Implement P1209 - Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20

[mclow.lists]

Summary

Implement container-based erase and erase_if for all the containers.
https://wg21.link/P1209

Lots of similar changes, over and over.

[ldionne]

Could you please split this change and the changes from class to struct into different patches? That would make it easier to review.

[mclow.lists]

In D55532#1326318, @ldionne wrote:

Could you please split this change and the changes from class to struct into different patches? That would make it easier to review.

Yes, sorry.

[mclow.lists]

Removed the tuple_size changes - those are in D55466.

[mclow.lists]

include/version

40

Tabs. I thought I got rid of them.

[ldionne]

include/deque

2942

I see that's what the specification says, but is the unqualified call intended? For a user-defined type, I think this could pick up a custom remove_if through ADL since our deque iterators have the _Tp as a template parameter. Either I'm wrong, or this seems like an undesirable thing.

include/unordered_set

948

There is a lot of duplication across associative containers -- would it make sense to factor this?

[mclow.lists]

include/deque

2942

I agree that it could pick up a user-defined remove_if, (or actually, remove as well).

include/unordered_set

948

I agree - but they're in four different (unrelated) headers: set/map/unordered_set/unordered_map. I could cut them in half (down from eight to four), but getting down to one would require finding a common (unrelated) header file.

Hrm. They all include <functional>

[mclow.lists]

• Make a common routine for the associative and unordered associative containers.
• Add _VSTD:: to prohibit ADL.
• Add inline _LIBCPP_INLINE_VISIBILITY in a bunch of spots.

[mclow.lists]

Committed as revision 349178

include/deque

     void swap(deque<T,Allocator>& x, deque<T,Allocator>& y)
          noexcept(noexcept(x.swap(y)));
 
+template <class T, class Allocator, class U>
+    void erase(deque<T, Allocator>& c, const U& value);       // C++20
+template <class T, class Allocator, class Predicate>
+    void erase_if(deque<T, Allocator>& c, Predicate pred);    // C++20
+
 }  // std
 
 */

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Tp, class _Allocator, class _Up>
+void erase(deque<_Tp, _Allocator>& __c, const _Up& __v)
+{ __c.erase(remove(__c.begin(), __c.end(), __v), __c.end()); }
+
+template <class _Tp, class _Allocator, class _Predicate>
+void erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred)
+{ __c.erase(remove_if(__c.begin(), __c.end(), __pred), __c.end()); }
+#endif
+
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

include/forward_list

     void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
          noexcept(noexcept(x.swap(y)));
 
+template <class T, class Allocator, class U>
+    void erase(forward_list<T, Allocator>& c, const U& value);       // C++20
+template <class T, class Allocator, class Predicate>
+    void erase_if(forward_list<T, Allocator>& c, Predicate pred);    // C++20
+
 }  // std
 
 */

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Tp, class _Allocator, class _Up>
+void erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v)
+{ erase_if(__c, [&](auto& __elem) { return __elem == __v; }); }
+
+template <class _Tp, class _Allocator, class _Predicate>
+void erase_if(forward_list<_Tp, _Allocator>& __c, _Predicate __pred)
+{ __c.remove_if(__pred); }
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

include/list

     void swap(list<T,Alloc>& x, list<T,Alloc>& y)
          noexcept(noexcept(x.swap(y)));
 
+template <class T, class Allocator, class U>
+    void erase(list<T, Allocator>& c, const U& value);       // C++20
+template <class T, class Allocator, class Predicate>
+    void erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
+
 }  // std
 
 */

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Tp, class _Allocator, class _Up>
+void erase(list<_Tp, _Allocator>& __c, const _Up& __v)
+{ erase_if(__c, [&](auto& __elem) { return __elem == __v; }); }
+
+template <class _Tp, class _Allocator, class _Predicate>
+void erase_if(list<_Tp, _Allocator>& __c, _Predicate __pred)
+{ __c.remove_if(__pred); }
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

include/map

 swap(map<Key, T, Compare, Allocator>& x, map<Key, T, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
+template <class Key, class T, class Compare, class Allocator, class Predicate>
+  void erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
+
+
 template <class Key, class T, class Compare = less<Key>,
           class Allocator = allocator<pair<const Key, T>>>
 class multimap

      multimap<Key, T, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
+template <class Key, class T, class Compare, class Allocator, class Predicate>
+  void erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
+
 }  // std
 
 */

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Key, class _Tp, class _Compare, class _Allocator, class _Predicate>
+void erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred)
+{
+    for (auto __iter = __c.begin(), __last = __c.end(); __iter != __last;)
+    {
+        if (__pred(*__iter))
+            __iter = __c.erase(__iter);
+        else
+            ++__iter;
+    }
+}
+#endif
+
+
 template <class _Key, class _Tp, class _Compare = less<_Key>,
           class _Allocator = allocator<pair<const _Key, _Tp> > >
 class _LIBCPP_TEMPLATE_VIS multimap

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Key, class _Tp, class _Compare, class _Allocator, class _Predicate>
+void erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred)
+{
+    for (auto __iter = __c.begin(), __last = __c.end(); __iter != __last;)
+    {
+        if (__pred(*__iter))
+            __iter = __c.erase(__iter);
+        else
+            ++__iter;
+    }
+}
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_MAP

include/set

 swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
+template <class Key, class Compare, class Allocator, class Predicate>
+  void erase_if(set<Key, Compare, Allocator>& c, Predicate pred);  // C++20
+
 template <class Key, class Compare = less<Key>,
           class Allocator = allocator<Key>>
 class multiset

 swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
+template <class Key, class Compare, class Allocator, class Predicate>
+  void erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
+
 }  // std
 
 */

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Key, class _Compare, class _Allocator, class _Predicate>
+void erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred)
+{
+  for (auto __iter = __c.begin(), __last = __c.end(); __iter != __last;)
+  {
+    if (__pred(*__iter))
+      __iter = __c.erase(__iter);
+    else
+      ++__iter;
+  }
+}
+#endif
+
 template <class _Key, class _Compare = less<_Key>,
           class _Allocator = allocator<_Key> >
 class _LIBCPP_TEMPLATE_VIS multiset

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Key, class _Compare, class _Allocator, class _Predicate>
+void erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred)
+{
+  for (auto __iter = __c.begin(), __last = __c.end(); __iter != __last;)
+  {
+    if (__pred(*__iter))
+      __iter = __c.erase(__iter);
+    else
+      ++__iter;
+  }
+}
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_SET

include/string

 basic_istream<charT, traits>&
 getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
 
