[libc++] Remove experimental/algorithm

[philnik]

Summary

The only thing left in experimental/algorithm is std::search() with a Searcher and that has been implemented in d835e59211883, which was part of LLVM7.

[• Quuxplusone]

Seems plausible to me, but there should be a ton of libcxx/test/ diffs here. I don't think buildkite ran on this... but I can't figure out why not.

Please git grep experimental/algorithm ../libcxx and fix what you find.

[philnik]

• Remove experimental/algorithm from tests

[Mordante]

In D119585#3315670, @Quuxplusone wrote:

Please git grep experimental/algorithm ../libcxx and fix what you find.

Nice catch @Quuxplusone, it seems our CI coverage isn't good enough. @philnik do want to look at why the CI didn't catch this?

[philnik]

Rebased

[philnik]

• Disable searcher tests in c++14

[• Quuxplusone]

This is related to D119198: std::experimental::search works hand-in-hand with std::experimental::boyer_moore_searcher and company. We can't remove std::experimental::boyer_moore_searcher because we have not yet implemented C++17 std::boyer_moore_searcher
https://en.cppreference.com/w/cpp/utility/functional/boyer_moore_searcher
In this PR, @philnik observes that we could remove std::experimental::search, and just tell people to use std::experimental::boyer_moore_searcher with std::search instead.
In D119198, @jloser observed that we could remove std::experimental::default_searcher, and just tell people to use std::default_searcher with std::experimental::search instead.
But we can't remove all of the experimental searcher stuff in one fell swoop yet, because we haven't implemented the C++17 equivalents.

D119585 seems to me slightly more acceptable than D119198... but guys, we should just implement the C++17 searchers already! @philnik, do you want to take that on?

libcxx/include/CMakeLists.txt

set(files
   cwchar
   cwctype
   deque
   errno.h
   exception
   execution
   experimental/__config
   experimental/__memory
-  experimental/algorithm
   experimental/coroutine
   experimental/deque
   experimental/forward_list
   experimental/functional
   experimental/iterator
   experimental/list
   experimental/map
   experimental/memory_resource

libcxx/include/experimental/algorithm

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_ALGORITHM
-#define _LIBCPP_EXPERIMENTAL_ALGORITHM
-
-/*
-   experimental/algorithm synopsis
-
-#include <algorithm>
-
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-
-template <class ForwardIterator, class Searcher>
-ForwardIterator search(ForwardIterator first, ForwardIterator last,
-                       const Searcher &searcher);
-
-// sample removed because it's now part of C++17
-
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
-*/
-
-#include <__debug>
-#include <algorithm>
-#include <experimental/__config>
-#include <type_traits>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS
-
-template <class _ForwardIterator, class _Searcher>
-_LIBCPP_INLINE_VISIBILITY
-_ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s)
-{ return __s(__f, __l).first; }
-
-_LIBCPP_END_NAMESPACE_LFTS
-
-#endif /* _LIBCPP_EXPERIMENTAL_ALGORITHM */

