diff --git a/autotests/shared/akrangestest.cpp b/autotests/shared/akrangestest.cpp
index 3d3424b50..36242f9d5 100644
--- a/autotests/shared/akrangestest.cpp
+++ b/autotests/shared/akrangestest.cpp
@@ -1,372 +1,386 @@
 /*
     Copyright (c) 2018  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.
 */
 
 #include <QObject>
 #include <QTest>
 
 #include <shared/akranges.h>
 
 #include <iostream>
 
 using namespace Akonadi;
 
 namespace {
 
 int transformFreeFunc(int i)
 {
     return i * 2;
 }
 
 struct TransformHelper
 {
 public:
     static int transform(int i)
     {
         return transformFreeFunc(i);
     }
 
     int operator()(int i) const
     {
         return transformFreeFunc(i);
     }
 };
 
 bool filterFreeFunc(int i)
 {
     return i % 2 == 0;
 }
 
 struct FilterHelper
 {
 public:
     static bool filter(int i)
     {
         return filterFreeFunc(i);
     }
 
     bool operator()(int i)
     {
         return filterFreeFunc(i);
     }
 };
 
 }
 
 class AkRangesTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase()
     {
         qSetGlobalQHashSeed(0);
     }
 
     void testContainerConversion()
     {
         {
             QVector<int> in = { 1, 2, 3, 4, 5 };
             QCOMPARE(in | Akonadi::toQList, in.toList());
             QCOMPARE(in | Akonadi::toQList | Akonadi::toQVector, in);
             QCOMPARE(in | Akonadi::toQSet, in.toList().toSet());
         }
         {
             QList<int> in = { 1, 2, 3, 4, 5 };
             QCOMPARE(in | Akonadi::toQVector, in.toVector());
             QCOMPARE(in | Akonadi::toQVector | toQList, in);
             QCOMPARE(in | Akonadi::toQSet, in.toSet());
         }
     }
 
     void testRangeConversion()
     {
         {
             QList<int> in = { 1, 2, 3, 4, 5 };
             Akonadi::detail::Range<QList<int>::const_iterator> range(in.cbegin(), in.cend());
             QCOMPARE(in | Akonadi::toQVector, QVector<int>::fromList(in));
         }
 
         {
             QVector<int> in = { 1, 2, 3, 4, 5 };
             Akonadi::detail::Range<QVector<int>::const_iterator> range(in.cbegin(), in.cend());
             QCOMPARE(in | toQList, in.toList());
         }
     }
 
     void testTransform()
     {
         QList<int> in = { 1, 2, 3, 4, 5 };
         QList<int> out = { 2, 4, 6, 8, 10 };
         QCOMPARE(in | transform([](int i) { return i * 2; }) | toQList, out);
         QCOMPARE(in | transform(transformFreeFunc) | toQList, out);
         QCOMPARE(in | transform(&TransformHelper::transform) | toQList, out);
         QCOMPARE(in | transform(TransformHelper()) | toQList, out);
     }
 
 private:
     class CopyCounter {
     public:
         CopyCounter() = default;
         CopyCounter(const CopyCounter &other)
             : copyCount(other.copyCount + 1), transformed(other.transformed)
         {}
         CopyCounter(CopyCounter &&other) = default;
         CopyCounter &operator=(const CopyCounter &other) {
             copyCount = other.copyCount + 1;
             transformed = other.transformed;
             return *this;
         }
         CopyCounter &operator=(CopyCounter &&other) = default;
 
         int copyCount = 0;
         bool transformed = false;
     };
 
 private Q_SLOTS:
 
     void testTransformCopyCount()
     {
         {
             QList<CopyCounter> in = { {} }; // 1st copy (QList::append())
             QList<CopyCounter> out = in 
                 | transform([](const auto &c) {
                         CopyCounter r(c);   // 2nd copy (expected)
                         r.transformed = true;
                         return r; })
                 | toQList;                  // 3rd copy (QList::append())
             QCOMPARE(out.size(), in.size());
             QCOMPARE(out[0].copyCount, 3);
             QCOMPARE(out[0].transformed, true);
         }
 
         {
             QVector<CopyCounter> in(1); // construct vector of one element, so no copying
                                         // occurs at initialization
             QVector<CopyCounter> out = in
                 | transform([](const auto &c) {
                         CopyCounter r(c);   // 1st copy
                         r.transformed = true;
                         return r; })
                 | toQVector;
             QCOMPARE(out.size(), in.size());
             QCOMPARE(out[0].copyCount, 1);
             QCOMPARE(out[0].transformed, true);
         }
     }
 
     void testTransformConvert()
     {
         {
             QList<int> in = { 1, 2, 3, 4, 5 };
             QVector<int> out = { 2, 4, 6, 8, 10 };
             QCOMPARE(in | transform([](int i) { return i * 2; }) | toQVector, out);
         }
 
         {
             QVector<int> in = { 1, 2, 3, 4, 5 };
             QList<int> out = { 2, 4, 6, 8, 10 };
             QCOMPARE(in | transform([](int i) { return i * 2; }) | toQList, out);
         }
     }
 
     void testCreateRange()
     {
         {
             QList<int> in = { 1, 2, 3, 4, 5, 6 };
             QList<int> out = { 3, 4, 5 };
             QCOMPARE(range(in.begin() + 2, in.begin() + 5) | toQList, out);
         }
     }
 
     void testRangeWithTransform()
     {
         {
             QList<int> in = { 1, 2, 3, 4, 5, 6 };
             QList<int> out = { 6, 8, 10 };
             QCOMPARE(range(in.begin() + 2, in.begin() + 5)
                         | transform([](int i) { return i  * 2; })
                         | toQList,
                      out);
         }
     }
 
     void testTransformType()
     {
         {
             QStringList in = { QStringLiteral("foo"), QStringLiteral("foobar"), QStringLiteral("foob") };
             QList<int> out = { 3, 6, 4 };
             QCOMPARE(in | transform([](const auto &str) { return str.size(); }) | toQList, out);
         }
     }
 
     void testFilter()
     {
         {
             QList<int> in = { 1, 2, 3, 4, 5, 6, 7, 8 };
             QList<int> out = { 2, 4, 6, 8 };
             QCOMPARE(in | filter([](int i) { return i % 2 == 0; })
                         | toQList,
                      out);
             QCOMPARE(in | filter(filterFreeFunc) | toQList, out);
             QCOMPARE(in | filter(&FilterHelper::filter) | toQList, out);
             QCOMPARE(in | filter(FilterHelper()) | toQList, out);
         }
     }
 
     void testFilterTransform()
     {
         {
             QStringList in = { QStringLiteral("foo"), QStringLiteral("foobar"), QStringLiteral("foob") };
             QList<int> out = { 6 };
             QCOMPARE(in | transform(&QString::size)
                         | filter([](int i) { return i > 5; })
                         | toQList,
                      out);
             QCOMPARE(in | filter([](const auto &str) { return str.size() > 5; })
                         | transform(&QString::size)
                         | toQList,
                      out);
         }
     }
 
     void testTemporaryContainer()
     {
         const auto func = []{
             QStringList rv;
             for (int i = 0; i < 5; i++) {
                 rv.push_back(QString::number(i));
             }
             return rv;
         };
         {
             QList<int> out = { 0, 2, 4 };
             QCOMPARE(func() | transform([](const auto &str) { return str.toInt(); })
                             | filter([](int i) { return i % 2 == 0; })
                             | toQList,
                      out);
         }
         {
             QList<int> out = { 0, 2, 4 };
             QCOMPARE(func() | filter([](const auto &v) { return v.toInt() % 2 == 0; })
                             | transform([](const auto &str) { return str.toInt(); })
                             | toQList,
                      out);
         }
     }
 
     void testTemporaryRange()
     {
         const auto func = []{
             QStringList rv;
             for (int i = 0; i < 5; ++i) {
                 rv.push_back(QString::number(i));
             }
             return rv | transform([](const auto &str) { return str.toInt(); });
         };
         QList<int> out = { 1, 3 };
         QCOMPARE(func() | filter([](int i) { return i % 2 == 1; })
                         | toQList,
                  out);
     }
 
 private:
     struct ForEachCallable
     {
     public:
         ForEachCallable(QList<int> &out)
             : mOut(out) {}
 
         void operator()(int i) {
             mOut.push_back(i);
         }
 
         static void append(int i) {
             sOut.push_back(i);
         }
         static void clear() {
             sOut.clear();
         }
         static QList<int> sOut;
     private:
         QList<int> &mOut;
     };
 
 private Q_SLOTS:
     void testForEach()
     {
         const QList<int> in = { 1, 2, 3, 4, 5, 6 };
         {
             QList<int> out;
             in | forEach([&out](int v) { out.push_back(v); });
             QCOMPARE(out, in);
         }
         {
             QList<int> out;
             in | forEach(ForEachCallable(out));
             QCOMPARE(out, in);
         }
         {
             ForEachCallable::clear();
             in | forEach(&ForEachCallable::append);
             QCOMPARE(ForEachCallable::sOut, in);
         }
         {
             QList<int> out;
             QCOMPARE(in | forEach([&out](int v) { out.push_back(v); })
                         | filter([](int v){ return v % 2 == 0; })
                         | transform([](int v) { return v * 2; })
                         | toQList,
                      QList<int>({ 4, 8, 12 }));
             QCOMPARE(out, in);
         }
 
     }
 
 private:
     template<template<typename, typename> class Container>
     void testKeysValuesHelper()
     {
         const Container<int, QString> in = {
             { 1, QStringLiteral("1") },
             { 2, QStringLiteral("2") },
             { 3, QStringLiteral("3") }
         };
 
         {
             const QList<int> out = { 1, 2, 3 };
             QCOMPARE(out, in | keys | toQList);
         }
         {
             const QStringList out = { QStringLiteral("1"), QStringLiteral("2"), QStringLiteral("3") };
             QCOMPARE(out, in | values | toQList);
         }
     }
 
 private Q_SLOTS:
     void testKeysValues()
     {
         testKeysValuesHelper<QMap>();
         testKeysValuesHelper<QHash>();
     }