+template<class charT, class traits, class Allocator, class U>
+void erase(basic_string<charT, traits, Allocator>& c, const U& value); // C++20
+template<class charT, class traits, class Allocator, class Predicate>
+void erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20
+
 typedef basic_string<char>    string;
 typedef basic_string<wchar_t> wstring;
 typedef basic_string<char16_t> u16string;

 
 #endif  // _LIBCPP_CXX03_LANG
 
+#if _LIBCPP_STD_VER > 17
+template<class _CharT, class _Traits, class _Allocator, class _Up>
+void erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v)
+{ __str.erase(remove(__str.begin(), __str.end(), __v), __str.end()); }
+
+template<class _CharT, class _Traits, class _Allocator, class _Predicate>
+void erase_if(basic_string<_CharT, _Traits, _Allocator>& __str, _Predicate __pred)
+{ __str.erase(remove_if(__str.begin(), __str.end(), __pred), __str.end()); }
+#endif
+
 #if _LIBCPP_DEBUG_LEVEL >= 2
 
 template<class _CharT, class _Traits, class _Allocator>

include/unordered_map

               unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
               noexcept(noexcept(x.swap(y)));
 
+template <class K, class T, class H, class P, class A, class Predicate>
+    void erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred);       // C++20
+
+template <class K, class T, class H, class P, class A, class Predicate>
+    void erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred);  // C++20
+
 template <class Key, class T, class Hash, class Pred, class Alloc>
     bool
     operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc, class _Predicate>
+void erase_if(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
+{
+    for (auto __iter = __c.begin(), __last = __c.end(); __iter != __last;)
+    {
+        if (__pred(*__iter))
+            __iter = __c.erase(__iter);
+        else
+            ++__iter;
+    }
+}
+#endif
+
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 bool
 operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc, class _Predicate>
+void erase_if(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
+{
+    for (auto __iter = __c.begin(), __last = __c.end(); __iter != __last;)
+    {
+        if (__pred(*__iter))
+            __iter = __c.erase(__iter);
+        else
+            ++__iter;
+    }
+}
+#endif
+
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 bool
 operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,

include/unordered_set

               unordered_multiset<Value, Hash, Pred, Alloc>& y)
               noexcept(noexcept(x.swap(y)));
 
+template <class K, class T, class H, class P, class A, class Predicate>
+    void erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred);       // C++20
+
+template <class K, class T, class H, class P, class A, class Predicate>
+    void erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred);  // C++20
+
+
 template <class Value, class Hash, class Pred, class Alloc>
     bool
     operator==(const unordered_multiset<Value, Hash, Pred, Alloc>& x,

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Value, class _Hash, class _Pred, class _Alloc, class _Predicate>
+void erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
+{
+    for (auto __iter = __c.begin(), __last = __c.end(); __iter != __last;)
+    {
+        if (__pred(*__iter))
+            __iter = __c.erase(__iter);
+        else
+            ++__iter;
+    }
+}
+#endif
+
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 bool
 operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Value, class _Hash, class _Pred, class _Alloc, class _Predicate>
+void erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
+{
+    for (auto __iter = __c.begin(), __last = __c.end(); __iter != __last;)
+    {
+        if (__pred(*__iter))
+            __iter = __c.erase(__iter);
+        else
+            ++__iter;
+    }
+}
+#endif
+
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 bool
 operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,

include/vector

 void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
+template <class T, class Allocator, class U>
+    void erase(vector<T, Allocator>& c, const U& value);       // C++20
+template <class T, class Allocator, class Predicate>
+    void erase_if(vector<T, Allocator>& c, Predicate pred);    // C++20
+
 }  // std
 
 */

     __x.swap(__y);
 }
 
+#if _LIBCPP_STD_VER > 17
+template <class _Tp, class _Allocator, class _Up>
+void erase(vector<_Tp, _Allocator>& __c, const _Up& __v)
+{ __c.erase(remove(__c.begin(), __c.end(), __v), __c.end()); }
+
+template <class _Tp, class _Allocator, class _Predicate>
+void erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred)
+{ __c.erase(remove_if(__c.begin(), __c.end(), __pred), __c.end()); }
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

include/version

 __cpp_lib_concepts                          201806L <concepts>
 __cpp_lib_constexpr_swap_algorithms         201806L <algorithm>
 __cpp_lib_enable_shared_from_this           201603L <memory>
+__cpp_lib_erase_if              201811L <string> <deque> <forward_list> <list> 
+                          <vector> <map> <set> <unordered_map> 
+                          <unordered_set>
 __cpp_lib_exchange_function                 201304L <utility>
 __cpp_lib_execution                         201603L <execution>
 __cpp_lib_filesystem                        201703L <filesystem>

 #endif
 
 #if _LIBCPP_STD_VER > 17
+#define __cpp_lib_erase_if                201811L
 #endif
 
 #endif  // _LIBCPP_VERSIONH

test/std/containers/associative/map/map.erasure/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <map>
+
+// template <class Key, class T, class Compare, class Allocator, class Predicate>
+//   void erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);
+
+#include <map>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+using Init = std::initializer_list<int>;
+template <typename M>
+M make (Init vals)
+{
+    M ret;
+    for (int v : vals)
+        ret[v] = v + 10;
+    return ret;
+}
+
+template <typename M, typename Pred>
+void
+test0(Init vals, Pred p, Init expected)
+{
+    M s = make<M> (vals);
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    assert(s == make<M>(expected));
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v.first == 1;};
+    auto is2 = [](auto v) { return v.first == 2;};
+    auto is3 = [](auto v) { return v.first == 3;};
+    auto is4 = [](auto v) { return v.first == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0<S>({}, is1, {});
+
+    test0<S>({1}, is1, {});
+    test0<S>({1}, is2, {1});
+
+    test0<S>({1,2}, is1, {2});
+    test0<S>({1,2}, is2, {1});
+    test0<S>({1,2}, is3, {1,2});
+
+    test0<S>({1,2,3}, is1, {2,3});
+    test0<S>({1,2,3}, is2, {1,3});
+    test0<S>({1,2,3}, is3, {1,2});
+    test0<S>({1,2,3}, is4, {1,2,3});
+
+    test0<S>({1,2,3}, True,  {});
+    test0<S>({1,2,3}, False, {1,2,3});
+}
+
+int main()
+{
+    test<std::map<int, int>>();
+    test<std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>>> ();
+    test<std::map<int, int, std::less<int>, test_allocator<std::pair<const int, int>>>> ();
+
+    test<std::map<long, short>>();
+    test<std::map<short, double>>();
+}
+

