diff --git a/src/utils/contains.hpp b/src/utils/contains.hpp
index ea1dd16..0a26cc1 100644
--- a/src/utils/contains.hpp
+++ b/src/utils/contains.hpp
@@ -13,6 +13,12 @@
     container.find(container.begin()->first);
 };
 
+template <class T>
+concept HasMemberContains = requires(T container)
+{
+    container.contains(*container.begin());
+};
+
 } // namespace detail
 
 template <detail::HasMemberFind T>
@@ -22,6 +28,12 @@
     return container.find(key) != container.end();
 }
 
+template <detail::HasMemberContains T>
+inline bool contains(const T& container, const typename T::value_type& key)
+{
+    return container.contains(key);
+}
+
 template <class T>
 inline bool contains(const T& container, const typename T::value_type& key)
 {
diff --git a/src/utils/transform.hpp b/src/utils/transform.hpp
index 4a28950..fc52fc3 100644
--- a/src/utils/transform.hpp
+++ b/src/utils/transform.hpp
@@ -16,27 +16,29 @@
 
 } // namespace detail
 
-template <class R, class Container, class F>
-auto transform(const Container& container, F&& functor)
+template <template <class, class...> class R, class Container, class Functor>
+inline auto transform(const Container& container, Functor&& f)
 {
-    auto result = R{};
+    auto result = R<decltype(f(*container.begin()))>{};
 
     if constexpr (detail::has_member_reserve<decltype(result)>)
     {
         result.reserve(container.size());
     }
+
     std::transform(container.begin(), container.end(),
                    std::inserter(result, result.end()),
-                   std::forward<F>(functor));
+                   std::forward<Functor>(f));
+
     return result;
 }
 
-template <template <class, class...> class Container, class T, class... Args,
-          class F>
-auto transform(const Container<T, Args...>& container, F&& functor)
+template <template <class, class...> class Container, class Functor,
+          class... Args>
+inline auto transform(const Container<Args...>& container, Functor&& f)
 {
-    using R = Container<decltype(functor(*container.begin()))>;
-    return transform<R>(container, std::forward<F>(functor));
+    return transform<Container, Container<Args...>, Functor>(
+        container, std::forward<Functor>(f));
 }
 
 } // namespace utils