diff --git a/include/meson.build b/include/meson.build
index 1a1eb6f..8b8b1dd 100644
--- a/include/meson.build
+++ b/include/meson.build
@@ -15,6 +15,7 @@
   'stdplus/signal.hpp',
   'stdplus/str/cat.hpp',
   'stdplus/str/cexpr.hpp',
+  'stdplus/str/maps.hpp',
   'stdplus/util/cexec.hpp',
   'stdplus/util/string.hpp',
   'stdplus/zstring.hpp',
diff --git a/include/stdplus/str/maps.hpp b/include/stdplus/str/maps.hpp
new file mode 100644
index 0000000..bc81875
--- /dev/null
+++ b/include/stdplus/str/maps.hpp
@@ -0,0 +1,23 @@
+#pragma once
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+namespace stdplus
+{
+
+namespace detail
+{
+struct string_hash : public std::hash<std::string_view>
+{
+    using is_transparent = void;
+};
+} // namespace detail
+
+template <typename V>
+using string_umap =
+    std::unordered_map<std::string, V, detail::string_hash, std::equal_to<>>;
+using string_uset =
+    std::unordered_set<std::string, detail::string_hash, std::equal_to<>>;
+
+} // namespace stdplus
diff --git a/src/meson.build b/src/meson.build
index ab786c0..5f5c78b 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -56,6 +56,7 @@
   'signal.cpp',
   'str/cat.cpp',
   'str/cexpr.cpp',
+  'str/maps.cpp',
   'util/cexec.cpp',
   'zstring.cpp',
   'zstring_view.cpp',
diff --git a/src/str/maps.cpp b/src/str/maps.cpp
new file mode 100644
index 0000000..ed8d63f
--- /dev/null
+++ b/src/str/maps.cpp
@@ -0,0 +1 @@
+#include <stdplus/str/maps.hpp>
diff --git a/test/meson.build b/test/meson.build
index 51bc288..c4e8a4d 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -12,6 +12,7 @@
   'signal': [stdplus_dep, gtest_main_dep],
   'str/cat': [stdplus_dep, gtest_main_dep],
   'str/cexpr': [stdplus_dep, gtest_main_dep],
+  'str/maps': [stdplus_dep, gmock_dep, gtest_main_dep],
   'util/cexec': [stdplus_dep, gtest_main_dep],
   'zstring': [stdplus_dep, gtest_main_dep],
   'zstring_view': [stdplus_dep, gtest_main_dep],
diff --git a/test/str/maps.cpp b/test/str/maps.cpp
new file mode 100644
index 0000000..e3ff1d6
--- /dev/null
+++ b/test/str/maps.cpp
@@ -0,0 +1,14 @@
+#include <stdplus/str/maps.hpp>
+
+#include <gtest/gtest.h>
+
+namespace stdplus
+{
+
+TEST(StringMaps, Basic)
+{
+    string_umap<int> a = {{"hi", 2}};
+    EXPECT_EQ(2, a.find(std::string_view("hi"))->second);
+}
+
+} // namespace stdplus