test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <map>
+
+//   template <class Key, class T, class Compare, class Allocator, class Predicate>
+//     void erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);
+
+#include <map>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+using Init = std::initializer_list<int>;
+template <typename M>
+M make (Init vals)
+{
+    M ret;
+    for (int v : vals)
+        ret.insert(typename M::value_type(v, v + 10));
+    return ret;
+}
+
+template <typename M, typename Pred>
+void
+test0(Init vals, Pred p, Init expected)
+{
+    M s = make<M> (vals);
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    assert(s == make<M>(expected));
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v.first == 1;};
+    auto is2 = [](auto v) { return v.first == 2;};
+    auto is3 = [](auto v) { return v.first == 3;};
+    auto is4 = [](auto v) { return v.first == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0<S>({}, is1, {});
+
+    test0<S>({1}, is1, {});
+    test0<S>({1}, is2, {1});
+
+    test0<S>({1,2}, is1, {2});
+    test0<S>({1,2}, is2, {1});
+    test0<S>({1,2}, is3, {1,2});
+    test0<S>({1,1}, is1, {});
+    test0<S>({1,1}, is3, {1,1});
+
+    test0<S>({1,2,3}, is1, {2,3});
+    test0<S>({1,2,3}, is2, {1,3});
+    test0<S>({1,2,3}, is3, {1,2});
+    test0<S>({1,2,3}, is4, {1,2,3});
+
+    test0<S>({1,1,1}, is1, {});
+    test0<S>({1,1,1}, is2, {1,1,1});
+    test0<S>({1,1,2}, is1, {2});
+    test0<S>({1,1,2}, is2, {1,1});
+    test0<S>({1,1,2}, is3, {1,1,2});
+    test0<S>({1,2,2}, is1, {2,2});
+    test0<S>({1,2,2}, is2, {1});
+    test0<S>({1,2,2}, is3, {1,2,2});
+    
+    test0<S>({1,2,3}, True,  {});
+    test0<S>({1,2,3}, False, {1,2,3});
+}
+
+int main()
+{
+    test<std::multimap<int, int>>();
+    test<std::multimap<int, int, std::less<int>, min_allocator<std::pair<const int, int>>>> ();
+    test<std::multimap<int, int, std::less<int>, test_allocator<std::pair<const int, int>>>> ();
+
+    test<std::multimap<long, short>>();
+    test<std::multimap<short, double>>();
+}

test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <set>
+
+// template <class T, class Compare, class Allocator, class Predicate>
+//   void erase_if(multiset<T, Compare, Allocator>& c, Predicate pred);
+
+#include <set>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class Pred>
+void
+test0(S s, Pred p, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    assert(s == expected);
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v == 1;};
+    auto is2 = [](auto v) { return v == 2;};
+    auto is3 = [](auto v) { return v == 3;};
+    auto is4 = [](auto v) { return v == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0(S(), is1, S());
+
+    test0(S({1}), is1, S());
+    test0(S({1}), is2, S({1}));
+
+    test0(S({1,2}), is1, S({2}));
+    test0(S({1,2}), is2, S({1}));
+    test0(S({1,2}), is3, S({1,2}));
+    test0(S({1,1}), is1, S());
+    test0(S({1,1}), is3, S({1,1}));
+
+    test0(S({1,2,3}), is1, S({2,3}));
+    test0(S({1,2,3}), is2, S({1,3}));
+    test0(S({1,2,3}), is3, S({1,2}));
+    test0(S({1,2,3}), is4, S({1,2,3}));
+
+    test0(S({1,1,1}), is1, S());
+    test0(S({1,1,1}), is2, S({1,1,1}));
+    test0(S({1,1,2}), is1, S({2}));
+    test0(S({1,1,2}), is2, S({1,1}));
+    test0(S({1,1,2}), is3, S({1,1,2}));
+    test0(S({1,2,2}), is1, S({2,2}));
+    test0(S({1,2,2}), is2, S({1}));
+    test0(S({1,2,2}), is3, S({1,2,2}));
+    
+    test0(S({1,2,3}), True,  S());
+    test0(S({1,2,3}), False, S({1,2,3}));
+}
+
+int main()
+{
+    test<std::multiset<int>>();
+    test<std::multiset<int, std::less<int>, min_allocator<int>>> ();
+    test<std::multiset<int, std::less<int>, test_allocator<int>>> ();
+
+    test<std::multiset<long>>();
+    test<std::multiset<double>>();
+}

test/std/containers/associative/set/set.erasure/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <set>
+
+// template <class T, class Compare, class Allocator, class Predicate>
+//   void erase_if(set<T, Compare, Allocator>& c, Predicate pred);
+
+#include <set>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class Pred>
+void
+test0(S s, Pred p, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    assert(s == expected);
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v == 1;};
+    auto is2 = [](auto v) { return v == 2;};
+    auto is3 = [](auto v) { return v == 3;};
+    auto is4 = [](auto v) { return v == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0(S(), is1, S());
+
+    test0(S({1}), is1, S());
+    test0(S({1}), is2, S({1}));
+
+    test0(S({1,2}), is1, S({2}));
+    test0(S({1,2}), is2, S({1}));
+    test0(S({1,2}), is3, S({1,2}));
+
+    test0(S({1,2,3}), is1, S({2,3}));
+    test0(S({1,2,3}), is2, S({1,3}));
+    test0(S({1,2,3}), is3, S({1,2}));
+    test0(S({1,2,3}), is4, S({1,2,3}));
+
+    test0(S({1,2,3}), True,  S());
+    test0(S({1,2,3}), False, S({1,2,3}));
+}
+
+int main()
+{
+    test<std::set<int>>();
+    test<std::set<int, std::less<int>, min_allocator<int>>> ();
+    test<std::set<int, std::less<int>, test_allocator<int>>> ();
+
+    test<std::set<long>>();
+    test<std::set<double>>();
+}

test/std/containers/sequences/deque/deque.erasure/erase.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <deque>
+
+// template <class T, class Allocator, class U>
+//   void erase(deque<T, Allocator>& c, const U& value);
+  
+
+#include <deque>
+#include <optional>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class U>
+void
+test0(S s,  U val, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase(s, val)));
+    std::erase(s, val);
+    assert(s == expected);
+}
+
+template <class S>
+void test()
+{
+
+    test0(S(), 1, S());
+
+    test0(S({1}), 1, S());
+    test0(S({1}), 2, S({1}));
+
+    test0(S({1,2}), 1, S({2}));
+    test0(S({1,2}), 2, S({1}));
+    test0(S({1,2}), 3, S({1,2}));
+    test0(S({1,1}), 1, S());
+    test0(S({1,1}), 3, S({1,1}));
+
+    test0(S({1,2,3}), 1, S({2,3}));
+    test0(S({1,2,3}), 2, S({1,3}));
+    test0(S({1,2,3}), 3, S({1,2}));
+    test0(S({1,2,3}), 4, S({1,2,3}));
+
+    test0(S({1,1,1}), 1, S());
+    test0(S({1,1,1}), 2, S({1,1,1}));
+    test0(S({1,1,2}), 1, S({2}));
+    test0(S({1,1,2}), 2, S({1,1}));
+    test0(S({1,1,2}), 3, S({1,1,2}));
+    test0(S({1,2,2}), 1, S({2,2}));
+    test0(S({1,2,2}), 2, S({1}));
+    test0(S({1,2,2}), 3, S({1,2,2}));
+
+//  Test cross-type erasure
+    using opt = std::optional<typename S::value_type>;
+    test0(S({1,2,1}), opt(),  S({1,2,1}));
+    test0(S({1,2,1}), opt(1), S({2}));
+    test0(S({1,2,1}), opt(2), S({1,1}));
+    test0(S({1,2,1}), opt(3), S({1,2,1}));
+}
+
+int main()
+{
+    test<std::deque<int>>();
+    test<std::deque<int, min_allocator<int>>> ();
+    test<std::deque<int, test_allocator<int>>> ();
+
+    test<std::deque<long>>();
+    test<std::deque<double>>();
+}

