diff --git a/include/boost/unordered/concurrent_flat_map.hpp b/include/boost/unordered/concurrent_flat_map.hpp
index ccc028ba..7a2095c5 100644
--- a/include/boost/unordered/concurrent_flat_map.hpp
+++ b/include/boost/unordered/concurrent_flat_map.hpp
@@ -216,6 +216,14 @@ namespace boost {
 
       size_type erase(key_type const& k) { return table_.erase(k); }
 
+      template <class K>
+      typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value, size_type>::type
+      erase(K&& k)
+      {
+        return table_.erase(std::forward<K>(k));
+      }
+
       /// Hash Policy
       ///
       void rehash(size_type n) { table_.rehash(n); }
diff --git a/test/cfoa/erase_tests.cpp b/test/cfoa/erase_tests.cpp
index d673f4d3..80573776 100644
--- a/test/cfoa/erase_tests.cpp
+++ b/test/cfoa/erase_tests.cpp
@@ -49,6 +49,44 @@ namespace {
     }
   } lvalue_eraser;
 
+  struct transp_lvalue_eraser_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_erased{0};
+      auto const old_size = x.size();
+
+      auto const old_dc = +raii::default_constructor;
+      auto const old_cc = +raii::copy_constructor;
+      auto const old_mc = +raii::move_constructor;
+
+      auto const old_d = +raii::destructor;
+
+      BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor +
+                      raii::move_constructor,
+        raii::destructor + 2 * x.size());
+
+      thread_runner(values, [&values, &num_erased, &x](boost::span<T>) {
+        for (auto const& k : values) {
+          auto count = x.erase(k.first.x_);
+          num_erased += count;
+          BOOST_TEST_LE(count, 1u);
+          BOOST_TEST_GE(count, 0u);
+        }
+      });
+
+      BOOST_TEST_EQ(raii::default_constructor, old_dc);
+      BOOST_TEST_EQ(raii::copy_constructor, old_cc);
+      BOOST_TEST_EQ(raii::move_constructor, old_mc);
+
+      BOOST_TEST_EQ(raii::destructor, old_d + 2 * old_size);
+
+      BOOST_TEST_EQ(x.size(), 0u);
+      BOOST_TEST(x.empty());
+      BOOST_TEST_EQ(num_erased, old_size);
+    }
+  } transp_lvalue_eraser;
+
   template <class X, class G, class F>
   void erase(X*, G gen, F eraser, test::random_generator rg)
   {
@@ -86,8 +124,8 @@ namespace {
   }
 
   boost::unordered::concurrent_flat_map<raii, raii>* map;
-  //   boost::unordered::concurrent_flat_map<raii, raii, transparent_hash,
-  //     transparent_key_equal>* transparent_map;
+  boost::unordered::concurrent_flat_map<raii, raii, transp_hash,
+    transp_key_equal>* transparent_map;
 
 } // namespace
 
@@ -103,6 +141,13 @@ UNORDERED_TEST(
   ((lvalue_eraser))
   ((default_generator)(sequential)(limited_range)))
 
+UNORDERED_TEST(
+  erase,
+  ((transparent_map))
+  ((value_type_generator)(init_type_generator))
+  ((lvalue_eraser)(transp_lvalue_eraser))
+  ((default_generator)(sequential)(limited_range)))
+
 // clang-format on
 
 RUN_TESTS()