Implementing erase/erase_if functions from library fundamentals ts:

base/containers/flat_set.h

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_CONTAINERS_FLAT_SET_H_
 #define BASE_CONTAINERS_FLAT_SET_H_
 
 #include <algorithm>
 #include <functional>
 #include <utility>
@@ skipping 14 matching lines @@
 // be very fast for set operations and for small number of elements.
 //
 // Usage guidance:
 // Prefer base::flat_set for:
 //  * Very small sets, something that is an easy fit for cache. Consider
 //    "very small" to be under a 100 32bit integers.
 //  * Sets that are built once (using flat_set::flat_set(first, last)). Consider
 //    collecting all data in a vector and then building flat_set out of it.
 //    TODO(dyaroshev): improve the interface to better support this pattern
 //    (crbug.com/682254).
-//  * Sets where mutating happens in big bulks: use erase(std::remove()) idiom
-//    for erasing many elements. Insertion is harder - consider set operations
-//    or building a new vector. Set operations can be slow if one of the sets
-//    is considerably bigger. Also be aware that beating performance of
-//    sort + unique (implementation of flat_set's constructor) is hard, clever
-//    merge of many sets might not win. Generally avoid inserting into flat set
-//    without benchmarks.
+//  * Sets where mutating happens in big bulks: to erase multiple elements, use
+//    base::EraseIf() rather than repeated single-element removal. Insertion is
+//    harder - consider set operations or building a new vector. Set operations
+//    can be slow if one of the sets is considerably bigger. Also be aware that
+//    beating performance of sort + unique (implementation of flat_set's
+//    constructor) is hard, clever merge of many sets might not win. Generally
+//    avoid inserting into flat set without benchmarks.
 //  * Copying and iterating.
 //  * Set operations (union/intersect etc).
 //
 // Prefer to build a new flat_set from a std::vector (or similar) instead of
 // calling insert() repeatedly, which would have O(size^2) complexity.
 //
 // TODO(dyaroshev): develop standalone benchmarks to find performance boundaries
 // for different types of sets crbug.com/682215.
 //
 // If you do write a benchmark that significantly depends on using sets please
@@ skipping 157 matching lines @@
   iterator emplace_hint(const_iterator position_hint, Args&&... args);
 
   // --------------------------------------------------------------------------
   // Erase operations.
   //
   // Assume that every operation invalidates iterators and references.
   //
   // erase(position), erase(first, last) can take O(size).
   // erase(key) may take O(size) + O(log(size)).
   //
-  // Prefer the erase(std::remove(), end()) idiom for deleting multiple
-  // elements.
+  // Prefer base::EraseIf() or some other variation on erase(remove(), end())
+  // idiom when deleting multiple non-consecutive elements.
 
   iterator erase(const_iterator position);
   iterator erase(const_iterator first, const_iterator last);
   size_type erase(const key_type& key);
 
   // --------------------------------------------------------------------------
   // Comparators.
 
   key_compare key_comp() const;
   value_compare value_comp() const;
@@ skipping 419 matching lines @@
 }
 
 // ----------------------------------------------------------------------------
 // General operations.
 
 template <class Key, class Compare>
 void flat_set<Key, Compare>::swap(flat_set& other) {
   std::swap(impl_, other.impl_);
 }
 
+// ----------------------------------------------------------------------------
+// Free functions.
+
+// Erases all elements that match predicate. It has O(size) complexity.
+template <typename Key, typename Compare, typename Predicate>
+void EraseIf(base::flat_set<Key, Compare>& container, Predicate pred) {
+  container.erase(std::remove_if(container.begin(), container.end(), pred),
+                  container.end());
+}
+
 }  // namespace  base
 
 #endif  // BASE_CONTAINERS_FLAT_SET_H_