test/std/containers/sequences/deque/deque.erasure/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <deque>
+
+// template <class T, class Allocator, class Predicate>
+//   void erase_if(deque<T, Allocator>& c, Predicate pred);  
+
+#include <deque>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class Pred>
+void
+test0(S s, Pred p, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    assert(s == expected);
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v == 1;};
+    auto is2 = [](auto v) { return v == 2;};
+    auto is3 = [](auto v) { return v == 3;};
+    auto is4 = [](auto v) { return v == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0(S(), is1, S());
+
+    test0(S({1}), is1, S());
+    test0(S({1}), is2, S({1}));
+
+    test0(S({1,2}), is1, S({2}));
+    test0(S({1,2}), is2, S({1}));
+    test0(S({1,2}), is3, S({1,2}));
+    test0(S({1,1}), is1, S());
+    test0(S({1,1}), is3, S({1,1}));
+
+    test0(S({1,2,3}), is1, S({2,3}));
+    test0(S({1,2,3}), is2, S({1,3}));
+    test0(S({1,2,3}), is3, S({1,2}));
+    test0(S({1,2,3}), is4, S({1,2,3}));
+
+    test0(S({1,1,1}), is1, S());
+    test0(S({1,1,1}), is2, S({1,1,1}));
+    test0(S({1,1,2}), is1, S({2}));
+    test0(S({1,1,2}), is2, S({1,1}));
+    test0(S({1,1,2}), is3, S({1,1,2}));
+    test0(S({1,2,2}), is1, S({2,2}));
+    test0(S({1,2,2}), is2, S({1}));
+    test0(S({1,2,2}), is3, S({1,2,2}));
+    
+    test0(S({1,2,3}), True,  S());
+    test0(S({1,2,3}), False, S({1,2,3}));
+}
+
+int main()
+{
+    test<std::deque<int>>();
+    test<std::deque<int, min_allocator<int>>> ();
+    test<std::deque<int, test_allocator<int>>> ();
+
+    test<std::deque<long>>();
+    test<std::deque<double>>();
+}

test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <forward_list>
+
+// template <class T, class Allocator, class U>
+//   void erase(forward_list<T, Allocator>& c, const U& value);
+  
+
+#include <forward_list>
+#include <optional>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class U>
+void
+test0(S s,  U val, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase(s, val)));
+    std::erase(s, val);
+    assert(s == expected);
+}
+
+template <class S>
+void test()
+{
+
+    test0(S(), 1, S());
+
+    test0(S({1}), 1, S());
+    test0(S({1}), 2, S({1}));
+
+    test0(S({1,2}), 1, S({2}));
+    test0(S({1,2}), 2, S({1}));
+    test0(S({1,2}), 3, S({1,2}));
+    test0(S({1,1}), 1, S());
+    test0(S({1,1}), 3, S({1,1}));
+
+    test0(S({1,2,3}), 1, S({2,3}));
+    test0(S({1,2,3}), 2, S({1,3}));
+    test0(S({1,2,3}), 3, S({1,2}));
+    test0(S({1,2,3}), 4, S({1,2,3}));
+
+    test0(S({1,1,1}), 1, S());
+    test0(S({1,1,1}), 2, S({1,1,1}));
+    test0(S({1,1,2}), 1, S({2}));
+    test0(S({1,1,2}), 2, S({1,1}));
+    test0(S({1,1,2}), 3, S({1,1,2}));
+    test0(S({1,2,2}), 1, S({2,2}));
+    test0(S({1,2,2}), 2, S({1}));
+    test0(S({1,2,2}), 3, S({1,2,2}));
+
+//  Test cross-type erasure
+    using opt = std::optional<typename S::value_type>;
+    test0(S({1,2,1}), opt(),  S({1,2,1}));
+    test0(S({1,2,1}), opt(1), S({2}));
+    test0(S({1,2,1}), opt(2), S({1,1}));
+    test0(S({1,2,1}), opt(3), S({1,2,1}));
+}
+
+int main()
+{
+    test<std::forward_list<int>>();
+    test<std::forward_list<int, min_allocator<int>>> ();
+    test<std::forward_list<int, test_allocator<int>>> ();
+
+    test<std::forward_list<long>>();
+    test<std::forward_list<double>>();
+}

test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <forward_list>
+
+// template <class T, class Allocator, class Predicate>
+//   void erase_if(forward_list<T, Allocator>& c, Predicate pred);  
+
+#include <forward_list>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class Pred>
+void
+test0(S s, Pred p, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    assert(s == expected);
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v == 1;};
+    auto is2 = [](auto v) { return v == 2;};
+    auto is3 = [](auto v) { return v == 3;};
+    auto is4 = [](auto v) { return v == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0(S(), is1, S());
+
+    test0(S({1}), is1, S());
+    test0(S({1}), is2, S({1}));
+
+    test0(S({1,2}), is1, S({2}));
+    test0(S({1,2}), is2, S({1}));
+    test0(S({1,2}), is3, S({1,2}));
+    test0(S({1,1}), is1, S());
+    test0(S({1,1}), is3, S({1,1}));
+
+    test0(S({1,2,3}), is1, S({2,3}));
+    test0(S({1,2,3}), is2, S({1,3}));
+    test0(S({1,2,3}), is3, S({1,2}));
+    test0(S({1,2,3}), is4, S({1,2,3}));
+
+    test0(S({1,1,1}), is1, S());
+    test0(S({1,1,1}), is2, S({1,1,1}));
+    test0(S({1,1,2}), is1, S({2}));
+    test0(S({1,1,2}), is2, S({1,1}));
+    test0(S({1,1,2}), is3, S({1,1,2}));
+    test0(S({1,2,2}), is1, S({2,2}));
+    test0(S({1,2,2}), is2, S({1}));
+    test0(S({1,2,2}), is3, S({1,2,2}));
+    
+    test0(S({1,2,3}), True,  S());
+    test0(S({1,2,3}), False, S({1,2,3}));
+}
+
+int main()
+{
+    test<std::forward_list<int>>();
+    test<std::forward_list<int, min_allocator<int>>> ();
+    test<std::forward_list<int, test_allocator<int>>> ();
+
+    test<std::forward_list<long>>();
+    test<std::forward_list<double>>();
+}