libcxx/include/module.modulemap

   module __threading_support {         header "__threading_support" export * }
   module __tree              {         header "__tree"              export * }
   module __tuple             { private header "__tuple"             export * }
   module __undef_macros      {         header "__undef_macros"      export * }
 
   module experimental {
     requires cplusplus11
 
-    module algorithm {
-      header "experimental/algorithm"
-      export *
-    }
     module coroutine {
       requires coroutines
       header "experimental/coroutine"
       export *
     }
     module deque {
       header "experimental/deque"
       export *

libcxx/test/libcxx/clang_tidy.sh.cpp

 #    include <wchar.h>
 #endif
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #    include <wctype.h>
 #endif
 
 // experimental headers
 #if __cplusplus >= 201103L
-#    include <experimental/algorithm>
 #    ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
 #        include <experimental/coroutine>
 #    endif
 #    include <experimental/deque>
 #    include <experimental/forward_list>
 #    include <experimental/functional>
 #    include <experimental/iterator>
 #    include <experimental/list>

libcxx/test/libcxx/double_include.sh.cpp

 #    include <wchar.h>
 #endif
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #    include <wctype.h>
 #endif
 
 // experimental headers
 #if __cplusplus >= 201103L
-#    include <experimental/algorithm>
 #    ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
 #        include <experimental/coroutine>
 #    endif
 #    include <experimental/deque>
 #    include <experimental/forward_list>
 #    include <experimental/functional>
 #    include <experimental/iterator>
 #    include <experimental/list>

libcxx/test/libcxx/experimental/algorithms/header.algorithm.synop/includes.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <experimental/algorithm>
-
-#include <experimental/algorithm>
-
-#include "test_macros.h"
-
-#ifndef _LIBCPP_ALGORITHM
-#  error "<experimental/algorithm> must include <algorithm>"
-#endif
-
-int main(int, char**)
-{
-
-  return 0;
-}

libcxx/test/libcxx/experimental/algorithms/version.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <experimental/algorithm>
-
-#include <experimental/algorithm>
-
-#include "test_macros.h"
-
-#ifndef _LIBCPP_VERSION
-#  error _LIBCPP_VERSION not defined
-#endif
-
-int main(int, char**)
-{
-
-  return 0;
-}

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

 #endif
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #    include <wctype.h>
 TEST_MACROS();
 #endif
 
 // experimental headers
 #if __cplusplus >= 201103L
-#    include <experimental/algorithm>
-TEST_MACROS();
 #    ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
 #        include <experimental/coroutine>
 TEST_MACROS();
 #    endif
 #    include <experimental/deque>
 TEST_MACROS();
 #    include <experimental/forward_list>
 TEST_MACROS();

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

 #    include <wchar.h>
 #endif
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #    include <wctype.h>
 #endif
 
 // experimental headers
 #if __cplusplus >= 201103L
-#    include <experimental/algorithm>
 #    ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
 #        include <experimental/coroutine>
 #    endif
 #    include <experimental/deque>
 #    include <experimental/forward_list>
 #    include <experimental/functional>
 #    include <experimental/iterator>
 #    include <experimental/list>

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

 #    include <wchar.h>
 #endif
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #    include <wctype.h>
 #endif
 
 // experimental headers
 #if __cplusplus >= 201103L
-#    include <experimental/algorithm>
 #    ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
 #        include <experimental/coroutine>
 #    endif
 #    include <experimental/deque>
 #    include <experimental/forward_list>
 #    include <experimental/functional>
 #    include <experimental/iterator>
 #    include <experimental/list>

libcxx/test/std/experimental/algorithms/alg.search/search.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11
-
-// <algorithm>
-
-//   template<class ForwardIterator, class Searcher>
-//   ForwardIterator search(ForwardIterator first, ForwardIterator last,
-//                          const Searcher& searcher);
-//
-//      returns searcher.operator(first, last).first
-//
-
-#include <experimental/algorithm>
-#include <cassert>
-
-#include "test_macros.h"
-#include "test_iterators.h"
-
-int searcher_called = 0;
-
-struct MySearcher {
-    template <typename Iterator>
-    std::pair<Iterator, Iterator>
-    operator() (Iterator b, Iterator e) const
-    {
-        ++searcher_called;
-        return std::make_pair(b, e);
-    }
-};
-
-
-int main(int, char**) {
-    typedef int * RI;
-    static_assert((std::is_same<RI, decltype(std::experimental::search(RI(), RI(), MySearcher()))>::value), "" );
-
-    RI it(nullptr);
-    assert(it == std::experimental::search(it, it, MySearcher()));
-    assert(searcher_called == 1);
-
-  return 0;
-}

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // boyer_moore searcher
 // template<class RandomAccessIterator1,
 //          class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
 //          class BinaryPredicate = equal_to<>>
 // class boyer_moore_searcher {
 // public:
 //   boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
 //
 //   template<class RandomAccessIterator2>
 //   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 //
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
 //   Hash                  hash_;      // exposition only
 //   BinaryPredicate       pred_;      // exposition only
 // };
 
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
     std::experimental::boyer_moore_searcher<Iter2> s{b2, e2};
-    assert(result == std::experimental::search(b1, e1, s));
+    assert(result == std::search(b1, e1, s));
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // boyer_moore searcher
 // template<class RandomAccessIterator1,
 //          class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
 //          class BinaryPredicate = equal_to<>>
 // class boyer_moore_searcher {
 // public:
 //   boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
 //
 //   template<class RandomAccessIterator2>
 //   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 //
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
 //   Hash                  hash_;      // exposition only
 //   BinaryPredicate       pred_;      // exposition only
 // };
 
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <typename T> struct MyHash {
     size_t operator () (T t) const { return static_cast<size_t>(t); }
 };
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned /*max_count*/) {
     std::experimental::boyer_moore_searcher<Iter2,
                  MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>>
           s{b2, e2};
-    assert(result == std::experimental::search(b1, e1, s));
+    assert(result == std::search(b1, e1, s));
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // boyer_moore searcher
 // template<class RandomAccessIterator1,
 //          class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
 //          class BinaryPredicate = equal_to<>>
 // class boyer_moore_searcher {
 // public:
 //   boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
 //
 //   template<class RandomAccessIterator2>
 //   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 //
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
 //   Hash                  hash_;      // exposition only
 //   BinaryPredicate       pred_;      // exposition only
 // };
 
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <typename T> struct MyHash {
     size_t operator () (T t) const { return static_cast<size_t>(t); }

 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
     std::experimental::boyer_moore_searcher<Iter2,
                  MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>,
                  count_equal>
           s{b2, e2};
     count_equal::count = 0;
-    assert(result == std::experimental::search(b1, e1, s));
+    assert(result == std::search(b1, e1, s));
     assert(count_equal::count <= max_count);
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // boyer_moore searcher
 // template<class RandomAccessIterator1,
 //          class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
 //          class BinaryPredicate = equal_to<>>
 // class boyer_moore_searcher {
 // public:
 //   boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                        Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
 //
 //   template<class RandomAccessIterator2>
 //   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 //
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
 //   Hash                  hash_;      // exposition only
 //   BinaryPredicate       pred_;      // exposition only
 // };
 
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct count_equal
 {
     static unsigned count;
     template <class T>
     bool operator()(const T& x, const T& y) const
         {++count; return x == y;}
 };
 
 unsigned count_equal::count = 0;
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
     std::experimental::boyer_moore_searcher<Iter2,
            typename std::hash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>, count_equal> s{b2, e2};
     count_equal::count = 0;
-    assert(result == std::experimental::search(b1, e1, s));
+    assert(result == std::search(b1, e1, s));
     assert(count_equal::count <= max_count);
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // boyer_moore_horspool searcher
 // template<class RandomAccessIterator1,
 //          class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
 //          class BinaryPredicate = equal_to<>>
 // class boyer_moore_horspool_searcher {
 // public:
 //   boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                                 Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
 //
 //   template<class RandomAccessIterator2>
 //   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 //
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
 //   Hash                  hash_;      // exposition only
 //   BinaryPredicate       pred_;      // exposition only
 // };
 
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
     std::experimental::boyer_moore_horspool_searcher<Iter2> s{b2, e2};
-    assert(result == std::experimental::search(b1, e1, s));
+    assert(result == std::search(b1, e1, s));
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // boyer_moore_horspool searcher
 // template<class RandomAccessIterator1,
 //          class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
 //          class BinaryPredicate = equal_to<>>
 // class boyer_moore_horspool_searcher {
 // public:
 //   boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                                 Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
 //
 //   template<class RandomAccessIterator2>
 //   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 //
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
 //   Hash                  hash_;      // exposition only
 //   BinaryPredicate       pred_;      // exposition only
 // };
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <typename T> struct MyHash {
     size_t operator () (T t) const { return static_cast<size_t>(t); }
 };
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned /*max_count*/) {
     std::experimental::boyer_moore_horspool_searcher<Iter2,
                  MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>>
           s{b2, e2};
-    assert(result == std::experimental::search(b1, e1, s));
+    assert(result == std::search(b1, e1, s));
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // boyer_moore_horspool searcher
 // template<class RandomAccessIterator1,
 //          class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
 //          class BinaryPredicate = equal_to<>>
 // class boyer_moore_horspool_searcher {
 // public:
 //   boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                                 Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
 //
 //   template<class RandomAccessIterator2>
 //   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 //
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
 //   Hash                  hash_;      // exposition only
 //   BinaryPredicate       pred_;      // exposition only
 // };
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <typename T> struct MyHash {
     size_t operator () (T t) const { return static_cast<size_t>(t); }

 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
     std::experimental::boyer_moore_horspool_searcher<Iter2,
                  MyHash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>,
                  count_equal>
           s{b2, e2};
     count_equal::count = 0;
-    assert(result == std::experimental::search(b1, e1, s));
+    assert(result == std::search(b1, e1, s));
     assert(count_equal::count <= max_count);
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // boyer_moore_horspool searcher
 // template<class RandomAccessIterator1,
 //          class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
 //          class BinaryPredicate = equal_to<>>
 // class boyer_moore_horspool_searcher {
 // public:
 //   boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
 //                                 Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
 //
 //   template<class RandomAccessIterator2>
 //   pair<RandomAccessIterator2, RandomAccessIterator2>
 //   operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;
 //
 // private:
 //   RandomAccessIterator1 pat_first_; // exposition only
 //   RandomAccessIterator1 pat_last_;  // exposition only
 //   Hash                  hash_;      // exposition only
 //   BinaryPredicate       pred_;      // exposition only
 // };
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct count_equal
 {
     static unsigned count;
     template <class T>
     bool operator()(const T& x, const T& y) const
         {++count; return x == y;}
 };
 
 unsigned count_equal::count = 0;
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
     std::experimental::boyer_moore_horspool_searcher<Iter2,
            typename std::hash<typename std::remove_cv<typename std::iterator_traits<Iter2>::value_type>::type>, count_equal> s{b2, e2};
     count_equal::count = 0;
-    assert(result == std::experimental::search(b1, e1, s));
+    assert(result == std::search(b1, e1, s));
     assert(count_equal::count <= max_count);
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};

libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // default searcher
 // template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
 // class default_searcher {
 // public:
 //     default_searcher(_ForwardIterator __f, _ForwardIterator __l,
 //                             _BinaryPredicate __p = _BinaryPredicate())
 //         : __first_(__f), __last_(__l), __pred_(__p) {}
 //
 //     template <typename _ForwardIterator2>
 //     pair<_ForwardIterator2, _ForwardIterator2>
 //     operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const {
 //         return std::search(__f, __l, __first_, __last_, __pred_);
 //         }
 //
 // private:
 //     _ForwardIterator __first_;
 //     _ForwardIterator __last_;
 //     _BinaryPredicate __pred_;
 //     };
 
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
-    std::experimental::default_searcher<Iter2> s{b2, e2};
-    assert(result == std::experimental::search(b1, e1, s));
+    std::default_searcher<Iter2> s{b2, e2};
+    assert(result == std::search(b1, e1, s));
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);

libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // default searcher
 // template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
 // class default_searcher {
 // public:
 //     default_searcher(_ForwardIterator __f, _ForwardIterator __l,
 //                             _BinaryPredicate __p = _BinaryPredicate())
 //         : __first_(__f), __last_(__l), __pred_(__p) {}
 //
 //     template <typename _ForwardIterator2>
 //     pair<_ForwardIterator2, _ForwardIterator2>
 //     operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const {
 //         return std::search(__f, __l, __first_, __last_, __pred_);
 //         }
 //
 // private:
 //     _ForwardIterator __first_;
 //     _ForwardIterator __last_;
 //     _BinaryPredicate __pred_;
 //     };
 
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct count_equal
 {
     static unsigned count;
     template <class T>
     bool operator()(const T& x, const T& y) const
         {++count; return x == y;}
 };
 
 unsigned count_equal::count = 0;
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
-    std::experimental::default_searcher<Iter2, count_equal> s{b2, e2};
+    std::default_searcher<Iter2, count_equal> s{b2, e2};
     count_equal::count = 0;
-    assert(result == std::experimental::search(b1, e1, s));
+    assert(result == std::search(b1, e1, s));
     assert(count_equal::count <= max_count);
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};

libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // template<class ForwardIterator, class BinaryPredicate = equal_to<>>
 // default_searcher<ForwardIterator, BinaryPredicate>
 // make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
 //                       BinaryPredicate pred = BinaryPredicate());
 
 
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
-    assert(result == std::experimental::search(b1, e1,
-        std::experimental::make_default_searcher(b2, e2)));
+    assert(result == std::search(b1, e1, std::default_searcher(b2, e2)));
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);

libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <functional>
 
 // template<class ForwardIterator, class BinaryPredicate = equal_to<>>
 // default_searcher<ForwardIterator, BinaryPredicate>
 // make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
 //                       BinaryPredicate pred = BinaryPredicate());
 
-
-#include <experimental/algorithm>
+#include <algorithm>
 #include <experimental/functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct count_equal
 {
     static unsigned count;
     template <class T>
     bool operator()(const T& x, const T& y)
         {++count; return x == y;}
 };
 
 unsigned count_equal::count = 0;
 
 template <typename Iter1, typename Iter2>
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
     count_equal::count = 0;
-    assert(result == std::experimental::search(b1, e1,
-        std::experimental::make_default_searcher(b2, e2)));
+    assert(result == std::search(b1, e1, std::default_searcher(b2, e2)));
     assert(count_equal::count <= max_count);
 }
 
 template <class Iter1, class Iter2>
 void
 test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

sources = [
       "cwchar",
       "cwctype",
       "deque",
       "errno.h",
       "exception",
       "execution",
       "experimental/__config",
       "experimental/__memory",
-      "experimental/algorithm",
       "experimental/coroutine",
       "experimental/deque",
       "experimental/forward_list",
       "experimental/functional",
       "experimental/iterator",
       "experimental/list",
       "experimental/map",
       "experimental/memory_resource",