diff --git a/src/shared/akranges.h b/src/shared/akranges.h
index d6923df06..055a40bc3 100644
--- a/src/shared/akranges.h
+++ b/src/shared/akranges.h
@@ -1,380 +1,372 @@
 /*
-    Copyright (C) 2018  Daniel Vrátil <dvratil@kde.org>
+    Copyright (C) 2018 - 2019  Daniel Vrátil <dvratil@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #ifndef AKONADI_AKRANGES_H
 #define AKONADI_AKRANGES_H
 
 #ifndef QT_STRICT_ITERATORS
 // Without strict iterator QVector<T>::iterator is just a typedef to T*,
 // which breaks some of the template magic below. QT_STRICT_ITERATORS
 // are a good thing anyway...
 #error AkRanges requires QT_STRICT_ITERATORS to be enabled.
 #endif
 
+#include "aktraits.h"
+
 #include <QVector>
 #include <QSet>
 #include <QDebug>
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 #include <type_traits>
 
 namespace Akonadi {
 
 namespace detail {
 
 template<template<typename> class Cont>
 struct To_
 {
     template<typename T> using Container = Cont<T>;
 };
 
-template<typename InContainer, typename OutContainer>
-OutContainer copyContainer(const InContainer &in, std::true_type)
+template<typename InContainer,
+         typename OutContainer,
+         AK_REQUIRES(AkTraits::isAppendable<OutContainer> && AkTraits::isReservable<OutContainer>)
+        >
+OutContainer copyContainer(const InContainer &in)
 {
     OutContainer rv;
     rv.reserve(in.size());
     for (auto &&v : in) {
         rv.push_back(std::move(v));
     }
     return rv;
 }
 
-template<typename InContainer, typename OutContainer>
-OutContainer copyContainer(const InContainer &in, std::false_type)
+template<typename InContainer,
+         typename OutContainer,
+         AK_REQUIRES(AkTraits::isInsertable<OutContainer>)
+        >
+OutContainer copyContainer(const InContainer &in)
 {
     OutContainer rv;
     for (const auto &v : in) {
-        rv.insert(v); // can't use std::inserter on QSet, sadly :/
+        rv.insert(v);
     }
     return rv;
 }
 
-template <typename...>
-using void_type = void;
-
-template <typename, template <typename> class, typename = void_type<>>
-struct has_method: std::false_type
-{};
+template<typename ...>
+using void_t = void;
 
-template <typename T, template <typename> class Op>
-struct has_method<T, Op, void_type<Op<T>>>: std::true_type
-{};
-
-template <typename T>
-using push_back = decltype(std::declval<T>().push_back({}));
+template<typename Fn, typename Arg,
+         typename = void>
+struct transformType;
 
 template<typename Fn, typename Arg>
-struct transformType
+struct transformType<Fn, Arg, void_t<decltype(std::declval<Fn>()(std::declval<Arg>()))>>
 {
-    using type = decltype(std::declval<Fn>()(Arg{}));
-};
-
-template<typename Arg>
-struct transformType<void*, Arg>
-{
-    using type = Arg;
+    using type = decltype(std::declval<Fn>()(std::declval<Arg>()));
 };
 
 template<typename Fn, typename ValueType>
 struct transformIteratorType
 {
     using type = typename transformType<Fn, ValueType>::type;
 };
 
 template<typename Fn, typename ValueType>
 using transformIteratorType_t = typename transformIteratorType<Fn, ValueType>::type;
 
 template<typename IterImpl,
          typename Iterator
         >
 struct IteratorBase
 {
 public:
     using iterator_category = typename Iterator::iterator_category;
     using value_type = typename Iterator::value_type;
     using difference_type = typename Iterator::difference_type;
     using pointer = typename Iterator::pointer;
     using reference = typename Iterator::reference;
 
     IteratorBase(const IteratorBase<IterImpl, Iterator> &other)
         : mIter(other.mIter)
     {}
 
     IterImpl &operator++()
     {
         ++static_cast<IterImpl*>(this)->mIter;
         return *static_cast<IterImpl*>(this);
     }
 
     IterImpl operator++(int)
     {
         auto ret = *static_cast<IterImpl*>(this);
         ++static_cast<IterImpl*>(this)->mIter;
         return ret;
     }
 
     bool operator==(const IterImpl &other) const
     {
         return mIter == other.mIter;
     }
 
     bool operator!=(const IterImpl &other) const
     {
         return !(*static_cast<const IterImpl*>(this) == other);
     }
 
     bool operator<(const IterImpl &other) const
     {
         return mIter < other.mIter;
     }
 
     auto operator-(const IterImpl &other) const
     {
         return mIter - other.mIter;
     }
 
     auto operator*() const
     {
         return *mIter;
     }
 
 protected:
     IteratorBase(const Iterator &iter)
         : mIter(iter)
     {}
 
     Iterator mIter;
 };
 
 template<typename Iterator,
          typename TransformFn,
          typename IteratorValueType = transformIteratorType_t<TransformFn, typename Iterator::value_type>
         >
 struct TransformIterator : public IteratorBase<TransformIterator<Iterator, TransformFn>, Iterator>
 {
 public:
     using value_type = IteratorValueType;
     using pointer = IteratorValueType *;         // FIXME: preserve const-ness
     using reference = const IteratorValueType &; // FIXME: preserve const-ness
 
     TransformIterator(const Iterator &iter, const TransformFn &fn)
         : IteratorBase<TransformIterator<Iterator, TransformFn>, Iterator>(iter)
         , mFn(fn)
     {}
 
     auto operator*() const
     {
         return mFn(*(this->mIter));
     }
 
 private:
     TransformFn mFn;
 };
 
 template<typename Iterator,
          typename Predicate
         >
 class FilterIterator : public IteratorBase<FilterIterator<Iterator, Predicate>, Iterator>
 {
 public:
     FilterIterator(const Iterator &iter, const Iterator &end, const Predicate &predicate)
         : IteratorBase<FilterIterator<Iterator, Predicate>, Iterator>(iter)
         , mPredicate(predicate), mEnd(end)
     {
         while (this->mIter != mEnd && !mPredicate(*this->mIter)) {
             ++this->mIter;
         }
     }
 
     FilterIterator<Iterator, Predicate> &operator++()
     {
         if (this->mIter != mEnd) {
             do {
                 ++this->mIter;
             } while (this->mIter != mEnd && !mPredicate(*this->mIter));
         }
         return *this;
     }
 
     FilterIterator<Iterator, Predicate> operator++(int)
     {
         auto it = *this;
         ++(*this);
         return it;
     }
 
 private:
     Predicate mPredicate;
     Iterator mEnd;
 };
 
 
 template<typename Iterator>
 struct Range
 {
 public:
     using iterator = Iterator;
     using const_iterator = Iterator;
     using value_type = typename Iterator::value_type;
 
     Range(Iterator &&begin, Iterator &&end)
         : mBegin(std::move(begin))
         , mEnd(std::move(end))
     {}
 
     Iterator begin() const
     {
         return mBegin;
     }
 
     Iterator cbegin() const
     {
         return mBegin;
     }
 
     Iterator end() const
     {
         return mEnd;
     }
 
     Iterator cend() const
     {
         return mEnd;
     }
 
     auto size() const
     {
         return mEnd - mBegin;
     }
 
 private:
     Iterator mBegin;
     Iterator mEnd;
 };
 
-
 template<typename T>
 using IsRange = typename std::is_same<T, Range<typename T::iterator>>;
 
 template<typename TransformFn>
 struct Transform_
 {
-    Transform_(const TransformFn &fn)
-        : mFn(fn)
-    {}
-
     const TransformFn &mFn;
 };
 
 template<typename PredicateFn>
 struct Filter_
 {
-    Filter_(const PredicateFn &fn)
-        : mFn(fn)
-    {}
-
     const PredicateFn &mFn;
 };
 
 } // namespace detail
 } // namespace Akonadi
 
 // Generic operator| for To_<> convertor
 template<typename InContainer,
          template<typename> class OutContainer,
          typename T = typename InContainer::value_type
         >
 auto operator|(const InContainer &in,
                const Akonadi::detail::To_<OutContainer> &) -> OutContainer<T>
 {
     using namespace Akonadi::detail;
-    return copyContainer<InContainer, OutContainer<T>>(
-            in, has_method<OutContainer<T>, push_back>{});
+    return copyContainer<InContainer, OutContainer<T>>(in);
 }
 
 // Specialization for case when InContainer and OutContainer are identical
+// Create a copy, but for Qt container this is very cheap due to implicit sharing.
 template<template<typename> class InContainer,
          typename T
         >
 auto operator|(const InContainer<T> &in,
                const Akonadi::detail::To_<InContainer> &) -> InContainer<T>
 {
     return in;
 }
 
 
 
 // Generic operator| for transform()
 template<typename InContainer,
          typename TransformFn
         >
 auto operator|(const InContainer &in,
                const Akonadi::detail::Transform_<TransformFn> &t)
 {
     using namespace Akonadi::detail;
     using OutIt = TransformIterator<typename InContainer::const_iterator, TransformFn>;
     return Range<OutIt>(OutIt(in.cbegin(), t.mFn), OutIt(in.cend(), t.mFn));
 }
 
 
 // Generic operator| for filter()
 template<typename InContainer,
          typename PredicateFn
         >
 auto operator|(const InContainer &in,
                const Akonadi::detail::Filter_<PredicateFn> &p)
 {
     using namespace Akonadi::detail;
     using OutIt = FilterIterator<typename InContainer::const_iterator, PredicateFn>;
     return Range<OutIt>(OutIt(in.cbegin(), in.cend(), p.mFn),
                         OutIt(in.cend(), in.cend(), p.mFn));
 }
 
 
 namespace Akonadi {
 
+/// Non-lazily convert given range or container to QVector
 static constexpr auto toQVector = detail::To_<QVector>{};
+/// Non-lazily convert given range or container to QSet
 static constexpr auto toQSet = detail::To_<QSet>{};
+/// Non-lazily convert given range or container to QList
 static constexpr auto toQList = detail::To_<QList>{};
 
+/// Lazily transform each element of a range or container using given transformation
 template<typename TransformFn>
 detail::Transform_<TransformFn> transform(TransformFn &&fn)
 {
-    return detail::Transform_<TransformFn>(std::forward<TransformFn>(fn));
+    return detail::Transform_<TransformFn>{std::forward<TransformFn>(fn)};
 }
 
+/// Lazily filters a range or container by applying given predicate on each element
 template<typename PredicateFn>
 detail::Filter_<PredicateFn> filter(PredicateFn &&fn)
 {
-    return detail::Filter_<PredicateFn>(std::forward<PredicateFn>(fn));
+    return detail::Filter_<PredicateFn>{std::forward<PredicateFn>(fn)};
 }
 
+/// Create a range, a view on a container from the given pair fo iterators
 template<typename Iterator1, typename Iterator2,
          typename It = std::remove_reference_t<Iterator1>
         >
 detail::Range<It> range(Iterator1 begin, Iterator2 end)
 {
     return detail::Range<It>(std::move(begin), std::move(end));
 }
 
 } // namespace Akonadi
 
 #endif
diff --git a/src/shared/aktraits.h b/src/shared/aktraits.h
new file mode 100644
index 000000000..0393a4b28
--- /dev/null
+++ b/src/shared/aktraits.h
@@ -0,0 +1,163 @@
+/*
+    Copyright (C) 2019  Daniel Vrátil <dvratil@kde.org>
+
+    This library is free software; you can redistribute it and/or modify it
+    under the terms of the GNU Library General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    This library is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
+    License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to the
+    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+    02110-1301, USA.
+*/
+
+#ifndef AKONADI_AKTRAITS_H_
+#define AKONADI_AKTRAITS_H_
+
+#include <type_traits>
+#include <utility>
+
+namespace Akonadi {
+namespace AkTraits {
+
+namespace detail {
+
+    /// Helpers from C++17
+    template<typename ...>
+    using void_t = void;
+
+    template<typename ...>
+    struct conjunction : std::true_type {};
+    template<typename T>
+    struct conjunction<T> : T {};
+    template<typename T, typename ... Ts>
+    struct conjunction<T, Ts...> : std::conditional_t<bool(T::value), conjunction<Ts...>, T> {};
+
+    /// Check for presence of member type
+    template<typename, typename = void_t<>>
+    struct hasMember {
+        static constexpr bool value = false;
+    };
+
+    template<typename T>
+    struct hasMember<T, void_t<T>> : std::true_type {};
+
+    /// TODO: Use Boost TTI instead?
+    #define DECLARE_HAS_METHOD_GENERIC_IMPL(name, fun, sign)        \
+        template<typename T, typename F = sign>                     \
+        struct hasMethod_##name {                                   \
+        public:                                                     \
+            template<typename UType, UType>                         \
+            struct helperClass;                                     \
+                                                                    \
+            using True = char;                                      \
+            using False = struct { char dummy_[2]; };               \
+                                                                    \
+            template<typename U>                                    \
+            static True helper(helperClass<F, &U::fun>*);\
+            template<typename>                                      \
+            static False helper(...);                  \
+        public:                                                     \
+            static constexpr bool value = sizeof(helper<T>(nullptr)) == sizeof(True); \
+        };
+
+    #define DECLARE_HAS_METHOD_GENERIC_CONST(fun, R, ...)           \
+        DECLARE_HAS_METHOD_GENERIC_IMPL(fun##_const, fun, R(T::*)(__VA_ARGS__) const)
+
+    #define DECLARE_HAS_METHOD_GENERIC(fun, R, ...)                 \
+        DECLARE_HAS_METHOD_GENERIC_IMPL(fun, fun, R(T::*)(__VA_ARGS__))
+
+    DECLARE_HAS_METHOD_GENERIC_CONST(size, int)
+    DECLARE_HAS_METHOD_GENERIC(push_back, void, const typename T::value_type &)
+    DECLARE_HAS_METHOD_GENERIC(insert, typename T::iterator, const typename T::value_type &)
+    DECLARE_HAS_METHOD_GENERIC(reserve, void, int)
+
+    #define DECLARE_HAS_FUNCTION(name, fun) \
+        template<typename T>                                        \
+        struct has_##name {                                         \
+            template<typename U>                                    \
+            struct helperClass;                                     \
+                                                                    \
+            using True = char;                                      \
+            using False = struct { char dummy_[2]; };               \
+                                                                    \
+            template<typename U>                                    \
+            static True helper(helperClass<decltype(fun(std::declval<T>()))>*); \
+            template<typename>                                      \
+            static False helper(...);                               \
+        public:                                                     \
+            static constexpr bool value = sizeof(helper<T>(nullptr)) == sizeof(True); \
+        };
+
+    // For some obscure reason QVector::begin() actually has a default
+    // argument, but QList::begin() does not, thus a regular hasMethod_* check
+    // won't cut it here. Instead we check whether the container object can be
+    // used with std::begin() and std::end() helpers.
+    // Check for constness can be performed by passing "const T" to the type.
+    DECLARE_HAS_FUNCTION(begin, std::begin)
+    DECLARE_HAS_FUNCTION(end, std::end)
+
+    /// This is a very incomplete set of Container named requirement, but I'm
+    /// too lazy to implement all of them, but this should be good enough to match
+    /// regular Qt containers and /not/ match arbitrary non-container types
+    template<typename T>
+    struct isContainer : conjunction<
+        std::is_constructible<T>,
+        hasMember<typename T::value_type>,
+        has_begin<T>,
+        has_begin<const T>,
+        has_end<T>,
+        has_end<const T>,
+        hasMethod_size_const<T>
+    > {};
+
+    /// Matches anything that is a container and has push_back() method.
+    template<typename T>
+    struct isAppendable : conjunction<
+        isContainer<T>,
+        hasMethod_push_back<T>
+    > {};
+
+    /// Matches anything that is a container and has insert() method.
+    template<typename T>
+    struct isInsertable : conjunction<
+        isContainer<T>,
+        hasMethod_insert<T>
+    > {};
+
+    /// Matches anything that is a container and has reserve() method.
+    template<typename T>
+    struct isReservable : conjunction<
+        isContainer<T>,
+        hasMethod_reserve<T>
+    > {};
+}
+
+template<typename T>
+constexpr bool isAppendable = detail::isAppendable<T>::value;
+
+template<typename T>
+constexpr bool isInsertable = detail::isInsertable<T>::value;
+
+template<typename T>
+constexpr bool isReservable = detail::isReservable<T>::value;
+
+}
+}
+
+#define AK_PP_CAT_(X, Y) X ## Y
+#define AK_PP_CAT(X, Y) AK_PP_CAT_(X, Y)
+
+#define AK_REQUIRES(...) \
+    bool AK_PP_CAT(_ak_requires_, __LINE__) = false, \
+    std::enable_if_t< \
+        AK_PP_CAT(_ak_requires_, __LINE__) || (__VA_ARGS__) \
+    >* = nullptr
+
+#endif