test/std/containers/sequences/list/list.erasure/erase.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <list>
+
+// template <class T, class Allocator, class U>
+//   void erase(list<T, Allocator>& c, const U& value);
+  
+
+#include <list>
+#include <optional>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class U>
+void
+test0(S s,  U val, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase(s, val)));
+    std::erase(s, val);
+    assert(s == expected);
+}
+
+template <class S>
+void test()
+{
+
+    test0(S(), 1, S());
+
+    test0(S({1}), 1, S());
+    test0(S({1}), 2, S({1}));
+
+    test0(S({1,2}), 1, S({2}));
+    test0(S({1,2}), 2, S({1}));
+    test0(S({1,2}), 3, S({1,2}));
+    test0(S({1,1}), 1, S());
+    test0(S({1,1}), 3, S({1,1}));
+
+    test0(S({1,2,3}), 1, S({2,3}));
+    test0(S({1,2,3}), 2, S({1,3}));
+    test0(S({1,2,3}), 3, S({1,2}));
+    test0(S({1,2,3}), 4, S({1,2,3}));
+
+    test0(S({1,1,1}), 1, S());
+    test0(S({1,1,1}), 2, S({1,1,1}));
+    test0(S({1,1,2}), 1, S({2}));
+    test0(S({1,1,2}), 2, S({1,1}));
+    test0(S({1,1,2}), 3, S({1,1,2}));
+    test0(S({1,2,2}), 1, S({2,2}));
+    test0(S({1,2,2}), 2, S({1}));
+    test0(S({1,2,2}), 3, S({1,2,2}));
+
+//  Test cross-type erasure
+    using opt = std::optional<typename S::value_type>;
+    test0(S({1,2,1}), opt(),  S({1,2,1}));
+    test0(S({1,2,1}), opt(1), S({2}));
+    test0(S({1,2,1}), opt(2), S({1,1}));
+    test0(S({1,2,1}), opt(3), S({1,2,1}));
+}
+
+int main()
+{
+    test<std::list<int>>();
+    test<std::list<int, min_allocator<int>>> ();
+    test<std::list<int, test_allocator<int>>> ();
+
+    test<std::list<long>>();
+    test<std::list<double>>();
+}

test/std/containers/sequences/list/list.erasure/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <list>
+
+// template <class T, class Allocator, class Predicate>
+//   void erase_if(list<T, Allocator>& c, Predicate pred);  
+
+#include <list>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class Pred>
+void
+test0(S s, Pred p, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    assert(s == expected);
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v == 1;};
+    auto is2 = [](auto v) { return v == 2;};
+    auto is3 = [](auto v) { return v == 3;};
+    auto is4 = [](auto v) { return v == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0(S(), is1, S());
+
+    test0(S({1}), is1, S());
+    test0(S({1}), is2, S({1}));
+
+    test0(S({1,2}), is1, S({2}));
+    test0(S({1,2}), is2, S({1}));
+    test0(S({1,2}), is3, S({1,2}));
+    test0(S({1,1}), is1, S());
+    test0(S({1,1}), is3, S({1,1}));
+
+    test0(S({1,2,3}), is1, S({2,3}));
+    test0(S({1,2,3}), is2, S({1,3}));
+    test0(S({1,2,3}), is3, S({1,2}));
+    test0(S({1,2,3}), is4, S({1,2,3}));
+
+    test0(S({1,1,1}), is1, S());
+    test0(S({1,1,1}), is2, S({1,1,1}));
+    test0(S({1,1,2}), is1, S({2}));
+    test0(S({1,1,2}), is2, S({1,1}));
+    test0(S({1,1,2}), is3, S({1,1,2}));
+    test0(S({1,2,2}), is1, S({2,2}));
+    test0(S({1,2,2}), is2, S({1}));
+    test0(S({1,2,2}), is3, S({1,2,2}));
+    
+    test0(S({1,2,3}), True,  S());
+    test0(S({1,2,3}), False, S({1,2,3}));
+}
+
+int main()
+{
+    test<std::list<int>>();
+    test<std::list<int, min_allocator<int>>> ();
+    test<std::list<int, test_allocator<int>>> ();
+
+    test<std::list<long>>();
+    test<std::list<double>>();
+}

test/std/containers/sequences/vector/vector.erasure/erase.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <vector>
+
+// template <class T, class Allocator, class U>
+//   void erase(vector<T, Allocator>& c, const U& value);
+  
+
+#include <vector>
+#include <optional>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class U>
+void
+test0(S s,  U val, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase(s, val)));
+    std::erase(s, val);
+    assert(s == expected);
+}
+
+template <class S>
+void test()
+{
+
+    test0(S(), 1, S());
+
+    test0(S({1}), 1, S());
+    test0(S({1}), 2, S({1}));
+
+    test0(S({1,2}), 1, S({2}));
+    test0(S({1,2}), 2, S({1}));
+    test0(S({1,2}), 3, S({1,2}));
+    test0(S({1,1}), 1, S());
+    test0(S({1,1}), 3, S({1,1}));
+
+    test0(S({1,2,3}), 1, S({2,3}));
+    test0(S({1,2,3}), 2, S({1,3}));
+    test0(S({1,2,3}), 3, S({1,2}));
+    test0(S({1,2,3}), 4, S({1,2,3}));
+
+    test0(S({1,1,1}), 1, S());
+    test0(S({1,1,1}), 2, S({1,1,1}));
+    test0(S({1,1,2}), 1, S({2}));
+    test0(S({1,1,2}), 2, S({1,1}));
+    test0(S({1,1,2}), 3, S({1,1,2}));
+    test0(S({1,2,2}), 1, S({2,2}));
+    test0(S({1,2,2}), 2, S({1}));
+    test0(S({1,2,2}), 3, S({1,2,2}));
+
+//  Test cross-type erasure
+    using opt = std::optional<typename S::value_type>;
+    test0(S({1,2,1}), opt(),  S({1,2,1}));
+    test0(S({1,2,1}), opt(1), S({2}));
+    test0(S({1,2,1}), opt(2), S({1,1}));
+    test0(S({1,2,1}), opt(3), S({1,2,1}));
+}
+
+int main()
+{
+    test<std::vector<int>>();
+    test<std::vector<int, min_allocator<int>>> ();
+    test<std::vector<int, test_allocator<int>>> ();
+
+    test<std::vector<long>>();
+    test<std::vector<double>>();
+}

