diff --git a/.circleci/tests.unit1.algorithms b/.circleci/tests.unit1.algorithms
index d35e591525da..66c4f0f179a3 100644
--- a/.circleci/tests.unit1.algorithms
+++ b/.circleci/tests.unit1.algorithms
@@ -10,6 +10,7 @@ tests.unit.modules.algorithms.algorithms.adjacentfind
 tests.unit.modules.algorithms.algorithms.adjacentfind_binary
 tests.unit.modules.algorithms.algorithms.all_of
 tests.unit.modules.algorithms.algorithms.any_of
+tests.unit.modules.algorithms.algorithms.contains
 tests.unit.modules.algorithms.algorithms.copy
 tests.unit.modules.algorithms.algorithms.copyif_random
 tests.unit.modules.algorithms.algorithms.copyif_forward
diff --git a/libs/core/algorithms/CMakeLists.txt b/libs/core/algorithms/CMakeLists.txt
index 6d10912d4d63..97328782bd9c 100644
--- a/libs/core/algorithms/CMakeLists.txt
+++ b/libs/core/algorithms/CMakeLists.txt
@@ -15,6 +15,7 @@ set(algorithms_headers
     hpx/parallel/algorithms/adjacent_difference.hpp
     hpx/parallel/algorithms/adjacent_find.hpp
     hpx/parallel/algorithms/all_any_none.hpp
+    hpx/parallel/algorithms/contains.hpp
     hpx/parallel/algorithms/copy.hpp
     hpx/parallel/algorithms/count.hpp
     hpx/parallel/algorithms/destroy.hpp
@@ -23,6 +24,7 @@ set(algorithms_headers
     hpx/parallel/algorithms/detail/accumulate.hpp
     hpx/parallel/algorithms/detail/advance_and_get_distance.hpp
     hpx/parallel/algorithms/detail/advance_to_sentinel.hpp
+    hpx/parallel/algorithms/detail/contains.hpp
     hpx/parallel/algorithms/detail/dispatch.hpp
     hpx/parallel/algorithms/detail/distance.hpp
     hpx/parallel/algorithms/detail/equal.hpp
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithm.hpp b/libs/core/algorithms/include/hpx/parallel/algorithm.hpp
index 4aedd3d820c7..309cdf842b25 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithm.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithm.hpp
@@ -16,6 +16,7 @@
 // Parallelism TS V1
 #include <hpx/parallel/algorithms/adjacent_find.hpp>
 #include <hpx/parallel/algorithms/all_any_none.hpp>
+#include <hpx/parallel/algorithms/contains.hpp>
 #include <hpx/parallel/algorithms/copy.hpp>
 #include <hpx/parallel/algorithms/count.hpp>
 #include <hpx/parallel/algorithms/equal.hpp>
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/contains.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/contains.hpp
new file mode 100644
index 000000000000..ea7d6b63f200
--- /dev/null
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/contains.hpp
@@ -0,0 +1,130 @@
+//  Copyright (c) 2024 Zakaria Abdi
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <hpx/config.hpp>
+#include <hpx/coroutines/thread_enums.hpp>
+#include <hpx/execution/algorithms/detail/predicates.hpp>
+#include <hpx/executors/execution_policy.hpp>
+#include <hpx/iterator_support/traits/is_iterator.hpp>
+#include <hpx/parallel/algorithms/detail/contains.hpp>
+#include <hpx/parallel/algorithms/detail/dispatch.hpp>
+#include <hpx/parallel/algorithms/detail/distance.hpp>
+#include <hpx/parallel/util/adapt_placement_mode.hpp>
+#include <hpx/parallel/util/cancellation_token.hpp>
+#include <hpx/parallel/util/detail/algorithm_result.hpp>
+#include <hpx/parallel/util/loop.hpp>
+#include <hpx/parallel/util/partitioner.hpp>
+#include <hpx/parallel/util/zip_iterator.hpp>
+#include <hpx/type_support/identity.hpp>
+
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+namespace hpx::parallel { namespace detail {
+    struct contains : public algorithm<contains, bool>
+    {
+        constexpr contains() noexcept
+          : algorithm("contains")
+        {
+        }
+
+        template <typename ExPolicy, typename Iterator, typename Sentinel,
+            typename T, typename Proj>
+        static constexpr bool sequential(
+            ExPolicy, Iterator first, Sentinel last, const T& val, Proj&& proj)
+        {
+            return sequential_contains<std::decay<ExPolicy>>(
+                first, last, val, HPX_FORWARD(Proj, proj));
+        }
+
+        template <typename ExPolicy, typename Iterator, typename Sentinel,
+            typename T, typename Proj>
+        static util::detail::algorithm_result_t<ExPolicy, bool> parallel(
+            ExPolicy&& orgpolicy, Iterator first, Sentinel last, const T& val,
+            Proj&& proj)
+        {
+            const std::size_t count = detail::distance(first, last);
+            if (count <= 0)
+                return util::detail::algorithm_result<ExPolicy, bool>::get(
+                    false);
+
+            decltype(auto) policy = parallel::util::adapt_placement_mode(
+                HPX_FORWARD(ExPolicy, orgpolicy),
+                hpx::threads::thread_placement_hint::breadth_first);
+
+            using policy_type = std::decay_t<decltype(policy)>;
+            util::cancellation_token<> tok;
+            auto f1 = [val, tok, proj](Iterator first, std::size_t count) {
+                sequential_contains<policy_type>(first, val, count, tok, proj);
+                return tok.was_cancelled();
+            };
+
+            auto f2 = [](auto&& results) {
+                return std::any_of(hpx::util::begin(results),
+                    hpx::util::end(results),
+                    [](hpx::future<bool>& val) { return val.get(); });
+            };
+
+            return util::partitioner<policy_type, bool>::call(
+                HPX_FORWARD(decltype(policy), policy), first, count,
+                HPX_MOVE(f1), HPX_MOVE(f2));
+        }
+    };
+}}    // namespace hpx::parallel::detail
+namespace hpx {
+
+    inline constexpr struct contains_t final
+      : hpx::functional::detail::tag_fallback<contains_t>
+    {
+    private:
+        template <typename Iterator, typename Sentinel, typename T,
+            typename Proj = hpx::identity,
+            HPX_CONCEPT_REQUIRES_(hpx::traits::is_iterator_v<Iterator>&& hpx::
+                    traits::is_iterator_v<Iterator>&& hpx::is_invocable_v<Proj,
+                        typename std::iterator_traits<Iterator>::value_type>)>
+
+        friend bool tag_fallback_invoke(hpx::contains_t, Iterator first,
+            Sentinel last, const T& val, Proj&& proj = Proj())
+        {
+            static_assert(hpx::traits::is_input_iterator_v<Iterator>,
+                "Required at least input iterator.");
+
+            static_assert(hpx::traits::is_input_iterator_v<Sentinel>,
+                "Required at least input iterator.");
+
+            return hpx::parallel::detail::contains().call(
+                hpx::execution::seq, first, last, val, proj);
+        }
+
+        template <typename ExPolicy, typename Iterator, typename Sentinel,
+            typename T, typename Proj = hpx::identity,
+            HPX_CONCEPT_REQUIRES_(hpx::is_execution_policy_v<
+                ExPolicy>&& hpx::traits::is_iterator_v<Iterator>&& hpx::traits::
+                    is_iterator_v<Iterator>&& hpx::is_invocable_v<Proj,
+                        typename std::iterator_traits<Iterator>::value_type>)>
+
+        friend typename parallel::util::detail::algorithm_result<ExPolicy,
+            bool>::type
+        tag_fallback_invoke(hpx::contains_t, ExPolicy&& policy, Iterator first,
+            Sentinel last, T const& val, Proj&& proj = Proj())
+        {
+            static_assert(hpx::traits::is_iterator_v<Iterator>,
+                "Required at least iterator.");
+
+            static_assert(hpx::traits::is_iterator_v<Sentinel>,
+                "Required at least iterator.");
+
+            return hpx::parallel::detail::contains().call(
+                HPX_FORWARD(ExPolicy, policy), first, last, val,
+                HPX_FORWARD(Proj, proj));
+        }
+
+    } contains{};
+}    // namespace hpx
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/detail/contains.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/detail/contains.hpp
new file mode 100644
index 000000000000..02cbccdc1981
--- /dev/null
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/detail/contains.hpp
@@ -0,0 +1,61 @@
+//  Copyright (c) 2024 Zakaria Abdi
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <hpx/config.hpp>
+#include <hpx/functional/detail/tag_fallback_invoke.hpp>
+#include <hpx/functional/invoke.hpp>
+#include <hpx/parallel/util/loop.hpp>
+
+#include <algorithm>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+namespace hpx::parallel::detail {
+
+    template <typename ExPolicy>
+    struct sequential_contains_t final
+      : hpx::functional::detail::tag_fallback<sequential_contains_t<ExPolicy>>
+    {
+    private:
+        template <typename Iterator, typename Sentinel, typename T,
+            typename Proj>
+        friend constexpr bool tag_fallback_invoke(sequential_contains_t,
+            Iterator first, Sentinel last, const T& val, Proj&& proj)
+        {
+            const std::size_t distance = detail::distance(first, last);
+            if (distance <= 0)
+                return false;
+
+            const auto itr =
+                util::loop_pred<std::decay_t<hpx::execution::sequenced_policy>>(
+                    first, last, [&val, &proj](const auto& cur) {
+                        return HPX_INVOKE(proj, *cur) == val;
+                    });
+
+            return itr != last;
+        }
+
+        template <typename Iterator, typename T, typename Token, typename Proj>
+        friend constexpr void tag_fallback_invoke(sequential_contains_t,
+            Iterator first, T const& val, std::size_t count, Token& tok,
+            Proj&& proj)
+        {
+            util::loop_n<ExPolicy>(
+                first, count, tok, [&val, &tok, &proj](const auto& cur) {
+                    if (HPX_INVOKE(proj, *cur) == val)
+                    {
+                        tok.cancel();
+                        return;
+                    }
+                });
+        }
+    };
+    template <typename ExPolicy>
+    inline constexpr sequential_contains_t<ExPolicy> sequential_contains =
+        sequential_contains_t<ExPolicy>{};
+}    //namespace hpx::parallel::detail
diff --git a/libs/core/algorithms/tests/unit/algorithms/CMakeLists.txt b/libs/core/algorithms/tests/unit/algorithms/CMakeLists.txt
index c5d009222d47..d31db556e772 100644
--- a/libs/core/algorithms/tests/unit/algorithms/CMakeLists.txt
+++ b/libs/core/algorithms/tests/unit/algorithms/CMakeLists.txt
@@ -23,6 +23,7 @@ set(tests
     adjacentfind_binary
     all_of
     any_of
+    contains
     copy
     copyif_random
     copyif_forward
diff --git a/libs/core/algorithms/tests/unit/algorithms/contains.cpp b/libs/core/algorithms/tests/unit/algorithms/contains.cpp
new file mode 100644
index 000000000000..ef5f4250a847
--- /dev/null
+++ b/libs/core/algorithms/tests/unit/algorithms/contains.cpp
@@ -0,0 +1,112 @@
+//  Copyright (c) 2024 Zakaria Abdi
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <hpx/init.hpp>
+#include "contains_tests.hpp"
+
+////////////////////////////////////////////////////////////////////////////
+template <typename IteratorTag>
+void test_contains()
+{
+    using namespace hpx::execution;
+
+    test_contains(IteratorTag());
+
+    test_contains(seq, IteratorTag());
+    test_contains(par, IteratorTag());
+    test_contains(par_unseq, IteratorTag());
+
+    test_contains_async(seq(task), IteratorTag());
+    test_contains_async(par(task), IteratorTag());
+    test_contains_async(par_unseq(task), IteratorTag());
+}
+
+void contains_test()
+{
+    test_contains<std::random_access_iterator_tag>();
+    test_contains<std::forward_iterator_tag>();
+}
+
+////////////////////////////////////////////////////////////////////////////
+template <typename IteratorTag>
+void test_contains_exception()
+{
+    using namespace hpx::execution;
+
+    test_contains_exception(IteratorTag());
+
+    test_contains_exception(seq, IteratorTag());
+    test_contains_exception(par, IteratorTag());
+
+    test_contains_exception_async(seq(task), IteratorTag());
+    test_contains_exception_async(par(task), IteratorTag());
+}
+
+void contains_exception_test()
+{
+    test_contains_exception<std::random_access_iterator_tag>();
+    test_contains_exception<std::forward_iterator_tag>();
+}
+
+////////////////////////////////////////////////////////////////////////////
+template <typename IteratorTag>
+void test_contains_bad_alloc()
+{
+    using namespace hpx::execution;
+
+    test_contains_bad_alloc(seq, IteratorTag());
+    test_contains_bad_alloc(par, IteratorTag());
+
+    test_contains_bad_alloc_async(seq(task), IteratorTag());
+    test_contains_bad_alloc_async(par(task), IteratorTag());
+}
+
+void contains_bad_alloc_test()
+{
+    test_contains_bad_alloc<std::random_access_iterator_tag>();
+    test_contains_bad_alloc<std::forward_iterator_tag>();
+}
+
+int hpx_main(hpx::program_options::variables_map& vm)
+{
+    if (vm.count("seed"))
+        seed = vm["seed"].as<unsigned int>();
+
+    std::cout << "Using seed as: " << seed << std::endl;
+    gen.seed(seed);
+
+    contains_test();
+    contains_exception_test();
+    contains_bad_alloc_test();
+
+    return hpx::local::finalize();
+}
+
+int main(int argc, char* argv[])
+{
+    using namespace hpx::program_options;
+    options_description desc_commandline(
+        "Usage" HPX_APPLICATION_STRING " [options]");
+
+    desc_commandline.add_options()("seed,s", value<unsigned int>(),
+        " the random number generator to use for this run");
+
+    std::vector<std::string> cfg = {"hpx.os_threads=all"};
+
+    hpx::local::init_params init_args;
+    init_args.desc_cmdline = desc_commandline;
+    init_args.cfg = cfg;
+
+    HPX_TEST_EQ_MSG(hpx::local::init(hpx_main, argc, argv, init_args), 0,
+        "HPX main exited with non-zero status");
+
+    return hpx::util::report_errors();
+}
diff --git a/libs/core/algorithms/tests/unit/algorithms/contains_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/contains_tests.hpp
new file mode 100644
index 000000000000..8d0505d204a3
--- /dev/null
+++ b/libs/core/algorithms/tests/unit/algorithms/contains_tests.hpp
@@ -0,0 +1,385 @@
+//  Copyright (c) 2024 Zakaria Abdi
+//  SPDX-License-Identifier: BSL-1.0
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <hpx/algorithm.hpp>
+#include <hpx/execution.hpp>
+#include <hpx/future.hpp>
+#include <hpx/modules/testing.hpp>
+
+#include <cstddef>
+#include <iostream>
+#include <iterator>
+#include <numeric>
+#include <random>
+#include <string>
+#include <vector>
+
+#include "test_utils.hpp"
+
+//////////////////////////////////////////////////////////////////////////////
+unsigned int seed = std::random_device{}();
+std::mt19937 gen(seed);
+std::uniform_int_distribution<> dis(2, 101);
+
+template <typename IteratorTag>
+void test_contains(IteratorTag)
+{
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::test_iterator<base_iterator, IteratorTag> iterator;
+
+    std::vector<int> c(10007);
+    std::fill(std::begin(c), std::end(c), dis(gen));
+    const std::size_t n = c.size();
+    c.at(n / 2) = 1;
+
+    bool result1 =
+        hpx::contains(iterator(std::begin(c)), iterator(std::end(c)), int(1));
+    HPX_TEST_EQ(result1, true);
+
+    bool result2 =
+        hpx::contains(iterator(std::begin(c)), iterator(std::end(c)), int(110));
+    HPX_TEST_EQ(result2, false);
+}
+
+template <typename ExPolicy, typename IteratorTag>
+void test_contains(ExPolicy&& policy, IteratorTag)
+{
+    static_assert(hpx::is_execution_policy_v<ExPolicy>,
+        "hpx::is_execution_policy_v<ExPolicy>");
+
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::test_iterator<base_iterator, IteratorTag> iterator;
+
+    std::vector<int> c(10007);
+    std::fill(std::begin(c), std::end(c), dis(gen));
+    const std::size_t n = c.size();
+    c.at(n / 2) = 1;
+
+    bool result1 =
+        hpx::contains(policy, iterator(std::begin(c)), std::end(c), int(1));
+    HPX_TEST_EQ(result1, true);
+
+    bool result2 =
+        hpx::contains(policy, iterator(std::begin(c)), std::end(c), int(110));
+    HPX_TEST_EQ(result2, false);
+}
+
+template <typename Policy, typename ExPolicy, typename IteratorTag>
+void test_contains_explicit_sender_direct(
+    Policy l, ExPolicy&& policy, IteratorTag)
+{
+    static_assert(hpx::is_execution_policy_v<ExPolicy>,
+        "hpx::is_execution_policy_v<ExPolicy>");
+
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::test_iterator<base_iterator, IteratorTag> iterator;
+
+    namespace ex = hpx::execution::experimental;
+    namespace tt = hpx::this_thread::experimental;
+
+    std::vector<int> c(10007);
+    std::fill(std::begin(c), std::end(c), dis(gen));
+    const std::size_t n = c.size();
+    c.at(n / 2) = 1;
+
+    using scheduler_t = ex::thread_pool_policy_scheduler<Policy>;
+    auto exec = ex::explicit_scheduler_executor(scheduler_t(l));
+
+    bool result1 = hpx::contains(policy.on(exec), iterator(std::begin(c)),
+        iterator(std::end(c)), int(1));
+    HPX_TEST_EQ(result1, true);
+
+    bool result2 = hpx::contains(policy.on(exec), iterator(std::begin(c)),
+        iterator(std::end(c)), int(110));
+    HPX_TEST_EQ(result2, false);
+}
+
+template <typename Policy, typename ExPolicy, typename IteratorTag>
+void test_contains_explicit_sender(Policy l, ExPolicy&& policy, IteratorTag)
+{
+    static_assert(hpx::is_execution_policy_v<ExPolicy>,
+        "hpx::is_execution_policy_v<ExPolicy>");
+
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::test_iterator<base_iterator, IteratorTag> iterator;
+
+    namespace ex = hpx::execution::experimental;
+    namespace tt = hpx::this_thread::experimental;
+
+    std::vector<int> c(10007);
+    const std::size_t n = c.size();
+    std::fill(std::begin(c), std::end(c), dis(gen));
+    c.at(n / 2) = 1;
+
+    using scheduler_t = ex::thread_pool_policy_scheduler<Policy>;
+    auto exec = ex::explicit_scheduler_executor(scheduler_t(l));
+    auto result1 = ex::just(iterator(std::begin(c)), iterator(std::end(c)),
+        int(1) | hpx::contains(policy.on(exec)) | tt::sync_wait());
+
+    HPX_TEST_EQ(hpx::get<0>(*result1), true);
+
+    auto result2 = ex::just(iterator(std::begin(c)), iterator(std::end(c)),
+        int(110) | hpx::contains(policy.on(exec)) | tt::sync_wait());
+
+    HPX_TEST_EQ(hpx::get<0>(*result2), false);
+}
+
+template <typename ExPolicy, typename IteratorTag>
+void test_contains_async(ExPolicy&& policy, IteratorTag)
+{
+    static_assert(hpx::is_execution_policy_v<ExPolicy>,
+        "hpx::is_execution_policy_v<ExPolicy>");
+
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::test_iterator<base_iterator, IteratorTag> iterator;
+
+    std::vector<int> c(10007);
+    const std::size_t n = c.size();
+    std::fill(std::begin(c), std::end(c), dis(gen));
+    c.at(n / 2) = 1;
+
+    hpx::future<bool> result1 = hpx::contains(
+        policy, iterator(std::begin(c)), iterator(std::end(c)), int(1));
+    result1.wait();
+    HPX_TEST_EQ(result1.get(), true);
+
+    hpx::future<bool> result2 = hpx::contains(
+        policy, iterator(std::begin(c)), iterator(std::end(c)), int(110));
+    result2.wait();
+    HPX_TEST_EQ(result2.get(), false);
+}
+
+template <typename Policy, typename ExPolicy, typename IteratorTag>
+void test_contains_explicit_sender_direct_async(
+    Policy l, ExPolicy&& p, IteratorTag)
+{
+    static_assert(hpx::is_execution_policy_v<ExPolicy>,
+        "hpx::is_execution_policy_v<ExPolicy>");
+
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::test_iterator<base_iterator, IteratorTag> iterator;
+
+    namespace ex = hpx::execution::experimental;
+    namespace tt = hpx::this_thread::experimental;
+
+    std::vector<int> c(10007);
+    const std::size_t n = c.size();
+    std::fill(std::begin(c), std::end(c), dis(gen));
+    c.at(n / 2) = 1;
+
+    using scheduler_t = ex::thread_pool_policy_scheduler<Policy>;
+    auto exec = ex::explicit_scheduler_executor(scheduler_t(l));
+
+    auto result1 = hpx::contains(p.on(exec), iterator(std::begin(c)),
+                       iterator(std::end(c)), int(1)) |
+        tt::sync_wait();
+    HPX_TEST_EQ(hpx::get<0>(*result1), true);
+
+    auto result2 = hpx::contains(p.on(exec), iterator(std::begin(c)),
+                       iterator(std::end(c)), int(110)) |
+        tt::sync_wait();
+    HPX_TEST_EQ(hpx::get<0>(*result2), false);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename IteratorTag>
+void test_contains_exception(IteratorTag)
+{
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::decorated_iterator<base_iterator, IteratorTag>
+        decorated_iterator;
+    std::vector<int> c(10007);
+    std::iota(std::begin(c), std::end(c), gen() + 1);
+    const std::size_t n = c.size();
+    c.at(n / 2) = 0;
+    bool caught_exception = false;
+    try
+    {
+        hpx::contains(
+            decorated_iterator(std::begin(c)),
+            []() { throw std::runtime_error("test"); },
+            decorated_iterator(std::end(c)), int(0));
+
+        HPX_TEST(false);
+    }
+
+    catch (hpx::exception_list const& e)
+    {
+        caught_exception = true;
+        test::test_num_exceptions<hpx::execution::sequenced_policy,
+            IteratorTag>::call(hpx::execution::seq, e);
+    }
+
+    catch (...)
+    {
+        HPX_TEST(false);
+    }
+
+    HPX_TEST(caught_exception);
+}
+
+template <typename ExPolicy, typename IteratorTag>
+void test_contains_exception(ExPolicy&& policy, IteratorTag)
+{
+    static_assert(hpx::is_execution_policy_v<ExPolicy>,
+        "hpx::is_execution_policy_v<ExPolicy>");
+
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::decorated_iterator<base_iterator, IteratorTag>
+        decorated_iterator;
+
+    std::vector<int> c(10007);
+    const std::size_t n = c.size();
+    std::iota(std::begin(c), std::end(c), gen() + 1);
+    c.at(n / 2) = 0;
+
+    bool caught_exception = false;
+    try
+    {
+        hpx::contains(
+            policy, decorated_iterator(std::begin(c)),
+            []() { throw std::runtime_error("test"); },
+            decorated_iterator(std::end(c)), int(0));
+
+        HPX_TEST(false);
+    }
+
+    catch (hpx::exception_list const& e)
+    {
+        caught_exception = true;
+        test::test_num_exceptions<ExPolicy, IteratorTag>::call(policy, e);
+    }
+
+    catch (...)
+    {
+        HPX_TEST(false);
+    }
+
+    HPX_TEST(caught_exception);
+}
+
+template <typename ExPolicy, typename IteratorTag>
+void test_contains_exception_async(ExPolicy&& policy, IteratorTag)
+{
+    static_assert(hpx::is_execution_policy_v<ExPolicy>,
+        "hpx::is_execution_policy_v<ExPolicy>");
+
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::decorated_iterator<base_iterator, IteratorTag>
+        decorated_iterator;
+
+    std::vector<int> c(10007);
+    const std::size_t n = c.size();
+    std::iota(std::begin(c), std::end(c), gen() + 1);
+    c.at(n / 2) = 0;
+
+    bool caught_exception = false;
+    bool returned_from_algorithm = false;
+    try
+    {
+        hpx::future<bool> result = hpx::contains(
+            policy, decorated_iterator(std::begin(c)),
+            []() { throw std::runtime_error("test"); },
+            decorated_iterator(std::end(c)), int(0));
+        returned_from_algorithm = true;
+        result.get();
+        HPX_TEST(false);
+    }
+
+    catch (hpx::exception_list const& e)
+    {
+        caught_exception = true;
+        test::test_num_exceptions<ExPolicy, IteratorTag>::call(policy, e);
+    }
+
+    catch (...)
+    {
+        HPX_TEST(false);
+    }
+
+    HPX_TEST(caught_exception);
+    HPX_TEST(returned_from_algorithm);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+template <typename ExPolicy, typename IteratorTag>
+void test_contains_bad_alloc(ExPolicy&& policy, IteratorTag)
+{
+    static_assert(hpx::is_execution_policy_v<ExPolicy>,
+        "hpx::is_execution_policy_b<ExPolicy>");
+
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::decorated_iterator<base_iterator, IteratorTag>
+        decorated_iterator;
+
+    std::vector<int> c(10007);
+    const std::size_t n = c.size();
+    std::iota(std::begin(c), std::end(c), gen() + 1);
+    c.at(n / 2) = 0;
+    bool caught_bad_alloc = false;
+    try
+    {
+        hpx::contains(policy, decorated_iterator(std::begin(c)),
+            []() { throw std::bad_alloc(); }),
+            decorated_iterator(std::end(c), int(0));
+        HPX_TEST(false);
+    }
+
+    catch (std::bad_alloc const&)
+    {
+        caught_bad_alloc = true;
+    }
+
+    catch (...)
+    {
+        HPX_TEST(false);
+    }
+
+    HPX_TEST(caught_bad_alloc);
+}
+
+template <typename ExPolicy, typename IteratorTag>
+void test_contains_bad_alloc_async(ExPolicy&& policy, IteratorTag)
+{
+    static_assert(hpx::is_execution_policy_v<ExPolicy>,
+        "hpx::is_execution_policy_v<ExPolicy>");
+
+    typedef std::vector<int>::iterator base_iterator;
+    typedef test::decorated_iterator<base_iterator, IteratorTag>
+        decorated_iterator;
+
+    std::vector<int> c(10007);
+    const std::size_t n = c.size();
+    std::iota(std::begin(c), std::end(c), gen() + 1);
+    c.at(n / 2) = 0;
+    bool caught_bad_alloc = false;
+    bool returned_from_algorithm = false;
+    try
+    {
+        hpx::future<bool> result = hpx::contains(
+            policy, decorated_iterator(std::begin(c)),
+            []() { throw std::bad_alloc(); }, decorated_iterator(std::end(c)),
+            int(0));
+        returned_from_algorithm = true;
+        result.get();
+        HPX_TEST(false);
+    }
+
+    catch (std::bad_alloc const&)
+    {
+        caught_bad_alloc = true;
+    }
+
+    catch (...)
+    {
+        HPX_TEST(false);
+    }
+
+    HPX_TEST(caught_bad_alloc);
+    HPX_TEST(returned_from_algorithm);
+}