react-native-windows 0.84.0 → 0.85.0-preview.2

package/external/folly/folly/container/F14Map.h

@@ -0,0 +1,2108 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+/**
+ * F14NodeMap, F14ValueMap, and F14VectorMap
+ *
+ * F14FastMap conditionally works like F14ValueMap or F14VectorMap
+ *
+ * See F14.md
+ */
+
+#include <cstddef>
+#include <initializer_list>
+#include <stdexcept>
+#include <tuple>
+
+#include <folly/Portability.h>
+#include <folly/Range.h>
+#include <folly/Traits.h>
+#include <folly/container/View.h>
+#include <folly/lang/Exception.h>
+#include <folly/lang/SafeAssert.h>
+
+#include <folly/container/F14Map-fwd.h>
+#include <folly/container/Iterator.h>
+#include <folly/container/detail/F14MapFallback.h>
+#include <folly/container/detail/F14Policy.h>
+#include <folly/container/detail/F14Table.h>
+#include <folly/container/detail/Util.h>
+
+namespace folly {
+
+#if FOLLY_F14_VECTOR_INTRINSICS_AVAILABLE
+
+//////// Common case for supported platforms
+
+namespace f14 {
+namespace detail {
+
+template <typename Policy>
+class F14BasicMap {
+  template <typename K, typename T>
+  using EnableHeterogeneousFind = std::enable_if_t<
+      ::folly::detail::EligibleForHeterogeneousFind<
+          typename Policy::Key,
+          typename Policy::Hasher,
+          typename Policy::KeyEqual,
+          K>::value,
+      T>;
+
+  template <typename K, typename T>
+  using EnableHeterogeneousInsert = std::enable_if_t<
+      ::folly::detail::EligibleForHeterogeneousInsert<
+          typename Policy::Key,
+          typename Policy::Hasher,
+          typename Policy::KeyEqual,
+          K>::value,
+      T>;
+
+  template <typename K>
+  using IsIter = Disjunction<
+      std::is_same<typename Policy::Iter, remove_cvref_t<K>>,
+      std::is_same<typename Policy::ConstIter, remove_cvref_t<K>>>;
+
+  template <typename K, typename T>
+  using EnableHeterogeneousErase = std::enable_if_t<
+      ::folly::detail::EligibleForHeterogeneousFind<
+          typename Policy::Key,
+          typename Policy::Hasher,
+          typename Policy::KeyEqual,
+          std::conditional_t<IsIter<K>::value, typename Policy::Key, K>>::
+              value &&
+          !IsIter<K>::value,
+      T>;
+
+ public:
+  //// PUBLIC - Member types
+
+  using key_type = typename Policy::Key;
+  using mapped_type = typename Policy::Mapped;
+  using value_type = typename Policy::Value;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+  using hash_token_type = F14HashToken;
+  using hasher = typename Policy::Hasher;
+  using key_equal = typename Policy::KeyEqual;
+  using allocator_type = typename Policy::Alloc;
+  using reference = value_type&;
+  using const_reference = value_type const&;
+  using pointer = typename Policy::AllocTraits::pointer;
+  using const_pointer = typename Policy::AllocTraits::const_pointer;
+  using iterator = typename Policy::Iter;
+  using const_iterator = typename Policy::ConstIter;
+
+ private:
+  using ItemIter = typename Policy::ItemIter;
+
+ public:
+  //// PUBLIC - Member functions
+
+  F14BasicMap() noexcept(Policy::kDefaultConstructIsNoexcept) : table_{} {}
+
+  explicit F14BasicMap(
+      std::size_t initialCapacity,
+      hasher const& hash = hasher{},
+      key_equal const& eq = key_equal{},
+      allocator_type const& alloc = allocator_type{})
+      : table_{initialCapacity, hash, eq, alloc} {}
+
+  explicit F14BasicMap(std::size_t initialCapacity, allocator_type const& alloc)
+      : F14BasicMap(initialCapacity, hasher{}, key_equal{}, alloc) {}
+
+  explicit F14BasicMap(
+      std::size_t initialCapacity,
+      hasher const& hash,
+      allocator_type const& alloc)
+      : F14BasicMap(initialCapacity, hash, key_equal{}, alloc) {}
+
+  explicit F14BasicMap(allocator_type const& alloc)
+      : F14BasicMap(0, hasher{}, key_equal{}, alloc) {}
+
+  template <typename InputIt>
+  F14BasicMap(
+      InputIt first,
+      InputIt last,
+      std::size_t initialCapacity = 0,
+      hasher const& hash = hasher{},
+      key_equal const& eq = key_equal{},
+      allocator_type const& alloc = allocator_type{})
+      : table_{initialCapacity, hash, eq, alloc} {
+    initialInsert(std::move(first), std::move(last), initialCapacity);
+  }
+
+  template <typename InputIt>
+  F14BasicMap(
+      InputIt first,
+      InputIt last,
+      std::size_t initialCapacity,
+      allocator_type const& alloc)
+      : table_{initialCapacity, hasher{}, key_equal{}, alloc} {
+    initialInsert(std::move(first), std::move(last), initialCapacity);
+  }
+
+  template <typename InputIt>
+  F14BasicMap(
+      InputIt first,
+      InputIt last,
+      std::size_t initialCapacity,
+      hasher const& hash,
+      allocator_type const& alloc)
+      : table_{initialCapacity, hash, key_equal{}, alloc} {
+    initialInsert(std::move(first), std::move(last), initialCapacity);
+  }
+
+  F14BasicMap(F14BasicMap const& rhs) = default;
+
+  F14BasicMap(F14BasicMap const& rhs, allocator_type const& alloc)
+      : table_{rhs.table_, alloc} {}
+
+  F14BasicMap(F14BasicMap&& rhs) = default;
+
+  F14BasicMap(F14BasicMap&& rhs, allocator_type const& alloc) noexcept(
+      Policy::kAllocIsAlwaysEqual)
+      : table_{std::move(rhs.table_), alloc} {}
+
+  /* implicit */ F14BasicMap(
+      std::initializer_list<value_type> init,
+      std::size_t initialCapacity = 0,
+      hasher const& hash = hasher{},
+      key_equal const& eq = key_equal{},
+      allocator_type const& alloc = allocator_type{})
+      : table_{initialCapacity, hash, eq, alloc} {
+    initialInsert(init.begin(), init.end(), initialCapacity);
+  }
+
+  F14BasicMap(
+      std::initializer_list<value_type> init,
+      std::size_t initialCapacity,
+      allocator_type const& alloc)
+      : table_{initialCapacity, hasher{}, key_equal{}, alloc} {
+    initialInsert(init.begin(), init.end(), initialCapacity);
+  }
+
+  F14BasicMap(
+      std::initializer_list<value_type> init,
+      std::size_t initialCapacity,
+      hasher const& hash,
+      allocator_type const& alloc)
+      : table_{initialCapacity, hash, key_equal{}, alloc} {
+    initialInsert(init.begin(), init.end(), initialCapacity);
+  }
+
+  F14BasicMap& operator=(F14BasicMap const&) = default;
+
+  F14BasicMap& operator=(F14BasicMap&&) = default;
+
+  F14BasicMap& operator=(std::initializer_list<value_type> ilist) {
+    clear();
+    bulkInsert(ilist.begin(), ilist.end(), true);
+    return *this;
+  }
+
+  /// Get the allocator for this container.
+  /// @methodset Allocator
+  allocator_type get_allocator() const noexcept { return table_.alloc(); }
+
+  //// PUBLIC - Iterators
+
+  /// Get an iterator to the beginning
+  /// @methodset Iterators
+  iterator begin() noexcept { return table_.makeIter(table_.begin()); }
+  const_iterator begin() const noexcept { return cbegin(); }
+  /// Get an iterator to the beginning
+  /// @methodset Iterators
+  const_iterator cbegin() const noexcept {
+    return table_.makeConstIter(table_.begin());
+  }
+
+  /// Get an iterator to the end
+  /// @methodset Iterators
+  iterator end() noexcept { return table_.makeIter(table_.end()); }
+  const_iterator end() const noexcept { return cend(); }
+  /// Get an iterator to the end
+  /// @methodset Iterators
+  const_iterator cend() const noexcept {
+    return table_.makeConstIter(table_.end());
+  }
+
+  //// PUBLIC - Capacity
+
+  /// Check if this container has any elements.
+  /// @methodset Capacity
+  bool empty() const noexcept { return table_.empty(); }
+
+  /// Number of elements in this container.
+  /// @methodset Capacity
+  std::size_t size() const noexcept { return table_.size(); }
+
+  /// The maximum size of this container.
+  /// @methodset Capacity
+  std::size_t max_size() const noexcept { return table_.max_size(); }
+
+  //// PUBLIC - Modifiers
+
+  /**
+   * Remove all elements.
+   * @methodset Modifiers
+   *
+   * Frees heap-allocated memory; bucket_count is returned to 0.
+   */
+  void clear() noexcept { table_.clear(); }
+
+  /**
+   * Add a single element.
+   * @overloadbrief Add elements.
+   * @methodset Modifiers
+   */
+  std::pair<iterator, bool> insert(value_type const& value) {
+    return emplace(value);
+  }
+
+  /// Add a single element, of a heterogeneous type.
+  template <typename P>
+  std::enable_if_t<
+      std::is_constructible<value_type, P&&>::value,
+      std::pair<iterator, bool>>
+  insert(P&& value) {
+    return emplace(std::forward<P>(value));
+  }
+
+  /**
+   * Add a single element, of a heterogeneous type.
+   *
+   * TODO(T31574848): Work around libstdc++ versions (e.g., GCC < 6) with no
+   * implementation of N4387 ("perfect initialization" for pairs and tuples).
+   */
+  template <typename U1, typename U2>
+  std::enable_if_t<
+      std::is_constructible<key_type, U1 const&>::value &&
+          std::is_constructible<mapped_type, U2 const&>::value,
+      std::pair<iterator, bool>>
+  insert(std::pair<U1, U2> const& value) {
+    return emplace(value);
+  }
+
+  /**
+   * Add a single element, of a heterogeneous type.
+   *
+   * TODO(T31574848): Work around libstdc++ versions (e.g., GCC < 6) with no
+   * implementation of N4387 ("perfect initialization" for pairs and tuples).
+   */
+  template <typename U1, typename U2>
+  std::enable_if_t<
+      std::is_constructible<key_type, U1&&>::value &&
+          std::is_constructible<mapped_type, U2&&>::value,
+      std::pair<iterator, bool>>
+  insert(std::pair<U1, U2>&& value) {
+    return emplace(std::move(value));
+  }
+
+  /// Add a single element.
+  std::pair<iterator, bool> insert(value_type&& value) {
+    return emplace(std::move(value));
+  }
+
+  // std::unordered_map's hinted insertion API is misleading.  No
+  // implementation I've seen actually uses the hint.  Code restructuring
+  // by the caller to use the hinted API is at best unnecessary, and at
+  // worst a pessimization.  It is used, however, so we provide it.
+
+  /// Add a single element, with a locational hint.
+  iterator insert(const_iterator /*hint*/, value_type const& value) {
+    return insert(value).first;
+  }
+
+  /// Add a single element, of heterogeneous type, with a locational hint.
+  template <typename P>
+  std::enable_if_t<std::is_constructible<value_type, P&&>::value, iterator>
+  insert(const_iterator /*hint*/, P&& value) {
+    return insert(std::forward<P>(value)).first;
+  }
+
+  /// Add a single element, with a locational hint.
+  iterator insert(const_iterator /*hint*/, value_type&& value) {
+    return insert(std::move(value)).first;
+  }
+
+  /// Emplace with hint.
+  /// @methodset Modifiers
+  template <class... Args>
+  iterator emplace_hint(const_iterator /*hint*/, Args&&... args) {
+    return emplace(std::forward<Args>(args)...).first;
+  }
+
+ private:
+  template <class InputIt>
+  FOLLY_ALWAYS_INLINE void bulkInsert(
+      InputIt first, InputIt last, bool autoReserve) {
+    if (autoReserve) {
+      auto n = std::distance(first, last);
+      if (n == 0) {
+        return;
+      }
+      table_.reserveForInsert(n);
+    }
+    while (first != last) {
+      insert(*first);
+      ++first;
+    }
+  }
+
+  template <class InputIt>
+  void initialInsert(InputIt first, InputIt last, std::size_t initialCapacity) {
+    FOLLY_SAFE_DCHECK(empty() && bucket_count() >= initialCapacity, "");
+
+    // It's possible that there are a lot of duplicates in first..last and
+    // so we will oversize ourself.  The common case, however, is that
+    // we can avoid a lot of rehashing if we pre-expand.  The behavior
+    // is easy to disable at a particular call site by asking for an
+    // initialCapacity of 1.
+    bool autoReserve =
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<InputIt>::iterator_category>::value &&
+        initialCapacity == 0;
+    bulkInsert(std::move(first), std::move(last), autoReserve);
+  }
+
+ public:
+  /// Add elements
+  template <class InputIt>
+  void insert(InputIt first, InputIt last) {
+    // Bulk reserve is a heuristic choice, so it can backfire.  We restrict
+    // ourself to situations that mimic bulk construction without an
+    // explicit initialCapacity.
+    bool autoReserve =
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<InputIt>::iterator_category>::value &&
+        bucket_count() == 0;
+    bulkInsert(std::move(first), std::move(last), autoReserve);
+  }
+
+  /// Add elements from an initializer list
+  void insert(std::initializer_list<value_type> ilist) {
+    insert(ilist.begin(), ilist.end());
+  }
+
+  /// Insert if the key is missing, overwrite using operator= if present.
+  /// @methodset Modifiers
+  template <typename M>
+  std::pair<iterator, bool> insert_or_assign(key_type const& key, M&& obj) {
+    auto rv = try_emplace(key, std::forward<M>(obj));
+    if (!rv.second) {
+      rv.first->second = std::forward<M>(obj);
+    }
+    return rv;
+  }
+
+  template <typename M>
+  std::pair<iterator, bool> insert_or_assign(key_type&& key, M&& obj) {
+    auto rv = try_emplace(std::move(key), std::forward<M>(obj));
+    if (!rv.second) {
+      rv.first->second = std::forward<M>(obj);
+    }
+    return rv;
+  }
+
+  template <typename M>
+  std::pair<iterator, bool> insert_or_assign(
+      F14HashToken const& token, key_type const& key, M&& obj) {
+    auto rv = try_emplace_token(token, key, std::forward<M>(obj));
+    if (!rv.second) {
+      rv.first->second = std::forward<M>(obj);
+    }
+    return rv;
+  }
+
+  template <typename M>
+  std::pair<iterator, bool> insert_or_assign(
+      const F14HashedKey<key_type, hasher>& hashedKey, M&& obj) {
+    return insert_or_assign(
+        hashedKey.getHashToken(), hashedKey.getKey(), std::forward<M>(obj));
+  }
+
+  template <typename M>
+  std::pair<iterator, bool> insert_or_assign(
+      F14HashToken const& token, key_type&& key, M&& obj) {
+    auto rv = try_emplace_token(token, std::move(key), std::forward<M>(obj));
+    if (!rv.second) {
+      rv.first->second = std::forward<M>(obj);
+    }
+    return rv;
+  }
+
+  template <typename M>
+  std::pair<iterator, bool> insert_or_assign(
+      F14HashedKey<key_type, hasher>&& hashedKey, M&& obj) {
+    return insert_or_assign(
+        hashedKey.getHashToken(),
+        std::move(hashedKey.getKey()),
+        std::forward<M>(obj));
+  }
+
+  template <typename M>
+  iterator insert_or_assign(
+      const_iterator /*hint*/, key_type const& key, M&& obj) {
+    return insert_or_assign(key, std::forward<M>(obj)).first;
+  }
+
+  template <typename M>
+  iterator insert_or_assign(const_iterator /*hint*/, key_type&& key, M&& obj) {
+    return insert_or_assign(std::move(key), std::forward<M>(obj)).first;
+  }
+
+  template <typename K, typename M>
+  EnableHeterogeneousInsert<K, std::pair<iterator, bool>> insert_or_assign(
+      K&& key, M&& obj) {
+    auto rv = try_emplace(std::forward<K>(key), std::forward<M>(obj));
+    if (!rv.second) {
+      rv.first->second = std::forward<M>(obj);
+    }
+    return rv;
+  }
+
+  template <typename K, typename M>
+  EnableHeterogeneousInsert<K, std::pair<iterator, bool>> insert_or_assign(
+      F14HashToken const& token, K&& key, M&& obj) {
+    auto rv = try_emplace(token, std::forward<K>(key), std::forward<M>(obj));
+    if (!rv.second) {
+      rv.first->second = std::forward<M>(obj);
+    }
+    return rv;
+  }
+
+ private:
+  template <typename Arg>
+  using UsableAsKey = ::folly::detail::
+      EligibleForHeterogeneousFind<key_type, hasher, key_equal, Arg>;
+
+ public:
+  /**
+   * Add an element by constructing it in-place.
+   * @overloadbrief Add elements in-place.
+   * @methodset Modifiers
+   */
+  template <typename... Args>
+  std::pair<iterator, bool> emplace(Args&&... args) {
+    auto rv =
+        folly::detail::callWithExtractedKey<key_type, mapped_type, UsableAsKey>(
+            table_.alloc(),
+            [&](auto&&... inner) {
+              return table_.tryEmplaceValue(
+                  std::forward<decltype(inner)>(inner)...);
+            },
+            std::forward<Args>(args)...);
+    return std::make_pair(table_.makeIter(rv.first), rv.second);
+  }
+
+  /**
+   * Add an element by constructing it in-place.
+   * @methodset Modifiers
+   *
+   * Does nothing if the key already exists.
+   */
+  template <typename... Args>
+  std::pair<iterator, bool> try_emplace(key_type const& key, Args&&... args) {
+    auto rv = table_.tryEmplaceValue(
+        key,
+        std::piecewise_construct,
+        std::forward_as_tuple(key),
+        std::forward_as_tuple(std::forward<Args>(args)...));
+    return std::make_pair(table_.makeIter(rv.first), rv.second);
+  }
+
+  template <typename... Args>
+  std::pair<iterator, bool> try_emplace(key_type&& key, Args&&... args) {
+    auto rv = table_.tryEmplaceValue(
+        key,
+        std::piecewise_construct,
+        std::forward_as_tuple(std::move(key)),
+        std::forward_as_tuple(std::forward<Args>(args)...));
+    return std::make_pair(table_.makeIter(rv.first), rv.second);
+  }
+
+  /// @copydoc try_emplace
+  template <typename... Args>
+  std::pair<iterator, bool> try_emplace_token(
+      F14HashToken const& token, key_type const& key, Args&&... args) {
+    auto rv = table_.tryEmplaceValueWithToken(
+        token,
+        key,
+        std::piecewise_construct,
+        std::forward_as_tuple(key),
+        std::forward_as_tuple(std::forward<Args>(args)...));
+    return std::make_pair(table_.makeIter(rv.first), rv.second);
+  }
+
+  template <typename... Args>
+  std::pair<iterator, bool> try_emplace_token(
+      const F14HashedKey<key_type, hasher>& hashedKey, Args&&... args) {
+    return try_emplace_token(
+        hashedKey.getHashToken(),
+        hashedKey.getKey(),
+        std::forward<Args>(args)...);
+  }
+
+  template <typename... Args>
+  std::pair<iterator, bool> try_emplace_token(
+      F14HashToken const& token, key_type&& key, Args&&... args) {
+    auto rv = table_.tryEmplaceValueWithToken(
+        token,
+        key,
+        std::piecewise_construct,
+        std::forward_as_tuple(std::move(key)),
+        std::forward_as_tuple(std::forward<Args>(args)...));
+    return std::make_pair(table_.makeIter(rv.first), rv.second);
+  }
+
+  template <typename... Args>
+  std::pair<iterator, bool> try_emplace_token(
+      F14HashedKey<key_type, hasher>&& hashedKey, Args&&... args) {
+    return try_emplace_token(
+        hashedKey.getHashToken(),
+        std::move(hashedKey.getKey()),
+        std::forward<Args>(args)...);
+  }
+
+  template <typename... Args>
+  iterator try_emplace(
+      const_iterator /*hint*/, key_type const& key, Args&&... args) {
+    auto rv = table_.tryEmplaceValue(
+        key,
+        std::piecewise_construct,
+        std::forward_as_tuple(key),
+        std::forward_as_tuple(std::forward<Args>(args)...));
+    return table_.makeIter(rv.first);
+  }
+
+  template <typename... Args>
+  iterator try_emplace(
+      const_iterator /*hint*/, key_type&& key, Args&&... args) {
+    auto rv = table_.tryEmplaceValue(
+        key,
+        std::piecewise_construct,
+        std::forward_as_tuple(std::move(key)),
+        std::forward_as_tuple(std::forward<Args>(args)...));
+    return table_.makeIter(rv.first);
+  }
+
+  template <typename K, typename... Args>
+  EnableHeterogeneousInsert<K, std::pair<iterator, bool>> try_emplace(
+      K&& key, Args&&... args) {
+    auto rv = table_.tryEmplaceValue(
+        key,
+        std::piecewise_construct,
+        std::forward_as_tuple(std::forward<K>(key)),
+        std::forward_as_tuple(std::forward<Args>(args)...));
+    return std::make_pair(table_.makeIter(rv.first), rv.second);
+  }
+
+  template <typename K, typename... Args>
+  EnableHeterogeneousInsert<K, std::pair<iterator, bool>> try_emplace_token(
+      F14HashToken const& token, K&& key, Args&&... args) {
+    auto rv = table_.tryEmplaceValueWithToken(
+        token,
+        key,
+        std::piecewise_construct,
+        std::forward_as_tuple(std::forward<K>(key)),
+        std::forward_as_tuple(std::forward<Args>(args)...));
+    return std::make_pair(table_.makeIter(rv.first), rv.second);
+  }
+
+  /**
+   * Remove element at a specific position (iterator).
+   * @overloadbrief Remove elements.
+   * @methodset Modifiers
+   */
+  FOLLY_ALWAYS_INLINE iterator erase(const_iterator pos) {
+    return eraseInto(pos, variadic_noop);
+  }
+
+  /**
+   * Remove element at a specific position (iterator).
+   *
+   * This form avoids ambiguity when key_type has a templated constructor
+   * that accepts const_iterator
+   */
+  FOLLY_ALWAYS_INLINE iterator erase(iterator pos) {
+    return eraseInto(pos, variadic_noop);
+  }
+
+  /// Remove a range of elements.
+  iterator erase(const_iterator first, const_iterator last) {
+    return eraseInto(first, last, variadic_noop);
+  }
+
+  /// Remove a specific key.
+  size_type erase(key_type const& key) { return eraseInto(key, variadic_noop); }
+
+  /// Remove a key, using a heterogeneous representation.
+  template <typename K>
+  EnableHeterogeneousErase<K, size_type> erase(K const& key) {
+    return eraseInto(key, variadic_noop);
+  }
+
+ protected:
+  template <typename BeforeDestroy>
+  FOLLY_ALWAYS_INLINE void tableEraseIterInto(
+      ItemIter pos, BeforeDestroy&& beforeDestroy) {
+    table_.eraseIterInto(pos, [&](value_type&& v) {
+      auto p = Policy::moveValue(v);
+      beforeDestroy(std::move(p.first), std::move(p.second));
+    });
+  }
+
+  template <typename K, typename BeforeDestroy>
+  FOLLY_ALWAYS_INLINE std::size_t tableEraseKeyInto(
+      K const& key, BeforeDestroy&& beforeDestroy) {
+    return table_.eraseKeyInto(key, [&](value_type&& v) {
+      auto p = Policy::moveValue(v);
+      beforeDestroy(std::move(p.first), std::move(p.second));
+    });
+  }
+
+ public:
+  /**
+   * Callback-erase a single iterator.
+   * @overloadbrief Erase with pre-destruction callback.
+   * @methodset Modifiers
+   *
+   * eraseInto contains the same overloads as erase but provides
+   * an additional callback argument which is called with an rvalue
+   * reference (not const) to the key and an rvalue reference to the
+   * mapped value directly before it is destroyed. This can be used
+   * to extract an entry out of a F14Map while avoiding a copy.
+   */
+  template <typename BeforeDestroy>
+  FOLLY_ALWAYS_INLINE iterator
+  eraseInto(const_iterator pos, BeforeDestroy&& beforeDestroy) {
+    // If we are inlined then gcc and clang can optimize away all of the
+    // work of itemPos.advance() if our return value is discarded.
+    auto itemPos = table_.unwrapIter(pos);
+    tableEraseIterInto(itemPos, beforeDestroy);
+    itemPos.advanceLikelyDead();
+    return table_.makeIter(itemPos);
+  }
+
+  /// This form avoids ambiguity when key_type has a templated constructor
+  /// that accepts const_iterator
+  template <typename BeforeDestroy>
+  FOLLY_ALWAYS_INLINE iterator
+  eraseInto(iterator pos, BeforeDestroy&& beforeDestroy) {
+    const_iterator cpos{pos};
+    return eraseInto(cpos, beforeDestroy);
+  }
+
+  /// Callback-erase a range of values.
+  template <typename BeforeDestroy>
+  iterator eraseInto(
+      const_iterator first,
+      const_iterator last,
+      BeforeDestroy&& beforeDestroy) {
+    auto itemFirst = table_.unwrapIter(first);
+    auto itemLast = table_.unwrapIter(last);
+    while (itemFirst != itemLast) {
+      tableEraseIterInto(itemFirst, beforeDestroy);
+      itemFirst.advance();
+    }
+    return table_.makeIter(itemFirst);
+  }
+
+  template <typename BeforeDestroy>
+  size_type eraseInto(key_type const& key, BeforeDestroy&& beforeDestroy) {
+    return tableEraseKeyInto(key, beforeDestroy);
+  }
+
+  /// Callback-erase a specific key, using a heterogeneous representation.
+  template <typename K, typename BeforeDestroy>
+  EnableHeterogeneousErase<K, size_type> eraseInto(
+      K const& key, BeforeDestroy&& beforeDestroy) {
+    return tableEraseKeyInto(key, beforeDestroy);
+  }
+
+  //// PUBLIC - Lookup
+
+  /// Get a value for a key
+  /// @methodset Element Access
+  FOLLY_ALWAYS_INLINE mapped_type& at(key_type const& key) {
+    return at(*this, key);
+  }
+
+  FOLLY_ALWAYS_INLINE mapped_type const& at(key_type const& key) const {
+    return at(*this, key);
+  }
+
+  template <typename K>
+  EnableHeterogeneousFind<K, mapped_type&> at(K const& key) {
+    return at(*this, key);
+  }
+
+  template <typename K>
+  EnableHeterogeneousFind<K, mapped_type const&> at(K const& key) const {
+    return at(*this, key);
+  }
+
+  /// Get a value for a key; create the value if it doesn't already exist
+  /// @methodset Element Access
+  mapped_type& operator[](key_type const& key) {
+    return try_emplace(key).first->second;
+  }
+
+  mapped_type& operator[](key_type&& key) {
+    return try_emplace(std::move(key)).first->second;
+  }
+
+  template <typename K>
+  EnableHeterogeneousInsert<K, mapped_type&> operator[](K&& key) {
+    return try_emplace(std::forward<K>(key)).first->second;
+  }
+
+  /// @overloadbrief Number of elements matching the given key.
+  /// @methodset Lookup
+  FOLLY_ALWAYS_INLINE size_type count(key_type const& key) const {
+    return contains(key) ? 1 : 0;
+  }
+
+  template <typename K>
+  FOLLY_ALWAYS_INLINE EnableHeterogeneousFind<K, size_type> count(
+      K const& key) const {
+    return contains(key) ? 1 : 0;
+  }
+
+  /**
+   * @overloadbrief Prehash a key.
+   * @methodset Lookup
+   *
+   * prehash(key) does the work of evaluating hash_function()(key)
+   * (including additional bit-mixing for non-avalanching hash functions),
+   * and wraps the result of that work in a token for later reuse.
+   *
+   * The returned token may be used at any time, may be used more than
+   * once, and may be used in other F14 sets and maps.  Tokens are
+   * transferrable between any F14 containers (maps and sets) with the
+   * same key_type and equal hash_function()s.
+   *
+   * Hash tokens are not hints -- it is a bug to call any method on this
+   * class with a token t and key k where t isn't the result of a call
+   * to prehash(k2) with k2 == k.
+   */
+  F14HashToken prehash(key_type const& key) const {
+    return table_.prehash(key);
+  }
+  /// @copydoc prehash
+  F14HashToken prehash(key_type const& key, std::size_t hash) const {
+    return table_.prehash(key, hash);
+  }
+
+  /// @copydoc prehash
+  template <typename K>
+  EnableHeterogeneousFind<K, F14HashToken> prehash(K const& key) const {
+    return table_.prehash(key);
+  }
+  /// @copydoc prehash
+  template <typename K>
+  EnableHeterogeneousFind<K, F14HashToken> prehash(
+      K const& key, std::size_t hash) const {
+    return table_.prehash(key, hash);
+  }
+
+  /**
+   * @overloadbrief Prefetch cachelines associated with a key.
+   * @methodset Lookup
+   *
+   * prefetch(token) begins prefetching the first steps of looking for key into
+   * the local CPU cache.
+   *
+   * Example Scenario: Loading 2 values from a cold map.
+   * You have a map that is cold, meaning it is out of the local CPU cache,
+   * and you want to load two values from the map. This can be extended to
+   * load N values, but we're loading 2 for simplicity.
+   *
+   * When the map is cold the dominating factor in the latency is loading the
+   * cache line of the entry into the local CPU cache. Using prehash() will
+   * issue these cache line fetches in parallel.  That means that by the time we
+   * finish map.find(token1, key1) the cache lines needed by map.find(token2,
+   * key2) may already be in the local CPU cache. In the best case this will
+   * half the latency.
+   *
+   * It is always okay to call prefetch() before a find() or other lookup
+   * operation, as it only prefetches cache lines that are guaranteed to be
+   * needed by the lookup.
+   *
+   *   std::pair<iterator, iterator> find2(
+   *       auto& map, key_type const& key1, key_type const& key2) {
+   *     auto const token1 = map.prehash(key1);
+   *     map.prefetch(token1);
+   *     auto const token2 = map.prehash(key2);
+   *     map.prefetch(token2);
+   *     return std::make_pair(map.find(token1, key1), map.find(token2, key2));
+   *   }
+   */
+  void prefetch(F14HashToken const& token) const { table_.prefetch(token); }
+
+  /// @overloadbrief Get the iterator for a key.
+  /// @methodset Lookup
+  FOLLY_ALWAYS_INLINE iterator find(key_type const& key) {
+    return table_.makeIter(table_.find(key));
+  }
+
+  /// Get the iterator for a key.
+  FOLLY_ALWAYS_INLINE const_iterator find(key_type const& key) const {
+    return table_.makeConstIter(table_.find(key));
+  }
+
+  FOLLY_ALWAYS_INLINE iterator
+  find(F14HashToken const& token, key_type const& key) {
+    return table_.makeIter(table_.find(token, key));
+  }
+
+  FOLLY_ALWAYS_INLINE iterator
+  find(const F14HashedKey<key_type, hasher>& hashedKey) {
+    return table_.makeIter(
+        table_.find(hashedKey.getHashToken(), hashedKey.getKey()));
+  }
+
+  FOLLY_ALWAYS_INLINE const_iterator
+  find(F14HashToken const& token, key_type const& key) const {
+    return table_.makeConstIter(table_.find(token, key));
+  }
+
+  FOLLY_ALWAYS_INLINE const_iterator
+  find(F14HashedKey<key_type, hasher> const& hashedKey) const {
+    return table_.makeIter(
+        table_.find(hashedKey.getHashToken(), hashedKey.getKey()));
+  }
+
+  template <typename K>
+  FOLLY_ALWAYS_INLINE EnableHeterogeneousFind<K, iterator> find(K const& key) {
+    return table_.makeIter(table_.find(key));
+  }
+
+  template <typename K>
+  FOLLY_ALWAYS_INLINE EnableHeterogeneousFind<K, const_iterator> find(
+      K const& key) const {
+    return table_.makeConstIter(table_.find(key));
+  }
+
+  template <typename K>
+  FOLLY_ALWAYS_INLINE EnableHeterogeneousFind<K, iterator> find(
+      F14HashToken const& token, K const& key) {
+    return table_.makeIter(table_.find(token, key));
+  }
+
+  template <typename K>
+  FOLLY_ALWAYS_INLINE EnableHeterogeneousFind<K, const_iterator> find(
+      F14HashToken const& token, K const& key) const {
+    return table_.makeConstIter(table_.find(token, key));
+  }
+
+  /**
+   * @overloadbrief Checks if the container contains an element with the
+   * specific key.
+   * @methodset Lookup
+   */
+  FOLLY_ALWAYS_INLINE bool contains(key_type const& key) const {
+    return !table_.find(key).atEnd();
+  }
+
+  template <typename K>
+  FOLLY_ALWAYS_INLINE EnableHeterogeneousFind<K, bool> contains(
+      K const& key) const {
+    return !table_.find(key).atEnd();
+  }
+
+  FOLLY_ALWAYS_INLINE bool contains(
+      F14HashToken const& token, key_type const& key) const {
+    return !table_.find(token, key).atEnd();
+  }
+
+  FOLLY_ALWAYS_INLINE bool contains(
+      const F14HashedKey<key_type, hasher>& hashedKey) const {
+    return !table_.find(hashedKey.getHashToken(), hashedKey.getKey()).atEnd();
+  }
+
+  template <typename K>
+  FOLLY_ALWAYS_INLINE EnableHeterogeneousFind<K, bool> contains(
+      F14HashToken const& token, K const& key) const {
+    return !table_.find(token, key).atEnd();
+  }
+
+  /// @overloadbrief Returns the range of elements matching a specific key.
+  /// @methodset Lookup
+  std::pair<iterator, iterator> equal_range(key_type const& key) {
+    return equal_range(*this, key);
+  }
+
+  std::pair<const_iterator, const_iterator> equal_range(
+      key_type const& key) const {
+    return equal_range(*this, key);
+  }
+
+  template <typename K>
+  EnableHeterogeneousFind<K, std::pair<iterator, iterator>> equal_range(
+      K const& key) {
+    return equal_range(*this, key);
+  }
+
+  template <typename K>
+  EnableHeterogeneousFind<K, std::pair<const_iterator, const_iterator>>
+  equal_range(K const& key) const {
+    return equal_range(*this, key);
+  }
+
+  //// PUBLIC - Bucket interface
+
+  /// The number of buckets in this container.
+  /// @methodset Bucket interface
+  std::size_t bucket_count() const noexcept { return table_.bucket_count(); }
+
+  /// The maximum number of buckets for this container.
+  /// @methodset Bucket interface
+  std::size_t max_bucket_count() const noexcept {
+    return table_.max_bucket_count();
+  }
+
+  //// PUBLIC - Hash policy
+
+  /// Load factor of the underlying hashtable.
+  /// @methodset Hash policy
+  float load_factor() const noexcept { return table_.load_factor(); }
+
+  /**
+   * @overloadbrief Load factor control.
+   * Get the maximum load factor for this container.
+   * @methodset Hash policy
+   */
+  float max_load_factor() const noexcept { return table_.max_load_factor(); }
+
+  /// Set the maximum load factor for this container.
+  /// @methodset Hash policy
+  void max_load_factor(float v) { table_.max_load_factor(v); }
+
+  /**
+   * Rehash this container.
+   * @methodset Hash policy
+   *
+   * This function is provided for compliance with C++'s requirements for
+   * hashtables, but is no better than a simple `reserve` call for F14.
+   *
+   * @param bucketCapcity  The desired capacity across all buckets.
+   */
+  void rehash(std::size_t bucketCapacity) {
+    // The standard's rehash() requires understanding the max load factor,
+    // which is easy to get wrong.  Since we don't actually allow adjustment
+    // of max_load_factor there is no difference.
+    reserve(bucketCapacity);
+  }
+
+  /**
+   * Pre-allocate space for at least this many elements.
+   * @methodset Capacity
+   *
+   * @param capacity  The number of elements to pre-allocate space for.
+   */
+  void reserve(std::size_t capacity) { table_.reserve(capacity); }
+
+  //// PUBLIC - Observers
+
+  /// Get the hasher.
+  /// @methodset Observers
+  hasher hash_function() const { return table_.hasher(); }
+
+  /// Get the key_equal.
+  /// @methodset Observers
+  key_equal key_eq() const { return table_.keyEqual(); }
+
+  //// PUBLIC - F14 Extensions
+
+  /**
+   * Checks for a value using operator==
+   * @methodset Lookup
+   *
+   * containsEqualValue returns true iff there is an element in the map
+   * that compares equal to value using operator==.  It is undefined
+   * behavior to call this function if operator== on key_type can ever
+   * return true when the same keys passed to key_eq() would return false
+   * (the opposite is allowed).
+   */
+  bool containsEqualValue(value_type const& value) const {
+    auto it = table_.findMatching(
+        value.first, [&](auto& key) { return value.first == key; });
+    return !it.atEnd() && value.second == table_.valueAtItem(it.citem()).second;
+  }
+
+  /// Get memory footprint, not including sizeof(*this).
+  /// @methodset Capacity
+  std::size_t getAllocatedMemorySize() const {
+    return table_.getAllocatedMemorySize();
+  }
+
+  /**
+   * In-depth memory analysis.
+   * @methodset Capacity
+   *
+   * Enumerates classes of allocated memory blocks currently owned
+   * by this table, calling visitor(allocationSize, allocationCount).
+   * This can be used to get a more accurate indication of memory footprint
+   * than getAllocatedMemorySize() if you have some way of computing the
+   * internal fragmentation of the allocator, such as JEMalloc's nallocx.
+   * The visitor might be called twice with the same allocationSize. The
+   * visitor's computation should produce the same result for visitor(8,
+   * 2) as for two calls to visitor(8, 1), for example.  The visitor may
+   * be called with a zero allocationCount.
+   */
+  template <typename V>
+  void visitAllocationClasses(V&& visitor) const {
+    return table_.visitAllocationClasses(visitor);
+  }
+
+  /**
+   * Visit contiguous ranges of elements.
+   * @methodset Iterators
+   *
+   * Calls visitor with two value_type const*, b and e, such that every
+   * entry in the table is included in exactly one of the ranges [b,e).
+   * This can be used to efficiently iterate elements in bulk when crossing
+   * an API boundary that supports contiguous blocks of items.
+   */
+  template <typename V>
+  void visitContiguousRanges(V&& visitor) const;
+
+  /// Get stats.
+  /// @methodset Hash policy
+  F14TableStats computeStats() const noexcept { return table_.computeStats(); }
+
+ private:
+  template <typename Self, typename K>
+  FOLLY_ALWAYS_INLINE static auto& at(Self& self, K const& key) {
+    auto iter = self.find(key);
+    if (iter == self.end()) {
+      throw_exception<std::out_of_range>("at() did not find key");
+    }
+    return iter->second;
+  }
+
+  template <typename Self, typename K>
+  static auto equal_range(Self& self, K const& key) {
+    auto first = self.find(key);
+    auto last = first;
+    if (last != self.end()) {
+      ++last;
+    }
+    return std::make_pair(first, last);
+  }
+
+ protected:
+  F14Table<Policy> table_;
+};
+} // namespace detail
+} // namespace f14
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher,
+    typename KeyEqual,
+    typename Alloc>
+class F14ValueMap
+    : public f14::detail::F14BasicMap<f14::detail::MapPolicyWithDefaults<
+          f14::detail::ValueContainerPolicy,
+          Key,
+          Mapped,
+          Hasher,
+          KeyEqual,
+          Alloc>> {
+ protected:
+  using Policy = f14::detail::MapPolicyWithDefaults<
+      f14::detail::ValueContainerPolicy,
+      Key,
+      Mapped,
+      Hasher,
+      KeyEqual,
+      Alloc>;
+
+ private:
+  using Super = f14::detail::F14BasicMap<Policy>;
+
+ public:
+  using typename Super::value_type;
+
+  F14ValueMap() = default;
+
+  using Super::Super;
+
+  F14ValueMap& operator=(std::initializer_list<value_type> ilist) {
+    Super::operator=(ilist);
+    return *this;
+  }
+
+  /// Swaps contained objects with another F14Map
+  /// @methodset Modifiers
+  void swap(F14ValueMap& rhs) noexcept(Policy::kSwapIsNoexcept) {
+    this->table_.swap(rhs.table_);
+  }
+
+  /**
+   * Visit contiguous ranges of elements.
+   * @methodset Iterators
+   *
+   * Calls visitor with two value_type const*, b and e, such that every
+   * entry in the table is included in exactly one of the ranges [b,e).
+   * This can be used to efficiently iterate elements in bulk when crossing
+   * an API boundary that supports contiguous blocks of items.
+   */
+  template <typename V>
+  void visitContiguousRanges(V&& visitor) const {
+    this->table_.visitContiguousItemRanges(visitor);
+  }
+};
+#endif // FOLLY_F14_VECTOR_INTRINSICS_AVAILABLE
+
+template <
+    typename InputIt,
+    typename Hasher = f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+    typename KeyEqual = f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+    typename Alloc = f14::DefaultAlloc<iterator_value_type_t<InputIt>>,
+    typename = detail::RequireInputIterator<InputIt>,
+    // Next two constraints are necessary to disambiguate from next constructor
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireNotAllocator<KeyEqual>,
+    typename = detail::RequireAllocator<Alloc>>
+F14ValueMap(
+    InputIt, InputIt, std::size_t = {}, Hasher = {}, KeyEqual = {}, Alloc = {})
+    -> F14ValueMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        KeyEqual,
+        Alloc>;
+
+template <
+    typename InputIt,
+    typename Alloc,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireAllocator<Alloc>>
+F14ValueMap(InputIt, InputIt, std::size_t, Alloc)
+    -> F14ValueMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
+
+template <
+    typename InputIt,
+    typename Hasher,
+    typename Alloc,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireAllocator<Alloc>>
+F14ValueMap(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14ValueMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher = f14::DefaultHasher<Key>,
+    typename KeyEqual = f14::DefaultKeyEqual<Key>,
+    typename Alloc = f14::DefaultAlloc<std::pair<const Key, Mapped>>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireNotAllocator<KeyEqual>,
+    typename = detail::RequireAllocator<Alloc>>
+F14ValueMap(
+    std::initializer_list<std::pair<Key, Mapped>>,
+    std::size_t = {},
+    Hasher = {},
+    KeyEqual = {},
+    Alloc = {}) -> F14ValueMap<Key, Mapped, Hasher, KeyEqual, Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Alloc,
+    typename = detail::RequireAllocator<Alloc>>
+F14ValueMap(std::initializer_list<std::pair<Key, Mapped>>, std::size_t, Alloc)
+    -> F14ValueMap<
+        Key,
+        Mapped,
+        f14::DefaultHasher<Key>,
+        f14::DefaultKeyEqual<Key>,
+        Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher,
+    typename Alloc,
+    typename = detail::RequireAllocator<Alloc>>
+F14ValueMap(
+    std::initializer_list<std::pair<Key, Mapped>>, std::size_t, Hasher, Alloc)
+    -> F14ValueMap<Key, Mapped, Hasher, f14::DefaultKeyEqual<Key>, Alloc>;
+
+#if FOLLY_F14_VECTOR_INTRINSICS_AVAILABLE
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher,
+    typename KeyEqual,
+    typename Alloc>
+class F14NodeMap
+    : public f14::detail::F14BasicMap<f14::detail::MapPolicyWithDefaults<
+          f14::detail::NodeContainerPolicy,
+          Key,
+          Mapped,
+          Hasher,
+          KeyEqual,
+          Alloc>> {
+ protected:
+  using Policy = f14::detail::MapPolicyWithDefaults<
+      f14::detail::NodeContainerPolicy,
+      Key,
+      Mapped,
+      Hasher,
+      KeyEqual,
+      Alloc>;
+
+ private:
+  using Super = f14::detail::F14BasicMap<Policy>;
+
+ public:
+  using typename Super::value_type;
+
+  F14NodeMap() = default;
+
+  using Super::Super;
+
+  F14NodeMap& operator=(std::initializer_list<value_type> ilist) {
+    Super::operator=(ilist);
+    return *this;
+  }
+
+  /// @methodset Modifiers
+  void swap(F14NodeMap& rhs) noexcept(Policy::kSwapIsNoexcept) {
+    this->table_.swap(rhs.table_);
+  }
+
+  /**
+   * Visit contiguous ranges of elements.
+   * @methodset Iterators
+   *
+   * Calls visitor with two value_type const*, b and e, such that every
+   * entry in the table is included in exactly one of the ranges [b,e).
+   * This can be used to efficiently iterate elements in bulk when crossing
+   * an API boundary that supports contiguous blocks of items.
+   */
+  template <typename V>
+  void visitContiguousRanges(V&& visitor) const {
+    this->table_.visitItems([&](typename Policy::Item ptr) {
+      value_type const* b = std::addressof(*ptr);
+      visitor(b, b + 1);
+    });
+  }
+
+  // TODO extract and node_handle insert
+};
+#endif // FOLLY_F14_VECTOR_INTRINSICS_AVAILABLE
+
+template <
+    typename InputIt,
+    typename Hasher = f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+    typename KeyEqual = f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+    typename Alloc = f14::DefaultAlloc<iterator_value_type_t<InputIt>>,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireNotAllocator<KeyEqual>,
+    typename = detail::RequireAllocator<Alloc>>
+F14NodeMap(
+    InputIt, InputIt, std::size_t = {}, Hasher = {}, KeyEqual = {}, Alloc = {})
+    -> F14NodeMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        KeyEqual,
+        Alloc>;
+
+template <
+    typename InputIt,
+    typename Alloc,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireAllocator<Alloc>>
+F14NodeMap(InputIt, InputIt, std::size_t, Alloc)
+    -> F14NodeMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
+
+template <
+    typename InputIt,
+    typename Hasher,
+    typename Alloc,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireAllocator<Alloc>>
+F14NodeMap(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14NodeMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher = f14::DefaultHasher<Key>,
+    typename KeyEqual = f14::DefaultKeyEqual<Key>,
+    typename Alloc = f14::DefaultAlloc<std::pair<const Key, Mapped>>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireNotAllocator<KeyEqual>,
+    typename = detail::RequireAllocator<Alloc>>
+F14NodeMap(
+    std::initializer_list<std::pair<Key, Mapped>>,
+    std::size_t = {},
+    Hasher = {},
+    KeyEqual = {},
+    Alloc = {}) -> F14NodeMap<Key, Mapped, Hasher, KeyEqual, Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Alloc,
+    typename = detail::RequireAllocator<Alloc>>
+F14NodeMap(std::initializer_list<std::pair<Key, Mapped>>, std::size_t, Alloc)
+    -> F14NodeMap<
+        Key,
+        Mapped,
+        f14::DefaultHasher<Key>,
+        f14::DefaultKeyEqual<Key>,
+        Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher,
+    typename Alloc,
+    typename = detail::RequireAllocator<Alloc>>
+F14NodeMap(
+    std::initializer_list<std::pair<Key, Mapped>>, std::size_t, Hasher, Alloc)
+    -> F14NodeMap<Key, Mapped, Hasher, f14::DefaultKeyEqual<Key>, Alloc>;
+
+#if FOLLY_F14_VECTOR_INTRINSICS_AVAILABLE
+namespace f14 {
+namespace detail {
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher,
+    typename KeyEqual,
+    typename Alloc,
+    typename EligibleForPerturbedInsertionOrder>
+class F14VectorMapImpl : public F14BasicMap<MapPolicyWithDefaults<
+                             VectorContainerPolicy,
+                             Key,
+                             Mapped,
+                             Hasher,
+                             KeyEqual,
+                             Alloc,
+                             EligibleForPerturbedInsertionOrder>> {
+ protected:
+  using Policy = MapPolicyWithDefaults<
+      VectorContainerPolicy,
+      Key,
+      Mapped,
+      Hasher,
+      KeyEqual,
+      Alloc,
+      EligibleForPerturbedInsertionOrder>;
+
+ private:
+  using Super = F14BasicMap<Policy>;
+
+  template <typename K>
+  using IsIter = Disjunction<
+      std::is_same<typename Policy::Iter, remove_cvref_t<K>>,
+      std::is_same<typename Policy::ConstIter, remove_cvref_t<K>>,
+      std::is_same<typename Policy::ReverseIter, remove_cvref_t<K>>,
+      std::is_same<typename Policy::ConstReverseIter, remove_cvref_t<K>>>;
+
+  template <typename K, typename T>
+  using EnableHeterogeneousVectorErase = std::enable_if_t<
+      ::folly::detail::EligibleForHeterogeneousFind<
+          Key,
+          Hasher,
+          KeyEqual,
+          std::conditional_t<IsIter<K>::value, Key, K>>::value &&
+          !IsIter<K>::value,
+      T>;
+
+ public:
+  using typename Super::const_iterator;
+  using typename Super::iterator;
+  using typename Super::key_type;
+  using typename Super::mapped_type;
+  using typename Super::value_type;
+
+  F14VectorMapImpl() = default;
+
+  // inherit constructors
+  using Super::Super;
+
+  F14VectorMapImpl& operator=(std::initializer_list<value_type> ilist) {
+    Super::operator=(ilist);
+    return *this;
+  }
+
+  /// @methodset Iterators
+  iterator begin() { return this->table_.linearBegin(this->size()); }
+  /// @methodset Iterators
+  const_iterator begin() const { return cbegin(); }
+  /// @methodset Iterators
+  const_iterator cbegin() const {
+    return this->table_.linearBegin(this->size());
+  }
+
+  /// @methodset Iterators
+  iterator end() { return this->table_.linearEnd(); }
+  /// @methodset Iterators
+  const_iterator end() const { return cend(); }
+  /// @methodset Iterators
+  const_iterator cend() const { return this->table_.linearEnd(); }
+
+ private:
+  template <typename BeforeDestroy>
+  void eraseUnderlying(
+      typename Policy::ItemIter underlying, BeforeDestroy&& beforeDestroy) {
+    Alloc& a = this->table_.alloc();
+    auto values = this->table_.values_;
+
+    // Remove the ptr from the base table and destroy the value.
+    auto index = underlying.item();
+    // The item still needs to be hashable during this call, so we must destroy
+    // the value _afterwards_.
+    this->tableEraseIterInto(underlying, beforeDestroy);
+    Policy::AllocTraits::destroy(a, std::addressof(values[index]));
+
+    // move the last element in values_ down and fix up the inbound index
+    auto tailIndex = this->size();
+    if (tailIndex != index) {
+      auto tail = this->table_.find(
+          VectorContainerIndexSearch{static_cast<uint32_t>(tailIndex)});
+      tail.item() = index;
+      auto p = std::addressof(values[index]);
+      assume(p != nullptr);
+      this->table_.transfer(a, std::addressof(values[tailIndex]), p, 1);
+    }
+  }
+
+  template <typename K, typename BeforeDestroy>
+  std::size_t eraseUnderlyingKey(K const& key, BeforeDestroy&& beforeDestroy) {
+    auto underlying = this->table_.find(key);
+    if (underlying.atEnd()) {
+      return 0;
+    } else {
+      eraseUnderlying(underlying, beforeDestroy);
+      return 1;
+    }
+  }
+
+ public:
+  /**
+   * Remove element at a specific position (iterator).
+   * @overloadbrief Remove elements.
+   * @methodset Modifiers
+   */
+  FOLLY_ALWAYS_INLINE iterator erase(const_iterator pos) {
+    return eraseInto(pos, variadic_noop);
+  }
+
+  // This form avoids ambiguity when key_type has a templated constructor
+  // that accepts const_iterator
+  FOLLY_ALWAYS_INLINE iterator erase(iterator pos) {
+    return eraseInto(pos, variadic_noop);
+  }
+
+  /// Remove a range of elements.
+  iterator erase(const_iterator first, const_iterator last) {
+    return eraseInto(first, last, variadic_noop);
+  }
+
+  /// Remove a specific key.
+  std::size_t erase(key_type const& key) {
+    return eraseInto(key, variadic_noop);
+  }
+
+  /// Remove a key, using a heterogeneous representation.
+  template <typename K>
+  EnableHeterogeneousVectorErase<K, std::size_t> erase(K const& key) {
+    return eraseInto(key, variadic_noop);
+  }
+
+  /**
+   * Callback-erase a single iterator.
+   * @overloadbrief Erase with pre-destruction callback.
+   * @methodset Modifiers
+   *
+   * Like erase, but with an additional callback argument which is called with
+   * an rvalue reference to the item directly before it is destroyed. This can
+   * be used to extract an item out of a F14Set while avoiding a copy.
+   */
+  template <typename BeforeDestroy>
+  FOLLY_ALWAYS_INLINE iterator
+  eraseInto(const_iterator pos, BeforeDestroy&& beforeDestroy) {
+    auto index = this->table_.iterToIndex(pos);
+    auto underlying = this->table_.find(VectorContainerIndexSearch{index});
+    eraseUnderlying(underlying, beforeDestroy);
+    return index == 0 ? end() : this->table_.indexToIter(index - 1);
+  }
+
+  // This form avoids ambiguity when key_type has a templated constructor
+  // that accepts const_iterator
+  template <typename BeforeDestroy>
+  FOLLY_ALWAYS_INLINE iterator
+  eraseInto(iterator pos, BeforeDestroy&& beforeDestroy) {
+    const_iterator cpos{pos};
+    return eraseInto(cpos, beforeDestroy);
+  }
+
+  /// Callback-erase a range of values.
+  template <typename BeforeDestroy>
+  iterator eraseInto(
+      const_iterator first,
+      const_iterator last,
+      BeforeDestroy&& beforeDestroy) {
+    while (first != last) {
+      first = eraseInto(first, beforeDestroy);
+    }
+    auto index = this->table_.iterToIndex(first);
+    return index == 0 ? end() : this->table_.indexToIter(index - 1);
+  }
+
+  /// Callback-erase a specific key.
+  template <typename BeforeDestroy>
+  std::size_t eraseInto(key_type const& key, BeforeDestroy&& beforeDestroy) {
+    return eraseUnderlyingKey(key, beforeDestroy);
+  }
+
+  /// Callback-erase a specific key, using a heterogeneous representation.
+  template <typename K, typename BeforeDestroy>
+  EnableHeterogeneousVectorErase<K, std::size_t> eraseInto(
+      K const& key, BeforeDestroy&& beforeDestroy) {
+    return eraseUnderlyingKey(key, beforeDestroy);
+  }
+
+  /**
+   * Visit contiguous ranges of elements.
+   * @methodset Iterators
+   *
+   * Calls visitor with two value_type const*, b and e, such that every
+   * entry in the table is included in exactly one of the ranges [b,e).
+   * This can be used to efficiently iterate elements in bulk when crossing
+   * an API boundary that supports contiguous blocks of items.
+   */
+  template <typename V>
+  void visitContiguousRanges(V&& visitor) const {
+    auto n = this->table_.size();
+    if (n > 0) {
+      value_type const* b = std::addressof(this->table_.values_[0]);
+      visitor(b, b + n);
+    }
+  }
+};
+} // namespace detail
+} // namespace f14
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher,
+    typename KeyEqual,
+    typename Alloc>
+class F14VectorMap : public f14::detail::F14VectorMapImpl<
+                         Key,
+                         Mapped,
+                         Hasher,
+                         KeyEqual,
+                         Alloc,
+                         std::false_type> {
+  using Super = f14::detail::
+      F14VectorMapImpl<Key, Mapped, Hasher, KeyEqual, Alloc, std::false_type>;
+
+ public:
+  using typename Super::const_iterator;
+  using typename Super::iterator;
+  using typename Super::value_type;
+  using reverse_iterator = typename Super::Policy::ReverseIter;
+  using const_reverse_iterator = typename Super::Policy::ConstReverseIter;
+
+  F14VectorMap() = default;
+
+  // inherit constructors
+  using Super::Super;
+
+  F14VectorMap& operator=(std::initializer_list<value_type> ilist) {
+    Super::operator=(ilist);
+    return *this;
+  }
+
+  /// @methodset Modifiers
+  void swap(F14VectorMap& rhs) noexcept(Super::Policy::kSwapIsNoexcept) {
+    this->table_.swap(rhs.table_);
+  }
+
+  // ITERATION ORDER
+  //
+  // Deterministic iteration order for insert-only workloads is part of
+  // F14VectorMap's supported API: iterator is LIFO and reverse_iterator
+  // is FIFO.
+  //
+  // If there have been no calls to erase() then iterator and
+  // const_iterator enumerate entries in the opposite of insertion order.
+  // begin()->first is the key most recently inserted.  reverse_iterator
+  // and reverse_const_iterator, therefore, enumerate in LIFO (insertion)
+  // order for insert-only workloads.  Deterministic iteration order is
+  // only guaranteed if no keys were removed since the last time the
+  // map was empty.  Iteration order is preserved across rehashes and
+  // F14VectorMap copies and moves.
+  //
+  // iterator uses LIFO order so that erasing while iterating with begin()
+  // and end() is safe using the erase(it++) idiom, which is supported
+  // by std::map and std::unordered_map.  erase(iter) invalidates iter
+  // and all iterators before iter in the non-reverse iteration order.
+  // Every successful erase invalidates all reverse iterators.
+  //
+  // No erase is provided for reverse_iterator or const_reverse_iterator
+  // to make it harder to shoot yourself in the foot by erasing while
+  // reverse-iterating.  You can write that as map.erase(map.iter(riter))
+  // if you really need it.
+
+  /// @methodset Iterators
+  reverse_iterator rbegin() { return this->table_.values_; }
+  /// @methodset Iterators
+  const_reverse_iterator rbegin() const { return crbegin(); }
+  /// @methodset Iterators
+  const_reverse_iterator crbegin() const { return this->table_.values_; }
+
+  /// @methodset Iterators
+  reverse_iterator rend() { return this->table_.values_ + this->table_.size(); }
+  /// @methodset Iterators
+  const_reverse_iterator rend() const { return crend(); }
+  /// @methodset Iterators
+  const_reverse_iterator crend() const {
+    return this->table_.values_ + this->table_.size();
+  }
+
+  /// Explicit conversions between iterator and reverse_iterator
+  /// @methodset Iterators
+  iterator iter(reverse_iterator riter) { return this->table_.iter(riter); }
+  const_iterator iter(const_reverse_iterator riter) const {
+    return this->table_.iter(riter);
+  }
+
+  /// @copydoc iter
+  reverse_iterator riter(iterator it) { return this->table_.riter(it); }
+  const_reverse_iterator riter(const_iterator it) const {
+    return this->table_.riter(it);
+  }
+
+  friend Range<const_reverse_iterator> tag_invoke(
+      order_preserving_reinsertion_view_fn, F14VectorMap const& c) noexcept {
+    return {c.rbegin(), c.rend()};
+  }
+};
+#endif // FOLLY_F14_VECTOR_INTRINSICS_AVAILABLE
+
+template <
+    typename InputIt,
+    typename Hasher = f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+    typename KeyEqual = f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+    typename Alloc = f14::DefaultAlloc<iterator_value_type_t<InputIt>>,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireNotAllocator<KeyEqual>,
+    typename = detail::RequireAllocator<Alloc>>
+F14VectorMap(
+    InputIt, InputIt, std::size_t = {}, Hasher = {}, KeyEqual = {}, Alloc = {})
+    -> F14VectorMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        KeyEqual,
+        Alloc>;
+
+template <
+    typename InputIt,
+    typename Alloc,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireAllocator<Alloc>>
+F14VectorMap(InputIt, InputIt, std::size_t, Alloc)
+    -> F14VectorMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
+
+template <
+    typename InputIt,
+    typename Hasher,
+    typename Alloc,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireAllocator<Alloc>>
+F14VectorMap(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14VectorMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher = f14::DefaultHasher<Key>,
+    typename KeyEqual = f14::DefaultKeyEqual<Key>,
+    typename Alloc = f14::DefaultAlloc<std::pair<const Key, Mapped>>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireNotAllocator<KeyEqual>,
+    typename = detail::RequireAllocator<Alloc>>
+F14VectorMap(
+    std::initializer_list<std::pair<Key, Mapped>>,
+    std::size_t = {},
+    Hasher = {},
+    KeyEqual = {},
+    Alloc = {}) -> F14VectorMap<Key, Mapped, Hasher, KeyEqual, Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Alloc,
+    typename = detail::RequireAllocator<Alloc>>
+F14VectorMap(std::initializer_list<std::pair<Key, Mapped>>, std::size_t, Alloc)
+    -> F14VectorMap<
+        Key,
+        Mapped,
+        f14::DefaultHasher<Key>,
+        f14::DefaultKeyEqual<Key>,
+        Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher,
+    typename Alloc,
+    typename = detail::RequireAllocator<Alloc>>
+F14VectorMap(
+    std::initializer_list<std::pair<Key, Mapped>>, std::size_t, Hasher, Alloc)
+    -> F14VectorMap<Key, Mapped, Hasher, f14::DefaultKeyEqual<Key>, Alloc>;
+
+#if FOLLY_F14_VECTOR_INTRINSICS_AVAILABLE
+/**
+ * F14FastMap is, under the hood, either an F14ValueMap or an F14VectorMap.
+ * F14FastMap chooses which of these two representations to use based on the
+ * size of a node.
+ */
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher,
+    typename KeyEqual,
+    typename Alloc>
+class F14FastMap : public std::conditional_t<
+                       (sizeof(std::pair<Key const, Mapped>) < 24),
+                       F14ValueMap<Key, Mapped, Hasher, KeyEqual, Alloc>,
+                       f14::detail::F14VectorMapImpl<
+                           Key,
+                           Mapped,
+                           Hasher,
+                           KeyEqual,
+                           Alloc,
+                           std::true_type>> {
+  using Super = std::conditional_t<
+      sizeof(std::pair<Key const, Mapped>) < 24,
+      F14ValueMap<Key, Mapped, Hasher, KeyEqual, Alloc>,
+      f14::detail::F14VectorMapImpl<
+          Key,
+          Mapped,
+          Hasher,
+          KeyEqual,
+          Alloc,
+          std::true_type>>;
+
+ public:
+  using typename Super::value_type;
+
+  F14FastMap() = default;
+
+  using Super::Super;
+
+  F14FastMap& operator=(std::initializer_list<value_type> ilist) {
+    Super::operator=(ilist);
+    return *this;
+  }
+
+  /// @methodset Modifiers
+  void swap(F14FastMap& rhs) noexcept(Super::Policy::kSwapIsNoexcept) {
+    this->table_.swap(rhs.table_);
+  }
+};
+#endif // if FOLLY_F14_VECTOR_INTRINSICS_AVAILABLE
+
+template <
+    typename InputIt,
+    typename Hasher = f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+    typename KeyEqual = f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+    typename Alloc = f14::DefaultAlloc<iterator_value_type_t<InputIt>>,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireNotAllocator<KeyEqual>,
+    typename = detail::RequireAllocator<Alloc>>
+F14FastMap(
+    InputIt, InputIt, std::size_t = {}, Hasher = {}, KeyEqual = {}, Alloc = {})
+    -> F14FastMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        KeyEqual,
+        Alloc>;
+
+template <
+    typename InputIt,
+    typename Alloc,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireAllocator<Alloc>>
+F14FastMap(InputIt, InputIt, std::size_t, Alloc)
+    -> F14FastMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        f14::DefaultHasher<iterator_key_type_t<InputIt>>,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
+
+template <
+    typename InputIt,
+    typename Hasher,
+    typename Alloc,
+    typename = detail::RequireInputIterator<InputIt>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireAllocator<Alloc>>
+F14FastMap(InputIt, InputIt, std::size_t, Hasher, Alloc)
+    -> F14FastMap<
+        iterator_key_type_t<InputIt>,
+        iterator_mapped_type_t<InputIt>,
+        Hasher,
+        f14::DefaultKeyEqual<iterator_key_type_t<InputIt>>,
+        Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher = f14::DefaultHasher<Key>,
+    typename KeyEqual = f14::DefaultKeyEqual<Key>,
+    typename Alloc = f14::DefaultAlloc<std::pair<const Key, Mapped>>,
+    typename = detail::RequireNotAllocator<Hasher>,
+    typename = detail::RequireNotAllocator<KeyEqual>,
+    typename = detail::RequireAllocator<Alloc>>
+F14FastMap(
+    std::initializer_list<std::pair<Key, Mapped>>,
+    std::size_t = {},
+    Hasher = {},
+    KeyEqual = {},
+    Alloc = {}) -> F14FastMap<Key, Mapped, Hasher, KeyEqual, Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Alloc,
+    typename = detail::RequireAllocator<Alloc>>
+F14FastMap(std::initializer_list<std::pair<Key, Mapped>>, std::size_t, Alloc)
+    -> F14FastMap<
+        Key,
+        Mapped,
+        f14::DefaultHasher<Key>,
+        f14::DefaultKeyEqual<Key>,
+        Alloc>;
+
+template <
+    typename Key,
+    typename Mapped,
+    typename Hasher,
+    typename Alloc,
+    typename = detail::RequireAllocator<Alloc>>
+F14FastMap(
+    std::initializer_list<std::pair<Key, Mapped>>, std::size_t, Hasher, Alloc)
+    -> F14FastMap<Key, Mapped, Hasher, f14::DefaultKeyEqual<Key>, Alloc>;
+
+} // namespace folly
+
+namespace folly {
+namespace f14 {
+namespace detail {
+template <typename M>
+bool mapsEqual(M const& lhs, M const& rhs) {
+  if (lhs.size() != rhs.size()) {
+    return false;
+  }
+  for (auto& kv : lhs) {
+    if (!rhs.containsEqualValue(kv)) {
+      return false;
+    }
+  }
+  return true;
+}
+} // namespace detail
+} // namespace f14
+
+template <typename K, typename M, typename H, typename E, typename A>
+bool operator==(
+    F14ValueMap<K, M, H, E, A> const& lhs,
+    F14ValueMap<K, M, H, E, A> const& rhs) {
+  return mapsEqual(lhs, rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+bool operator!=(
+    F14ValueMap<K, M, H, E, A> const& lhs,
+    F14ValueMap<K, M, H, E, A> const& rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+bool operator==(
+    F14NodeMap<K, M, H, E, A> const& lhs,
+    F14NodeMap<K, M, H, E, A> const& rhs) {
+  return mapsEqual(lhs, rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+bool operator!=(
+    F14NodeMap<K, M, H, E, A> const& lhs,
+    F14NodeMap<K, M, H, E, A> const& rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+bool operator==(
+    F14VectorMap<K, M, H, E, A> const& lhs,
+    F14VectorMap<K, M, H, E, A> const& rhs) {
+  return mapsEqual(lhs, rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+bool operator!=(
+    F14VectorMap<K, M, H, E, A> const& lhs,
+    F14VectorMap<K, M, H, E, A> const& rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+bool operator==(
+    F14FastMap<K, M, H, E, A> const& lhs,
+    F14FastMap<K, M, H, E, A> const& rhs) {
+  return mapsEqual(lhs, rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+bool operator!=(
+    F14FastMap<K, M, H, E, A> const& lhs,
+    F14FastMap<K, M, H, E, A> const& rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+void swap(
+    F14ValueMap<K, M, H, E, A>& lhs,
+    F14ValueMap<K, M, H, E, A>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+  lhs.swap(rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+void swap(
+    F14NodeMap<K, M, H, E, A>& lhs,
+    F14NodeMap<K, M, H, E, A>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+  lhs.swap(rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+void swap(
+    F14VectorMap<K, M, H, E, A>& lhs,
+    F14VectorMap<K, M, H, E, A>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+  lhs.swap(rhs);
+}
+
+template <typename K, typename M, typename H, typename E, typename A>
+void swap(
+    F14FastMap<K, M, H, E, A>& lhs,
+    F14FastMap<K, M, H, E, A>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+  lhs.swap(rhs);
+}
+
+template <
+    typename K,
+    typename M,
+    typename H,
+    typename E,
+    typename A,
+    typename Pred>
+std::size_t erase_if(F14ValueMap<K, M, H, E, A>& c, Pred pred) {
+  return f14::detail::erase_if_impl(c, pred);
+}
+
+template <
+    typename K,
+    typename M,
+    typename H,
+    typename E,
+    typename A,
+    typename Pred>
+std::size_t erase_if(F14NodeMap<K, M, H, E, A>& c, Pred pred) {
+  return f14::detail::erase_if_impl(c, pred);
+}
+
+template <
+    typename K,
+    typename M,
+    typename H,
+    typename E,
+    typename A,
+    typename Pred>
+std::size_t erase_if(F14VectorMap<K, M, H, E, A>& c, Pred pred) {
+  return f14::detail::erase_if_impl(c, pred);
+}
+
+template <
+    typename K,
+    typename M,
+    typename H,
+    typename E,
+    typename A,
+    typename Pred>
+std::size_t erase_if(F14FastMap<K, M, H, E, A>& c, Pred pred) {
+  return f14::detail::erase_if_impl(c, pred);
+}
+
+} // namespace folly