test/std/containers/sequences/vector/vector.erasure/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <vector>
+
+// template <class T, class Allocator, class Predicate>
+//   void erase_if(vector<T, Allocator>& c, Predicate pred);  
+
+#include <vector>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class Pred>
+void
+test0(S s, Pred p, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    assert(s == expected);
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v == 1;};
+    auto is2 = [](auto v) { return v == 2;};
+    auto is3 = [](auto v) { return v == 3;};
+    auto is4 = [](auto v) { return v == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0(S(), is1, S());
+
+    test0(S({1}), is1, S());
+    test0(S({1}), is2, S({1}));
+
+    test0(S({1,2}), is1, S({2}));
+    test0(S({1,2}), is2, S({1}));
+    test0(S({1,2}), is3, S({1,2}));
+    test0(S({1,1}), is1, S());
+    test0(S({1,1}), is3, S({1,1}));
+
+    test0(S({1,2,3}), is1, S({2,3}));
+    test0(S({1,2,3}), is2, S({1,3}));
+    test0(S({1,2,3}), is3, S({1,2}));
+    test0(S({1,2,3}), is4, S({1,2,3}));
+
+    test0(S({1,1,1}), is1, S());
+    test0(S({1,1,1}), is2, S({1,1,1}));
+    test0(S({1,1,2}), is1, S({2}));
+    test0(S({1,1,2}), is2, S({1,1}));
+    test0(S({1,1,2}), is3, S({1,1,2}));
+    test0(S({1,2,2}), is1, S({2,2}));
+    test0(S({1,2,2}), is2, S({1}));
+    test0(S({1,2,2}), is3, S({1,2,2}));
+    
+    test0(S({1,2,3}), True,  S());
+    test0(S({1,2,3}), False, S({1,2,3}));
+}
+
+int main()
+{
+    test<std::vector<int>>();
+    test<std::vector<int, min_allocator<int>>> ();
+    test<std::vector<int, test_allocator<int>>> ();
+
+    test<std::vector<long>>();
+    test<std::vector<double>>();
+}

test/std/containers/unord/unord.map/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash, class Pred, class Allocator, class Predicate>
+//   void erase_if(unordered_map<Key, T, Hash, Pred, Allocator>& c, Predicate pred);
+
+#include <unordered_map>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+using Init = std::initializer_list<int>;
+template <typename M>
+M make (Init vals)
+{
+    M ret;
+    for (int v : vals)
+        ret[v] = v + 10;
+    return ret;
+}
+
+template <typename M, typename Pred>
+void
+test0(Init vals, Pred p, Init expected)
+{
+    M s = make<M> (vals);
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    M e = make<M>(expected);
+    assert((std::is_permutation(s.begin(), s.end(), e.begin(), e.end())));
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v.first == 1;};
+    auto is2 = [](auto v) { return v.first == 2;};
+    auto is3 = [](auto v) { return v.first == 3;};
+    auto is4 = [](auto v) { return v.first == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0<S>({}, is1, {});
+
+    test0<S>({1}, is1, {});
+    test0<S>({1}, is2, {1});
+
+    test0<S>({1,2}, is1, {2});
+    test0<S>({1,2}, is2, {1});
+    test0<S>({1,2}, is3, {1,2});
+
+    test0<S>({1,2,3}, is1, {2,3});
+    test0<S>({1,2,3}, is2, {1,3});
+    test0<S>({1,2,3}, is3, {1,2});
+    test0<S>({1,2,3}, is4, {1,2,3});
+
+    test0<S>({1,2,3}, True,  {});
+    test0<S>({1,2,3}, False, {1,2,3});
+}
+
+int main()
+{
+    test<std::unordered_map<int, int>>();
+    test<std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>>> ();
+    test<std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int, int>>>> ();
+
+    test<std::unordered_map<long, short>>();
+    test<std::unordered_map<short, double>>();
+}
+

test/std/containers/unord/unord.multimap/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash, class Pred, class Allocator, class Predicate>
+//   void erase_if(unordered_multimap<Key, T, Hash, Pred, Allocator>& c, Predicate pred);
+
+#include <unordered_map>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+using Init = std::initializer_list<int>;
+template <typename M>
+M make (Init vals)
+{
+    M ret;
+    for (int v : vals)
+        ret.insert(typename M::value_type(v, v + 10));
+    return ret;
+}
+
+template <typename M, typename Pred>
+void
+test0(Init vals, Pred p, Init expected)
+{
+    M s = make<M> (vals);
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    M e = make<M>(expected);
+    assert((std::is_permutation(s.begin(), s.end(), e.begin(), e.end())));
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v.first == 1;};
+    auto is2 = [](auto v) { return v.first == 2;};
+    auto is3 = [](auto v) { return v.first == 3;};
+    auto is4 = [](auto v) { return v.first == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0<S>({}, is1, {});
+
+    test0<S>({1}, is1, {});
+    test0<S>({1}, is2, {1});
+
+    test0<S>({1,2}, is1, {2});
+    test0<S>({1,2}, is2, {1});
+    test0<S>({1,2}, is3, {1,2});
+    test0<S>({1,1}, is1, {});
+    test0<S>({1,1}, is3, {1,1});
+
+    test0<S>({1,2,3}, is1, {2,3});
+    test0<S>({1,2,3}, is2, {1,3});
+    test0<S>({1,2,3}, is3, {1,2});
+    test0<S>({1,2,3}, is4, {1,2,3});
+
+    test0<S>({1,1,1}, is1, {});
+    test0<S>({1,1,1}, is2, {1,1,1});
+    test0<S>({1,1,2}, is1, {2});
+    test0<S>({1,1,2}, is2, {1,1});
+    test0<S>({1,1,2}, is3, {1,1,2});
+    test0<S>({1,2,2}, is1, {2,2});
+    test0<S>({1,2,2}, is2, {1});
+    test0<S>({1,2,2}, is3, {1,2,2});
+    
+    test0<S>({1,2,3}, True,  {});
+    test0<S>({1,2,3}, False, {1,2,3});
+}
+
+int main()
+{
+    test<std::unordered_multimap<int, int>>();
+    test<std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>>> ();
+    test<std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int, int>>>> ();
+
+    test<std::unordered_multimap<long, short>>();
+    test<std::unordered_multimap<short, double>>();
+}

