diff --git a/CMakeLists.txt b/CMakeLists.txt
index 59a7c6c..e445683 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -43,10 +43,12 @@ if(BUILD_TESTING AND ${KDALGORITHMS_BUILD_TEST})
     add_executable(tst_kdalgorithms
         src/kdalgorithms.h
 
-        src/bits/copy_or_move_iterators.h
+        src/bits/read_iterator_wrapper.h
         src/bits/filter.h
-        src/bits/has_reserve_trait.h
+        src/bits/insert_wrapper.h
         src/bits/is_const_method.h
+        src/bits/is_detected.h
+        src/bits/method_tests.h
         src/bits/operators.h
         src/bits/return_type_trait.h
         src/bits/shared.h
diff --git a/README.md b/README.md
index 0a20664..821e51e 100644
--- a/README.md
+++ b/README.md
@@ -81,6 +81,12 @@ Lots of Examples
 In this document you will find lots of examples. More, however, may be found in the 
 unit tests.
 
+Qt data types
+-------------
+A few of the functions (copy, filtered, and transform) need additional support for Qt 
+data types. Therefore, to us kdalgorithms together with Qt, you must include kdalgorithms_qt.h
+rather than kdalgorithms.h
+
 Algorithms
 ==========
 
@@ -183,7 +189,7 @@ auto toString = [] (int i) { return QString::number(i); }
 QVector<QString> result = kdalgorithms::transformed<QVector>(ints, toString);
 ```
 
-Finally ther is a version which does an inline transform:
+Finally there is a version which does an inline transform:
 
 ```
 std::vector<int> ints{1,2,3};
@@ -192,6 +198,29 @@ kdalgorithms::transform(ints, square);
 // ints = {1,4,9}
 ```
 
+transformed on maps
+-------------------
+The transform methods can unfortunately not automatically deduce the
+type of the result container - even when it is just the same type as the input container,
+therefore two additional methods are provided:
+
+```
+std::map<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+auto doubleKeys = [](const auto& item) {
+    return std::make_pair(item.first * 2, item.second);
+};
+auto result = kdalgorithms::transformed_to_same_container(map, doubleKeys);
+// result = {2, "abc"}, {4, "def"}, {6, "hij"}, {8, "klm"}
+```
+
+
+```
+std::map<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+auto result = kdalgorithms::transformed_with_new_return_type<std::map<std::string, int>>(
+    map, [](auto item) { return std::make_pair(item.second, item.first); });
+// result = {{"abc", 1}, {"def", 2}, {"hij", 3}, {"klm", 4}};
+```
+
 See [std::transform](https://en.cppreference.com/w/cpp/algorithm/transform) for the algorithm from the standard.
 
 <a name="reverse">reverse / reversed</a>
diff --git a/src/bits/filter.h b/src/bits/filter.h
index 05f166c..f260a24 100644
--- a/src/bits/filter.h
+++ b/src/bits/filter.h
@@ -1,6 +1,8 @@
 #pragma once
 
-#include "has_reserve_trait.h"
+#include "insert_wrapper.h"
+#include "method_tests.h"
+#include "read_iterator_wrapper.h"
 #include "shared.h"
 #include "to_function_object.h"
 #include <algorithm>
@@ -14,12 +16,12 @@ namespace detail {
     {
         ResultContainer result;
 #if __cplusplus >= 201703L
-        if constexpr (traits::has_reserve_method_v<ResultContainer>) {
+        if constexpr (detail::has_reserve_method_v<ResultContainer>) {
             result.reserve(input.size());
         }
 #endif
-        auto range = copy_or_move_iterators(std::forward<InputContainer>(input));
-        std::copy_if(range.begin, range.end, std::back_inserter(result),
+        auto range = read_iterator_wrapper(std::forward<InputContainer>(input));
+        std::copy_if(range.begin, range.end, detail::insert_wrapper(result),
                      std::forward<UnaryPredicate>(predicate));
         return result;
     }
diff --git a/src/bits/has_reserve_trait.h b/src/bits/has_reserve_trait.h
deleted file mode 100644
index 5711036..0000000
--- a/src/bits/has_reserve_trait.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <type_traits>
-
-namespace kdalgorithms {
-namespace traits {
-
-    template <typename... Ts>
-    struct make_void
-    {
-        typedef void type;
-    };
-
-    template <typename... Ts>
-    using void_t = typename make_void<Ts...>::type;
-
-    template <typename T, typename S = void_t<>>
-    struct has_reserve_method : std::false_type
-    {
-    };
-
-    template <typename T>
-    struct has_reserve_method<T, void_t<decltype(std::declval<T>().reserve(42))>> : std::true_type
-    {
-    };
-
-    template <typename T>
-    constexpr bool has_reserve_method_v = has_reserve_method<T>::value;
-
-} // namespace traits
-} // namespace kdalgorithms
diff --git a/src/bits/insert_wrapper.h b/src/bits/insert_wrapper.h
new file mode 100644
index 0000000..cb8fc54
--- /dev/null
+++ b/src/bits/insert_wrapper.h
@@ -0,0 +1,88 @@
+#pragma once
+
+#include "method_tests.h"
+#include <iterator>
+#include <utility>
+
+namespace kdalgorithms {
+namespace detail {
+    // similar to std::inserter, but calls insert with just one argument - required for QSet in Qt5
+    template <typename T>
+    class single_arg_inserter
+    {
+    public:
+        using value_type = typename T::value_type;
+        single_arg_inserter(T &set)
+            : m_set(set)
+        {
+        }
+
+        single_arg_inserter &operator++() { return *this; }
+        single_arg_inserter &operator*() { return *this; }
+        single_arg_inserter &operator=(const value_type &value)
+        {
+            m_set.insert(value);
+            return *this;
+        }
+
+    private:
+        T &m_set;
+    };
+
+    template <class Container, typename T>
+    using has_push_back = decltype(std::declval<Container &>().push_back(std::declval<T>()));
+
+    template <class Container, typename T>
+    using has_insert = decltype(std::declval<Container &>().insert(std::declval<T>()));
+
+    template <typename Container>
+    auto insert_wrapper(
+        Container &c,
+        std::enable_if_t<
+            detail::is_detected_v<has_push_back, Container, typename Container::value_type>, int> =
+            0)
+    {
+        return std::back_inserter(c);
+    }
+
+    template <typename Container>
+    auto insert_wrapper(
+        Container &c,
+        std::enable_if_t<
+            detail::is_detected_v<has_insert, Container, typename Container::value_type>, int> = 0)
+    {
+        return single_arg_inserter<Container>(c);
+    }
+
+    // similar to std::inserter, but for QMap/QHash which usually accept a value in their operator=
+    template <typename T>
+    class qmap_inserter
+    {
+    public:
+        qmap_inserter(T &map)
+            : m_map(map)
+        {
+        }
+
+        qmap_inserter &operator++() { return *this; }
+        qmap_inserter &operator*() { return *this; }
+        qmap_inserter &
+        operator=(const std::pair<typename T::key_type, typename T::mapped_type> &pair)
+        {
+            m_map.insert(pair.first, pair.second);
+            return *this;
+        }
+
+    private:
+        T &m_map;
+    };
+
+    template <typename Container>
+    auto insert_wrapper(Container &c,
+                        std::enable_if_t<detail::has_keyValueBegin_v<Container>, int> = 0)
+    {
+        return qmap_inserter<Container>(c);
+    }
+
+} // namespace detail
+} // namespace kdalgorithms
diff --git a/src/bits/is_detected.h b/src/bits/is_detected.h
new file mode 100644
index 0000000..611921d
--- /dev/null
+++ b/src/bits/is_detected.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <type_traits>
+
+// Inspired from std::experimental::is_detected
+// See https://en.cppreference.com/w/cpp/experimental/is_detected
+
+namespace kdalgorithms {
+namespace detail {
+    template <class AlwaysVoid, template <class...> class, typename... Args>
+    struct detector : std::false_type
+    {
+    };
+
+    template <template <class...> class Op, typename... Args>
+    struct detector<std::void_t<Op<Args...>>, Op, Args...> : std::true_type
+    {
+    };
+
+    template <template <class...> class Op, typename... Args>
+    using is_detected = detector<void, Op, Args...>;
+
+    template <template <class...> class Op, typename... Args>
+    static constexpr auto is_detected_v = detector<void, Op, Args...>::value;
+}
+}
diff --git a/src/bits/method_tests.h b/src/bits/method_tests.h
new file mode 100644
index 0000000..292c2d8
--- /dev/null
+++ b/src/bits/method_tests.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "is_detected.h"
+namespace kdalgorithms {
+
+namespace detail {
+    namespace tests {
+        template <typename Container>
+        using has_reserve = decltype(std::declval<Container>().reserve(42));
+
+        template <typename Container>
+        using has_keyValueBegin = decltype(std::declval<Container &>().keyValueBegin());
+
+        template <typename Container>
+        using has_keyValueBegin = decltype(std::declval<Container &>().keyValueBegin());
+    }
+
+    template <typename Container>
+    constexpr bool has_reserve_method_v = detail::is_detected_v<tests::has_reserve, Container>;
+
+    template <typename Container>
+    using has_keyValueBegin = detail::is_detected<tests::has_keyValueBegin, Container>;
+
+    template <typename Container>
+    constexpr bool has_keyValueBegin_v = detail::is_detected_v<tests::has_keyValueBegin, Container>;
+
+} // namespace detail
+} // namespace kdalgorithms
diff --git a/src/bits/copy_or_move_iterators.h b/src/bits/read_iterator_wrapper.h
similarity index 60%
rename from src/bits/copy_or_move_iterators.h
rename to src/bits/read_iterator_wrapper.h
index 7e338f2..4f3ed16 100644
--- a/src/bits/copy_or_move_iterators.h
+++ b/src/bits/read_iterator_wrapper.h
@@ -1,4 +1,5 @@
 #pragma once
+#include "method_tests.h"
 #include <iterator>
 #include <tuple>
 #include <type_traits>
@@ -21,27 +22,35 @@ namespace detail {
 
     // used for l-value containers
     template <typename Container>
-    auto copy_or_move_iterators_helper(const Container &container, std::true_type)
+    auto read_iterator_wrapper_helper(const Container &container, std::true_type, std::false_type)
     {
         return make_iteratorPair(container.cbegin(), container.cend());
     }
 
     // used for r-value containers
     template <typename Container>
-    auto copy_or_move_iterators_helper(Container &&container, std::false_type)
+    auto read_iterator_wrapper_helper(Container &&container, std::false_type, std::false_type)
     {
         return make_iteratorPair(std::make_move_iterator(container.begin()),
                                  std::make_move_iterator(container.end()));
     }
+
+    // Used for QHash and QMap containers
+    template <typename Container, typename T>
+    auto read_iterator_wrapper_helper(Container &&container, T, std::true_type)
+    {
+        return make_iteratorPair(container.constKeyValueBegin(), container.constKeyValueEnd());
+    }
 }
 
 // Depending on the value type of container - either l-value or r-value
 // return iterators that either copy elements out or that move elements out.
 template <typename Container>
-auto copy_or_move_iterators(Container &&container)
+auto read_iterator_wrapper(Container &&container)
 {
-    return detail::copy_or_move_iterators_helper(
-        std::forward<Container>(container), typename std::is_lvalue_reference<Container>::type());
+    return detail::read_iterator_wrapper_helper(
+        std::forward<Container>(container), typename std::is_lvalue_reference<Container>::type(),
+        detail::has_keyValueBegin<Container>());
 }
 
 } // namespace kdalgorithms
diff --git a/src/bits/shared.h b/src/bits/shared.h
index dfb1f23..3ba9515 100644
--- a/src/bits/shared.h
+++ b/src/bits/shared.h
@@ -21,8 +21,23 @@ using remove_cvref_t = typename std::remove_const<typename std::remove_reference
 #endif
 
 // -------------------- general helpers --------------------
+namespace detail {
+    template <typename T, typename = void>
+    struct ValueTypeHelper
+    {
+        using value_type = typename T::value_type;
+    };
+
+    // QMap doesn't have the value_type typedef, so we have to build that ourselves.
+    template <typename T>
+    struct ValueTypeHelper<T, std::void_t<typename T::mapped_type>>
+    {
+        using value_type = std::pair<const typename T::key_type, typename T::mapped_type>;
+    };
+}
+
 template <typename Container>
-using ValueType = typename remove_cvref_t<Container>::value_type;
+using ValueType = typename detail::ValueTypeHelper<remove_cvref_t<Container>>::value_type;
 
 // -------------------- concepts --------------------
 #if __cplusplus >= 202002L
diff --git a/src/bits/to_function_object.h b/src/bits/to_function_object.h
index 5782cdc..ba20998 100644
--- a/src/bits/to_function_object.h
+++ b/src/bits/to_function_object.h
@@ -28,7 +28,7 @@ namespace detail {
     }
 
     template <typename F>
-    auto to_function_object(F &&f)
+    decltype(auto) to_function_object(F &&f)
     {
         return detail::to_function_object_helper(std::forward<F>(f),
                                                  typename std::is_member_pointer<F>::type{});
diff --git a/src/bits/transform.h b/src/bits/transform.h
index ae97d88..529bca2 100644
--- a/src/bits/transform.h
+++ b/src/bits/transform.h
@@ -1,7 +1,9 @@
 #pragma once
 
-#include "has_reserve_trait.h"
+#include "insert_wrapper.h"
+#include "method_tests.h"
 #include "shared.h"
+#include "to_function_object.h"
 #include <algorithm>
 
 namespace kdalgorithms {
@@ -35,11 +37,12 @@ namespace detail {
     {
         ResultContainer result;
 #if __cplusplus >= 201703L
-        if constexpr (traits::has_reserve_method_v<ResultContainer>) {
+        if constexpr (detail::has_reserve_method_v<ResultContainer>) {
             result.reserve(input.size());
         }
 #endif
-        std::transform(input.cbegin(), input.cend(), std::back_inserter(result),
+        auto range = read_iterator_wrapper(std::forward<InputContainer>(input));
+        std::transform(range.begin, range.end, detail::insert_wrapper(result),
                        std::forward<Transform>(transform));
         return result;
     }
@@ -64,7 +67,7 @@ namespace detail {
             std::is_lvalue_reference<InputContainer>::value
                 || !std::is_same<ResultContainer, InputContainer>::value > ());
     }
-}
+} // namespace detail
 
 template <typename InputContainer, typename Transform>
 auto transformed(InputContainer &&input, Transform &&transform)
@@ -95,6 +98,23 @@ auto transformed(InputContainer &&input, Transform &&transform)
         detail::to_function_object(std::forward<Transform>(transform)));
 }
 
+template <typename InputContainer, typename Transform>
+auto transformed_to_same_container(InputContainer &&input, Transform &&transform)
+
+{
+    return detail::transformed<remove_cvref_t<InputContainer>, InputContainer, Transform>(
+        std::forward<InputContainer>(input),
+        detail::to_function_object(std::forward<Transform>(transform)));
+}
+
+template <typename ReturnType, typename InputContainer, typename Transform>
+auto transformed_with_new_return_type(InputContainer &&input, Transform &&transform)
+
+{
+    return detail::transformed<ReturnType>(std::forward<InputContainer>(input),
+                                           std::forward<Transform>(transform));
+}
+
 // -------------------- transform --------------------
 template <typename Container, typename UnaryPredicate>
 void transform(Container &input, UnaryPredicate &&predicate)
diff --git a/src/kdalgorithms.h b/src/kdalgorithms.h
index e56d730..7e187be 100644
--- a/src/kdalgorithms.h
+++ b/src/kdalgorithms.h
@@ -1,9 +1,10 @@
 #pragma once
 
-#include "bits/copy_or_move_iterators.h"
 #include "bits/filter.h"
-#include "bits/has_reserve_trait.h"
+#include "bits/insert_wrapper.h"
+#include "bits/method_tests.h"
 #include "bits/operators.h"
+#include "bits/read_iterator_wrapper.h"
 #include "bits/return_type_trait.h"
 #include "bits/shared.h"
 #include "bits/to_function_object.h"
@@ -27,33 +28,36 @@ requires ContainerOfType<OutputContainer, ValueType<InputContainer>>
 void copy(InputContainer &&input, OutputContainer &output)
 {
 #if __cplusplus >= 201703L
-    if constexpr (traits::has_reserve_method_v<OutputContainer>) {
+    if constexpr (detail::has_reserve_method_v<OutputContainer>) {
         output.reserve(input.size() + output.size());
     }
 #endif
-    auto range = copy_or_move_iterators(std::forward<InputContainer>(input));
-    std::copy(range.begin, range.end, std::back_inserter(output));
+    auto range = read_iterator_wrapper(std::forward<InputContainer>(input));
+    std::copy(range.begin, range.end, detail::insert_wrapper(output));
 }
 
 // -------------------- all_of / any_of / none_of --------------------
 template <typename Container, typename UnaryPredicate>
 bool any_of(const Container &container, UnaryPredicate &&predicate)
 {
-    return std::any_of(container.cbegin(), container.cend(),
+    auto range = read_iterator_wrapper(container);
+    return std::any_of(range.begin, range.end,
                        detail::to_function_object(std::forward<UnaryPredicate>(predicate)));
 }
 
 template <typename Container, typename UnaryPredicate>
 bool all_of(const Container &container, UnaryPredicate &&predicate)
 {
-    return std::all_of(container.cbegin(), container.cend(),
+    auto range = read_iterator_wrapper(container);
+    return std::all_of(range.begin, range.end,
                        detail::to_function_object(std::forward<UnaryPredicate>(predicate)));
 }
 
 template <typename Container, typename UnaryPredicate>
 bool none_of(const Container &container, UnaryPredicate &&predicate)
 {
-    return std::none_of(container.cbegin(), container.cend(),
+    auto range = read_iterator_wrapper(container);
+    return std::none_of(range.begin, range.end,
                         detail::to_function_object(std::forward<UnaryPredicate>(predicate)));
 }
 
@@ -134,7 +138,8 @@ requires UnaryPredicateOnContainerValues<UnaryPredicate, Container>
 #endif
 int count_if(const Container &container, UnaryPredicate &&predicate)
 {
-    return std::count_if(container.cbegin(), container.cend(),
+    auto range = read_iterator_wrapper(container);
+    return std::count_if(range.begin, range.end,
                          detail::to_function_object(std::forward<UnaryPredicate>(predicate)));
 }
 
@@ -149,6 +154,7 @@ requires BinaryPredicateOnContainerValues<Compare, Container>
 {
     if (container.empty())
         return {};
+
     return *std::max_element(container.cbegin(), container.cend(),
                              detail::to_function_object(std::forward<Compare>(compare)));
 }
@@ -225,7 +231,8 @@ requires std::is_invocable_r_v<ReturnType, BinaryOperation, ReturnType, ValueTyp
     ReturnType accumulate(const Container &container, BinaryOperation &&accumulateFunction,
                           ReturnType initialValue = {})
 {
-    return std::accumulate(container.cbegin(), container.cend(), initialValue,
+    auto range = read_iterator_wrapper(container);
+    return std::accumulate(range.begin, range.end, initialValue,
                            std::forward<BinaryOperation>(accumulateFunction));
 }
 
diff --git a/tests/tst_kdalgorithms.cpp b/tests/tst_kdalgorithms.cpp
index c46e63c..facaab9 100644
--- a/tests/tst_kdalgorithms.cpp
+++ b/tests/tst_kdalgorithms.cpp
@@ -5,6 +5,12 @@
 #include <QTest>
 #include <QVector>
 #include <algorithm>
+#include <deque>
+#include <forward_list>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
 #include <vector>
 
 namespace {
@@ -69,6 +75,7 @@ private Q_SLOTS:
     void filteredSameContainer();
     void filteredAsMove();
     void filterWithMemberFunction();
+    void filterOtherContainers();
     void filter();
     void transformedChangeContainer();
     void transformedSameContainer();
@@ -77,10 +84,12 @@ private Q_SLOTS:
     void transformedChangeDataType();
     void transformedWithRValue();
     void transformMemberFunction();
+    void transformOtherContainers();
     void transform();
     void anyOf();
     void allOf();
     void noneOf();
+    void anyAllNoneOtherContainers();
     void reverse();
     void reversed();
     void reversedEnsureMoveOnly();
@@ -105,6 +114,7 @@ private Q_SLOTS:
     void accumulateWithInitialValue();
     void accumulateDifferentReturnType();
     void accumulateWithAuto();
+    void accumulateWithMap();
     void get_first_match();
     void get_first_match_or_default();
     void remove_duplicates();
@@ -133,15 +143,109 @@ void TestAlgorithms::copy()
         QCOMPARE(list, expected);
     }
 
-#if 0 // Doesn't compile on mac
-    // This is the equivalent when using std::ranges
+    // deque
     {
-        QVector<int> result;
-        std::ranges::copy(intVector, std::back_inserter(result));
-        QVector<int> expected{1, 2, 3, 4};
-        QCOMPARE(result, expected);
+        std::deque<int> from{1, 2, 3, 4};
+        std::deque<int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // set
+    {
+        std::set<int> from{1, 2, 3, 4, 1, 3};
+        std::set<int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // unordered_set
+    {
+        std::unordered_set<int> from{1, 2, 3, 4, 1, 3};
+        std::unordered_set<int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // multiset
+    {
+        std::multiset<int> from{1, 2, 3, 4, 1, 3};
+        std::multiset<int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // unordered_multiset
+    {
+        std::unordered_multiset<int> from{1, 2, 3, 4, 1, 3};
+        std::unordered_multiset<int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // map
+    {
+        std::map<int, int> from{{1, 2}, {2, 3}, {4, 5}};
+        std::map<int, int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // multimap
+    {
+        std::multimap<int, int> from{{1, 2}, {2, 3}, {1, 3}, {4, 5}};
+        std::multimap<int, int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // unordered_map
+    {
+        std::unordered_map<int, int> from{{1, 2}, {2, 3}, {4, 5}};
+        std::unordered_map<int, int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // unordered_multimap
+    {
+        std::unordered_multimap<int, int> from{{1, 2}, {2, 3}, {1, 3}, {4, 5}};
+        std::unordered_multimap<int, int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // std::vector to std::set
+    {
+        std::set<int> set;
+        kdalgorithms::copy(intVector, set);
+        std::set<int> expected{1, 2, 3, 4};
+        QCOMPARE(set, expected);
+    }
+
+    // QSet
+    {
+        QSet<int> from{1, 2, 3, 4, 1, 3};
+        QSet<int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // QMap
+    {
+        QMap<int, int> from{{1, 2}, {2, 3}, {4, 5}};
+        QMap<int, int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
+    }
+
+    // QHash
+    {
+        QHash<int, int> from{{1, 2}, {2, 3}, {4, 5}};
+        QHash<int, int> to;
+        kdalgorithms::copy(from, to);
+        QCOMPARE(from, to);
     }
-#endif
 }
 
 std::vector<CopyObserver> getObserverVector()
@@ -241,6 +345,37 @@ void TestAlgorithms::filterWithMemberFunction()
     }
 }
 
+void TestAlgorithms::filterOtherContainers()
+{
+    {
+        auto result = kdalgorithms::filtered<std::set>(intVector, isOdd);
+        std::set<int> expected{1, 3};
+        QCOMPARE(result, expected);
+    }
+
+    {
+        auto result = kdalgorithms::filtered<QSet>(intVector, isOdd);
+        QSet<int> expected{1, 3};
+        QCOMPARE(result, expected);
+    }
+
+    {
+        std::map<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+        auto hasOddKey = [](auto item) { return item.first % 2 == 1; };
+        auto result = kdalgorithms::filtered(map, hasOddKey);
+        std::map<int, std::string> expected{{1, "abc"}, {3, "hij"}};
+        QCOMPARE(result, expected);
+    }
+
+    {
+        QMap<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+        auto hasOddKey = [](auto item) { return item.first % 2 == 1; };
+        auto result = kdalgorithms::filtered(map, hasOddKey);
+        QMap<int, std::string> expected{{1, "abc"}, {3, "hij"}};
+        QCOMPARE(result, expected);
+    }
+}
+
 void TestAlgorithms::filter()
 {
     std::vector<int> vec{1, 2, 3, 4};
@@ -355,6 +490,87 @@ void TestAlgorithms::transformMemberFunction()
     }
 }
 
+void TestAlgorithms::transformOtherContainers()
+{
+    {
+        auto result = kdalgorithms::transformed<std::set>(intVector, toString);
+        std::set<QString> expected{"1", "2", "3", "4"};
+        QCOMPARE(result, expected);
+    }
+
+    {
+        auto result = kdalgorithms::transformed<QSet>(intVector, toString);
+        QSet<QString> expected{"1", "2", "3", "4"};
+        QCOMPARE(result, expected);
+    }
+
+    // This unfortunately doesn't work as I have no way to deduce the result type of the transform
+    // to match a container We would end up with std::vector<std::map<std::pair<int,string>>
+    // instead we now have kdalgorithms::transformed_to_same_container
+    /*
+    {
+        std::map<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+        auto doubleKeys = [](const std::pair<int, std::string> &item) {
+            return std::pair(item.first * 2, item.second);
+        };
+        auto result = kdalgorithms::transformed(map, doubleKeys);
+        std::map<int, std::string> expected{{1, "abc"}, {4, "def"}, {6, "hij"}, {8, "klm"}};
+        QCOMPARE(result, expected);
+    }
+    */
+    {
+        std::map<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+        auto doubleKeys = [](const auto &item) {
+            return std::make_pair(item.first * 2, item.second);
+        };
+        auto result = kdalgorithms::transformed_to_same_container(map, doubleKeys);
+        std::map<int, std::string> expected{{2, "abc"}, {4, "def"}, {6, "hij"}, {8, "klm"}};
+        QCOMPARE(result, expected);
+    }
+
+    {
+        QMap<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+        auto doubleKeys = [](const auto &item) {
+            return std::make_pair(item.first * 2, item.second);
+        };
+        auto result = kdalgorithms::transformed_to_same_container(map, doubleKeys);
+        QMap<int, std::string> expected{{2, "abc"}, {4, "def"}, {6, "hij"}, {8, "klm"}};
+        QCOMPARE(result, expected);
+    }
+
+    {
+        auto squareItem = [](int i) { return i * i; };
+        auto result = kdalgorithms::transformed_to_same_container(intVector, squareItem);
+        std::vector<int> expected{1, 4, 9, 16};
+        QCOMPARE(result, expected);
+    }
+
+    {
+        std::map<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+        auto result = kdalgorithms::transformed_with_new_return_type<std::map<std::string, int>>(
+            map, [](const auto &item) { return std::make_pair(item.second, item.first); });
+        std::map<std::string, int> expected{{"abc", 1}, {"def", 2}, {"hij", 3}, {"klm", 4}};
+        QCOMPARE(result, expected);
+    }
+
+    {
+        QMap<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+        auto result = kdalgorithms::transformed_with_new_return_type<QMap<std::string, int>>(
+            map, [](const auto &item) { return std::make_pair(item.second, item.first); });
+        QMap<std::string, int> expected{{"abc", 1}, {"def", 2}, {"hij", 3}, {"klm", 4}};
+        QCOMPARE(result, expected);
+    }
+
+    {
+        std::map<int, std::string> map{{1, "abc"}, {2, "abc"}, {3, "hij"}, {4, "klm"}};
+        auto result =
+            kdalgorithms::transformed_with_new_return_type<std::multimap<std::string, int>>(
+                map, [](const auto &item) { return std::make_pair(item.second, item.first); });
+        std::multimap<std::string, int> expected{{"abc", 1}, {"abc", 2}, {"hij", 3}, {"klm", 4}};
+        QCOMPARE(result, expected);
+    }
+}
+
 void TestAlgorithms::transform()
 {
     std::vector<int> vec{1, 2, 3, 4};
@@ -420,6 +636,29 @@ void TestAlgorithms::noneOf()
     QCOMPARE(res, true);
 }
 
+void TestAlgorithms::anyAllNoneOtherContainers()
+{
+    auto has_key = [](int value) { return [value](auto item) { return item.first == value; }; };
+
+    {
+        std::map<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+        QVERIFY(kdalgorithms::any_of(map, has_key(2)));
+        QVERIFY(!kdalgorithms::any_of(map, has_key(42)));
+        QVERIFY(!kdalgorithms::all_of(map, has_key(2)));
+        QVERIFY(kdalgorithms::none_of(map, has_key(42)));
+        QVERIFY(!kdalgorithms::none_of(map, has_key(2)));
+    }
+
+    {
+        QMap<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}, {4, "klm"}};
+        QVERIFY(kdalgorithms::any_of(map, has_key(2)));
+        QVERIFY(!kdalgorithms::any_of(map, has_key(42)));
+        QVERIFY(!kdalgorithms::all_of(map, has_key(2)));
+        QVERIFY(kdalgorithms::none_of(map, has_key(42)));
+        QVERIFY(!kdalgorithms::none_of(map, has_key(2)));
+    }
+}
+
 void TestAlgorithms::reverse()
 {
     std::vector<int> vec{1, 2, 3, 4};
@@ -569,12 +808,26 @@ void TestAlgorithms::count()
 
 void TestAlgorithms::count_if()
 {
-    std::vector<int> vec{1, 2, 1, 3, 2, 1, 5};
-    auto result = kdalgorithms::count_if(vec, [](int i) { return i > 2; });
-    QCOMPARE(result, 2);
+    {
+        std::vector<int> vec{1, 2, 1, 3, 2, 1, 5};
+        auto result = kdalgorithms::count_if(vec, [](int i) { return i > 2; });
+        QCOMPARE(result, 2);
+
+        result = kdalgorithms::count_if(structVec, &Struct::isKeyGreaterThanValue);
+        QCOMPARE(result, 2);
+    }
 
-    result = kdalgorithms::count_if(structVec, &Struct::isKeyGreaterThanValue);
-    QCOMPARE(result, 2);
+    {
+        std::map<int, std::string> map{{2, "abc"}, {4, "def"}, {6, "hij"}, {8, "klm"}};
+        auto result = kdalgorithms::count_if(map, [](auto item) { return item.first > 5; });
+        QCOMPARE(result, 2);
+    }
+
+    {
+        QMap<int, std::string> map{{2, "abc"}, {4, "def"}, {6, "hij"}, {8, "klm"}};
+        auto result = kdalgorithms::count_if(map, [](auto item) { return item.first > 5; });
+        QCOMPARE(result, 2);
+    }
 }
 
 void TestAlgorithms::max()
@@ -600,6 +853,14 @@ void TestAlgorithms::max()
         Struct expected{4, 1};
         QCOMPARE(*result, expected);
     }
+
+    {
+        std::map<int, int> map{{1, 1}, {2, 3}, {4, 2}};
+        auto lessthan = [](auto x, auto y) { return x.second < y.second; };
+        auto result = kdalgorithms::max_element(map, lessthan);
+        std::pair<const int, int> expected{2, 3};
+        QCOMPARE(*result, expected);
+    }
 #endif
 }
 
@@ -643,6 +904,10 @@ void TestAlgorithms::maxValueLessThan()
 
     result = kdalgorithms::max_value_less_than(emptyIntVector, 10);
     QVERIFY(!result.has_value());
+
+    std::set<int> set{1, 12, 3, 4, -23};
+    result = kdalgorithms::max_value_less_than(set, 4);
+    QCOMPARE(*result, 3);
 #endif
 }
 
@@ -675,6 +940,10 @@ void TestAlgorithms::minValueGreaterThan()
 
     result = kdalgorithms::min_value_greater_than(emptyIntVector, 10);
     QVERIFY(!result.has_value());
+
+    std::set<int> set{1, 12, 3, 4, -23};
+    result = kdalgorithms::min_value_greater_than(set, 3);
+    QCOMPARE(*result, 4);
 #endif
 }
 
@@ -765,6 +1034,26 @@ void TestAlgorithms::accumulateWithAuto()
     QCOMPARE(stringResult, "0,1,2,3,4");
 }
 
+void TestAlgorithms::accumulateWithMap()
+{
+    QMap<int, std::string> map{{1, "abc"}, {2, "def"}, {3, "hij"}};
+    {
+        auto sum = [](int subResult, const std::pair<int, std::string> &pair) {
+            return subResult + pair.first;
+        };
+        auto result = kdalgorithms::accumulate(map, sum);
+        QCOMPARE(result, 6);
+    }
+    {
+        auto concatenate = [](const std::string &subResult,
+                              const std::pair<int, std::string> &pair) {
+            return subResult + "/" + pair.second;
+        };
+        auto result = kdalgorithms::accumulate(map, concatenate);
+        QCOMPARE(result, "/abc/def/hij");
+    }
+}
+
 void TestAlgorithms::get_first_match()
 {
 #if __cplusplus >= 201703L
@@ -785,6 +1074,14 @@ void TestAlgorithms::get_first_match()
         Struct expected{3, 3};
         QCOMPARE(value.value(), expected);
     }
+
+    {
+        std::map<int, int> map{{1, 2}, {2, 1}, {3, 3}, {4, 1}};
+        auto valueEqualToKey = [](const auto &pair) { return pair.first == pair.second; };
+        auto value = kdalgorithms::get_first_match(map, valueEqualToKey);
+        std::pair<const int, int> expected{3, 3};
+        QCOMPARE(value.value(), expected);
+    }
 #endif
 }
 
@@ -806,6 +1103,14 @@ void TestAlgorithms::get_first_match_or_default()
     value = kdalgorithms::get_first_match_or_default(structVec, &Struct::hasEqualKeyValuePair,
                                                      defaultValue);
     QCOMPARE(value, defaultValue);
+
+    {
+        std::map<int, int> map{{1, 2}, {2, 1}, {13, 3}, {4, 1}};
+        auto valueEqualToKey = [](const auto &pair) { return pair.first == pair.second; };
+        auto value = kdalgorithms::get_first_match_or_default(map, valueEqualToKey);
+        std::pair<const int, int> expected{0, 0};
+        QCOMPARE(value, expected);
+    }
 }
 
 void TestAlgorithms::remove_duplicates()