+
+    void testAll()
+    {
+        const QList<int> vals = { 2, 4, 6, 8, 10 };
+        QVERIFY(vals | all([](int v) { return v % 2 == 0; }));
+        QVERIFY(!(vals | all([](int v) { return v % 2 == 1; })));
+    }
+
+    void testAny()
+    {
+        const QList<int> vals = { 1, 3, 5, 7, 9 };
+        QVERIFY(vals | any([](int v) { return v % 2 == 1; }));
+        QVERIFY(!(vals | any([](int v) { return v % 2 == 0; })));
+    }
 };
 
 QList<int> AkRangesTest::ForEachCallable::sOut;
 
 QTEST_GUILESS_MAIN(AkRangesTest)
 
 #include "akrangestest.moc"
diff --git a/src/shared/akranges.h b/src/shared/akranges.h
index 6f9c04f1b..c95c0b560 100644
--- a/src/shared/akranges.h
+++ b/src/shared/akranges.h
@@ -1,481 +1,527 @@
 /*
     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
 
 #include "aktraits.h"
 #include "akhelpers.h"
 
 #include <QVector>
 #include <QSet>
 #include <QDebug>
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 #include <type_traits>
 #include <iterator>
 
 namespace Akonadi {
 
 namespace detail {
 
 template<template<typename> class Cont>
 struct To_
 {
     template<typename T> using Container = Cont<T>;
 };
 
 struct Values_ {};
 struct Keys_ {};
 
 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,
          AK_REQUIRES(AkTraits::isInsertable<OutContainer>)
         >
 OutContainer copyContainer(const InContainer &in)
 {
     OutContainer rv;
     for (const auto &v : in) {
         rv.insert(v);
     }
     return rv;
 }
 
 template<typename Iterator>
 struct IteratorTrait {
     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;
 };
 
 // Without QT_STRICT_ITERATORS QVector and QList iterators do not satisfy STL
 // iterator concepts since they are nothing more but typedefs to T* - for those
 // we need to provide custom traits.
 template<typename Iterator>
 struct IteratorTrait<Iterator*> {
     // QTypedArrayData::iterator::iterator_category
     using iterator_category = std::random_access_iterator_tag;
     using value_type = Iterator;
     using difference_type = int;
     using pointer = Iterator*;
     using reference = Iterator&;
 };
 
 template<typename Iterator>
 struct IteratorTrait<const Iterator *> {
     using iterator_category = std::random_access_iterator_tag;
     using value_type = Iterator;
     using difference_type = int;
     using pointer = const Iterator *;
     using reference = const Iterator &;
 };
 
 template<typename IterImpl,
          typename Container,
          typename Iterator = typename Container::const_iterator
         >
 struct IteratorBase
 {
 public:
     using iterator_category = typename IteratorTrait<Iterator>::iterator_category;
     using value_type = typename IteratorTrait<Iterator>::value_type;
     using difference_type = typename IteratorTrait<Iterator>::difference_type;
     using pointer = typename IteratorTrait<Iterator>::pointer;
     using reference = typename IteratorTrait<Iterator>::reference;
 
     IteratorBase(const IteratorBase<IterImpl, Container> &other)
         : mIter(other.mIter), mContainer(other.mContainer)
     {}
 
     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, const Container &container)
         : mIter(iter), mContainer(container)
     {}
     IteratorBase(const Iterator &iter, Container &&container)
         : mIter(iter), mContainer(std::move(container))
     {}
 
     Iterator mIter;
     Container mContainer;
 };
 
 template<typename Container,
          typename TransformFn,
          typename Iterator = typename Container::const_iterator
         >
 struct TransformIterator : public IteratorBase<TransformIterator<Container, TransformFn>, Container>
 {
 private:
     template<typename ... T>
     struct ResultOf;
 
     template<typename R, typename ... Args>
     struct ResultOf<R(Args ...)> {
         using type = R;
     };
 
     template<typename ... Ts>
     using FuncHelper = decltype(Akonadi::invoke(std::declval<Ts>() ...))(Ts ...);
     using IteratorValueType = typename ResultOf<FuncHelper<TransformFn, typename IteratorTrait<Iterator>::value_type>>::type;
 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, const Container &container)
         : IteratorBase<TransformIterator<Container, TransformFn>, Container>(iter, container)
         , mFn(fn)
     {
     }
 
     auto operator*() const
     {
         return Akonadi::invoke(mFn, *this->mIter);
     }
 
 private:
     TransformFn mFn;
 };
 
 template<typename Container,
          typename Predicate,
          typename Iterator = typename Container::const_iterator
         >
 class FilterIterator : public IteratorBase<FilterIterator<Container, Predicate>, Container>
 {
 public:
     FilterIterator(const Iterator &iter, const Iterator &end,
                    const Predicate &predicate,
                    const Container &container)
         : IteratorBase<FilterIterator<Container, Predicate>, Container>(iter, container)
         , mPredicate(predicate), mEnd(end)
     {
         while (this->mIter != mEnd && !Akonadi::invoke(mPredicate, *this->mIter)) {
             ++this->mIter;
         }
     }
 
     auto &operator++()
     {
         if (this->mIter != mEnd) {
             do {
                 ++this->mIter;
             } while (this->mIter != mEnd && !Akonadi::invoke(mPredicate, *this->mIter));
         }
         return *this;
     }
 
     auto operator++(int)
     {
         auto it = *this;
         ++(*this);
         return it;
     }
 
 private:
     Predicate mPredicate;
     Iterator mEnd;
 };
 
 
 template<typename Container,
          int Pos,
          typename Iterator = typename Container::const_key_value_iterator>
 class AssociativeContainerIterator
     : public IteratorBase<AssociativeContainerIterator<Container, Pos>, Container, Iterator>
 {
 public:
     using value_type = std::remove_const_t<std::remove_reference_t<
                             typename std::tuple_element<Pos, typename Iterator::value_type>::type>>;
     using pointer = std::add_pointer_t<value_type>;
     using reference = std::add_lvalue_reference_t<value_type>;
 
     AssociativeContainerIterator(const Iterator &iter, const Container &container)
         : IteratorBase<AssociativeContainerIterator<Container, Pos>, Container, Iterator>(iter, container)
     {}
 
     auto operator*() const
     {
         return std::get<Pos>(*this->mIter);
     }
 };
 
 template<typename Container>
 using AssociativeContainerKeyIterator = AssociativeContainerIterator<Container, 0>;
 template<typename Container>
 using AssociativeContainerValueIterator = AssociativeContainerIterator<Container, 1>;
 
 
 template<typename Iterator>
 struct Range
 {
 public:
     using iterator = Iterator;
     using const_iterator = Iterator;
     using value_type = typename detail::IteratorTrait<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 std::distance(mBegin, mEnd);
     }
 
 private:
     Iterator mBegin;
     Iterator mEnd;
 };
 
 template<typename T>
 using IsRange = typename std::is_same<T, Range<typename T::iterator>>;
 
 template<typename TransformFn>
 struct Transform_
 {
     TransformFn mFn;
 };
 
 template<typename PredicateFn>
 struct Filter_
 {
     PredicateFn mFn;
 };
 
 template<typename EachFun>
 struct ForEach_
 {
     EachFun mFn;
 };
 
+template<typename Predicate>
+struct All_
+{
+    Predicate mFn;
+};
+
+template<typename Predicate>
+struct Any_
+{
+    Predicate 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);
 }
 
 // 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<InContainer, TransformFn>;
     return Range<OutIt>(OutIt(std::cbegin(in), t.mFn, in), OutIt(std::cend(in), t.mFn, in));
 }
 
 
 // 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<InContainer, PredicateFn>;
     return Range<OutIt>(OutIt(std::cbegin(in), std::cend(in), p.mFn, in),
                         OutIt(std::cend(in), std::cend(in), p.mFn, in));
 }
 
 
 // Generic operator| fo foreach()
 template<typename InContainer,
          typename EachFun
         >
 auto operator|(const InContainer &in,
                Akonadi::detail::ForEach_<EachFun> fun)
 {
     std::for_each(std::cbegin(in), std::cend(in),
                   [&fun](const auto &val) {
                       Akonadi::invoke(fun.mFn, val);
                   });
     return in;
 }
 
+// Generic operator| for all
+template<typename InContainer,
+         typename PredicateFn
+        >
+auto operator|(const InContainer &in,
+               Akonadi::detail::All_<PredicateFn> fun)
+{
+    return std::all_of(std::cbegin(in), std::cend(in), fun.mFn);
+}
+
+// Generic operator| for any
+template<typename InContainer,
+         typename PredicateFn
+        >
+auto operator|(const InContainer &in,
+               Akonadi::detail::Any_<PredicateFn> fun)
+{
+    return std::any_of(std::cbegin(in), std::cend(in), fun.mFn);
+}
 
 // Generic operator| for keys
 template<typename InContainer>
 auto operator|(const InContainer &in, Akonadi::detail::Keys_)
 {
     using namespace Akonadi::detail;
     using OutIt = AssociativeContainerKeyIterator<InContainer>;
     return Range<OutIt>(OutIt(in.constKeyValueBegin(), in),
                         OutIt(in.constKeyValueEnd(), in));
 }
 
 
 // Generic operator| for values
 template<typename InContainer>
 auto operator|(const InContainer &in, Akonadi::detail::Values_)
 {
     using namespace Akonadi::detail;
     using OutIt = AssociativeContainerValueIterator<InContainer>;
     return Range<OutIt>(OutIt(in.constKeyValueBegin(), in),
                         OutIt(in.constKeyValueEnd(), in));
 }
 
+
 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 extract values from an associative container
 static constexpr auto values = detail::Values_{};
 /// Lazily extract keys from an associative container
 static constexpr auto keys = detail::Keys_{};
 
 /// 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)};
 }
 
 /// 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)};
 }
 
 /// Non-lazily call EachFun for each element of the container or range
 template<typename EachFun>
 detail::ForEach_<EachFun> forEach(EachFun &&fn)
 {
     return detail::ForEach_<EachFun>{std::forward<EachFun>(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));
 }
 
+/// Non-lazily check that all elements in the range satisfy given predicate
+template<typename Predicate>
+detail::All_<Predicate> all(Predicate &&fn)
+{
+    return detail::All_<Predicate>{std::forward<Predicate>(fn)};
+}
+
+/// Non-lazily check that at least one element in range satisfies the given predicate
+template<typename Predicate>
+detail::Any_<Predicate> any(Predicate &&fn)
+{
+    return detail::Any_<Predicate>{std::forward<Predicate>(fn)};
+}
+
 } // namespace Akonadi
 
 #endif