test/std/containers/unord/unord.multiset/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <set>
+
+// template <class T, class Hash, class Compare, class Allocator, class Predicate>
+//   void erase_if(unordered_multiset<T, Hash, Compare, Allocator>& c, Predicate pred);
+
+#include <unordered_set>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+using Init = std::initializer_list<int>;
+
+template <typename M>
+M make (Init vals)
+{
+    M ret;
+    for (int v : vals)
+        ret.insert(v);
+    return ret;
+}
+
+template <typename M, typename Pred>
+void
+test0(Init vals, Pred p, Init expected)
+{
+    M s = make<M> (vals);
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    M e = make<M>(expected);
+    assert((std::is_permutation(s.begin(), s.end(), e.begin(), e.end())));
+}
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v == 1;};
+    auto is2 = [](auto v) { return v == 2;};
+    auto is3 = [](auto v) { return v == 3;};
+    auto is4 = [](auto v) { return v == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0<S>({}, is1, {});
+
+    test0<S>({1}, is1, {});
+    test0<S>({1}, is2, {1});
+
+    test0<S>({1,2}, is1, {2});
+    test0<S>({1,2}, is2, {1});
+    test0<S>({1,2}, is3, {1,2});
+    test0<S>({1,1}, is1, {});
+    test0<S>({1,1}, is3, {1,1});
+
+    test0<S>({1,2,3}, is1, {2,3});
+    test0<S>({1,2,3}, is2, {1,3});
+    test0<S>({1,2,3}, is3, {1,2});
+    test0<S>({1,2,3}, is4, {1,2,3});
+
+    test0<S>({1,1,1}, is1, {});
+    test0<S>({1,1,1}, is2, {1,1,1});
+    test0<S>({1,1,2}, is1, {2});
+    test0<S>({1,1,2}, is2, {1,1});
+    test0<S>({1,1,2}, is3, {1,1,2});
+    test0<S>({1,2,2}, is1, {2,2});
+    test0<S>({1,2,2}, is2, {1});
+    test0<S>({1,2,2}, is3, {1,2,2});
+    
+    test0<S>({1,2,3}, True,  {});
+    test0<S>({1,2,3}, False, {1,2,3});
+}
+
+int main()
+{
+    test<std::unordered_multiset<int>>();
+    test<std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>>> ();
+    test<std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, test_allocator<int>>> ();
+
+    test<std::unordered_multiset<long>>();
+    test<std::unordered_multiset<double>>();
+}

test/std/containers/unord/unord.set/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <unordered_set>
+
+// template <class T, class Hash, class Compare, class Allocator, class Predicate>
+//   void erase_if(unorderd_set<T, Hash, Compare, Allocator>& c, Predicate pred);
+
+#include <unordered_set>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+using Init = std::initializer_list<int>;
+
+template <typename M>
+M make (Init vals)
+{
+    M ret;
+    for (int v : vals)
+        ret.insert(v);
+    return ret;
+}
+
+template <typename M, typename Pred>
+void
+test0(Init vals, Pred p, Init expected)
+{
+    M s = make<M> (vals);
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    M e = make<M>(expected);
+    assert((std::is_permutation(s.begin(), s.end(), e.begin(), e.end())));
+}
+
+
+template <typename S>
+void test()
+{
+    auto is1 = [](auto v) { return v == 1;};
+    auto is2 = [](auto v) { return v == 2;};
+    auto is3 = [](auto v) { return v == 3;};
+    auto is4 = [](auto v) { return v == 4;};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0<S>({}, is1, {});
+
+    test0<S>({1}, is1, {});
+    test0<S>({1}, is2, {1});
+
+    test0<S>({1,2}, is1, {2});
+    test0<S>({1,2}, is2, {1});
+    test0<S>({1,2}, is3, {1,2});
+
+    test0<S>({1,2,3}, is1, {2,3});
+    test0<S>({1,2,3}, is2, {1,3});
+    test0<S>({1,2,3}, is3, {1,2});
+    test0<S>({1,2,3}, is4, {1,2,3});
+
+    test0<S>({1,2,3}, True,  {});
+    test0<S>({1,2,3}, False, {1,2,3});
+}
+
+int main()
+{
+    test<std::unordered_set<int>>();
+    test<std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>>> ();
+    test<std::unordered_set<int, std::hash<int>, std::equal_to<int>, test_allocator<int>>> ();
+
+    test<std::unordered_set<long>>();
+    test<std::unordered_set<double>>();
+}

test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp

 
 /*  Constant                                    Value
     __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_erase_if                          201811L
     __cpp_lib_nonmember_container_access        201411L
 
 */

 {
 //  ensure that the macros that are supposed to be defined in <deque> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_erase_if)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
+# else
+#  if __cpp_lib_erase_if < 201811L
+#   error "__cpp_lib_erase_if has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp

 
 /*  Constant                                    Value
     __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_erase_if                          201811L
     __cpp_lib_incomplete_container_elements     201505L
     __cpp_lib_list_remove_return_type           201806L
     __cpp_lib_nonmember_container_access        201411L

 {
 //  ensure that the macros that are supposed to be defined in <forward_list> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_erase_if)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
+# else
+#  if __cpp_lib_erase_if < 201811L
+#   error "__cpp_lib_erase_if has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp

 
 /*  Constant                                    Value
     __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_erase_if                          201811L
     __cpp_lib_incomplete_container_elements     201505L
     __cpp_lib_list_remove_return_type           201806L
     __cpp_lib_nonmember_container_access        201411L

 {
 //  ensure that the macros that are supposed to be defined in <list> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_erase_if)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
+# else
+#  if __cpp_lib_erase_if < 201811L
+#   error "__cpp_lib_erase_if has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp

 
 /*  Constant                                    Value
     __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_erase_if                          201811L
     __cpp_lib_generic_associative_lookup        201304L
     __cpp_lib_map_try_emplace                   201411L
     __cpp_lib_node_extract                      201606L

 {
 //  ensure that the macros that are supposed to be defined in <map> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_erase_if)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
+# else
+#  if __cpp_lib_erase_if < 201811L
+#   error "__cpp_lib_erase_if has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp

 
 /*  Constant                                    Value
     __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_erase_if                          201811L
     __cpp_lib_generic_associative_lookup        201304L
     __cpp_lib_node_extract                      201606L
     __cpp_lib_nonmember_container_access        201411L

 {
 //  ensure that the macros that are supposed to be defined in <set> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_erase_if)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
+# else
+#  if __cpp_lib_erase_if < 201811L
+#   error "__cpp_lib_erase_if has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp

 
 /*  Constant                                    Value
     __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_erase_if                          201811L
     __cpp_lib_nonmember_container_access        201411L
     __cpp_lib_string_udls                       201304L
     __cpp_lib_string_view                       201606L

 {
 //  ensure that the macros that are supposed to be defined in <string> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_erase_if)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
+# else
+#  if __cpp_lib_erase_if < 201811L
+#   error "__cpp_lib_erase_if has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp

 
 /*  Constant                                    Value
     __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_erase_if                          201811L
     __cpp_lib_node_extract                      201606L
     __cpp_lib_nonmember_container_access        201411L
     __cpp_lib_unordered_map_try_emplace         201411L

 {
 //  ensure that the macros that are supposed to be defined in <unordered_map> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_erase_if)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
+# else
+#  if __cpp_lib_erase_if < 201811L
+#   error "__cpp_lib_erase_if has an invalid value"
+#  endif
+# endif
+#endif
+
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp

 
 /*  Constant                                    Value
     __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_erase_if                          201811L
     __cpp_lib_node_extract                      201606L
     __cpp_lib_nonmember_container_access        201411L
 

 {
 //  ensure that the macros that are supposed to be defined in <unordered_set> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_erase_if)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
+# else
+#  if __cpp_lib_erase_if < 201811L
+#   error "__cpp_lib_erase_if has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp

 
 /*  Constant                                    Value
     __cpp_lib_allocator_traits_is_always_equal  201411L
+    __cpp_lib_erase_if                          201811L
     __cpp_lib_incomplete_container_elements     201505L
     __cpp_lib_nonmember_container_access        201411L
 

 {
 //  ensure that the macros that are supposed to be defined in <vector> are defined.
 
+#if TEST_STD_VER > 17
+# if !defined(__cpp_lib_erase_if)  
+  LIBCPP_STATIC_ASSERT(false, "__cpp_lib_erase_if is not defined");
+# else
+#  if __cpp_lib_erase_if < 201811L
+#   error "__cpp_lib_erase_if has an invalid value"
+#  endif
+# endif
+#endif
+
 /*
 #if !defined(__cpp_lib_fooby)
 # error "__cpp_lib_fooby is not defined"

test/std/strings/strings.erasure/erase.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template <class charT, class traits, class Allocator, class U>
+//   void erase(basic_string<charT, traits, Allocator>& c, const U& value);
+  
+
+#include <string>
+#include <optional>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class U>
+void
+test0(S s,  U val, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase(s, val)));
+    std::erase(s, val);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+}
+
+template <class S>
+void test()
+{
+
+    test0(S(""), 'a', S(""));
+
+    test0(S("a"), 'a', S(""));
+    test0(S("a"), 'b', S("a"));
+
+    test0(S("ab"), 'a', S("b"));
+    test0(S("ab"), 'b', S("a"));
+    test0(S("ab"), 'c', S("ab"));
+    test0(S("aa"), 'a', S(""));
+    test0(S("aa"), 'c', S("aa"));
+
+    test0(S("abc"), 'a', S("bc"));
+    test0(S("abc"), 'b', S("ac"));
+    test0(S("abc"), 'c', S("ab"));
+    test0(S("abc"), 'd', S("abc"));
+
+    test0(S("aab"), 'a', S("b"));
+    test0(S("aab"), 'b', S("aa"));
+    test0(S("aab"), 'c', S("aab"));
+    test0(S("abb"), 'a', S("bb"));
+    test0(S("abb"), 'b', S("a"));
+    test0(S("abb"), 'c', S("abb"));
+    test0(S("aaa"), 'a', S(""));
+    test0(S("aaa"), 'b', S("aaa"));
+
+//  Test cross-type erasure
+    using opt = std::optional<typename S::value_type>;
+    test0(S("aba"), opt(),    S("aba"));
+    test0(S("aba"), opt('a'), S("b"));
+    test0(S("aba"), opt('b'), S("aa"));
+    test0(S("aba"), opt('c'), S("aba"));
+}
+
+int main()
+{
+    test<std::string>();
+    test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
+    test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
+}

test/std/strings/strings.erasure/erase_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+// template <class charT, class traits, class Allocator, class Predicate>
+//   void erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);  
+
+#include <string>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "min_allocator.h"
+
+template <class S, class Pred>
+void
+test0(S s, Pred p, S expected)
+{
+    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
+    std::erase_if(s, p);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+}
+
+template <typename S>
+void test()
+{
+    auto isA = [](auto ch) { return ch == 'a';};
+    auto isB = [](auto ch) { return ch == 'b';};
+    auto isC = [](auto ch) { return ch == 'c';};
+    auto isD = [](auto ch) { return ch == 'd';};
+    auto True  = [](auto) { return true; };
+    auto False = [](auto) { return false; };
+    
+    test0(S(""), isA, S(""));
+
+    test0(S("a"), isA, S(""));
+    test0(S("a"), isB, S("a"));
+
+    test0(S("ab"), isA, S("b"));
+    test0(S("ab"), isB, S("a"));
+    test0(S("ab"), isC, S("ab"));
+    test0(S("aa"), isA, S(""));
+    test0(S("aa"), isC, S("aa"));
+
+    test0(S("abc"), isA, S("bc"));
+    test0(S("abc"), isB, S("ac"));
+    test0(S("abc"), isC, S("ab"));
+    test0(S("abc"), isD, S("abc"));
+
+    test0(S("aab"), isA, S("b"));
+    test0(S("aab"), isB, S("aa"));
+    test0(S("aab"), isC, S("aab"));
+    test0(S("abb"), isA, S("bb"));
+    test0(S("abb"), isB, S("a"));
+    test0(S("abb"), isC, S("abb"));
+    test0(S("aaa"), isA, S(""));
+    test0(S("aaa"), isB, S("aaa"));
+
+    test0(S("aba"), False,  S("aba"));
+    test0(S("aba"), True,   S(""));
+}
+
+int main()
+{
+    test<std::string>();
+    test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
+    test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
+}

www/cxx2a_status.html

   <tr><td><a href="https://wg21.link/P1123R0">P1123R0</a></td><td>LWG</td><td>Editorial Guidance for merging P0019r8 and P0528r3</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1148R0">P1148R0</a></td><td>LWG</td><td>Cleaning up Clause 20</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1165R1">P1165R1</a></td><td>LWG</td><td>Make stateful allocator propagation more consistent for <tt>operator+(basic_string)</tt></td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1209R0">P1209R0</a></td><td>LWG</td><td>Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20</td><td>San Diego</td><td><i> </i></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P1209R0">P1209R0</a></td><td>LWG</td><td>Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P1210R0">P1210R0</a></td><td>LWG</td><td>Completing the Rebase of Library Fundamentals, Version 3, Working Draft</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1236R1">P1236R1</a></td><td>CWG</td><td>Alternative Wording for P0907R4 Signed Integers are Two's Complement</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1248R1">P1248R1</a></td><td>LWG</td><td>Remove CommonReference requirement from StrictWeakOrdering (a.k.a Fixing Relations)</td><td>San Diego</td><td><i> </i></td><td></td></tr>