Fix: Composing STL collections

Author: ashvardanian

include/stringzilla/stringzilla.hpp

@@ -1971,7 +1971,7 @@ class basic_string_slice {
 #pragma endregion
 
     /**  @brief Hashes the string, equivalent to `std::hash<string_view>{}(str)`. */
-    size_type hash(std::uint64_t seed = 42) const noexcept {
+    size_type hash(std::uint64_t seed = 0) const noexcept {
         return static_cast<size_type>(sz_hash(start_, length_, static_cast<sz_u64_t>(seed)));
     }
 
@@ -3759,10 +3759,10 @@ bool basic_string<char_type_, allocator_>::try_preparing_replacement( //
  *  @see Similar to `std::less<std::string_view>`: https://en.cppreference.com/w/cpp/utility/functional/less
  *
  *  Unlike the STL analog, doesn't require C++14 or including the heavy `<functional>` header.
- *  Can be used to combine STL classes with StringZilla logic, like: `std::map<std::string, int, sz::string_view_less>`.
+ *  Can be used to combine STL classes with StringZilla logic, like: `std::map<std::string, int, sz::less>`.
  */
-struct string_view_less {
-    bool operator()(string_view a, string_view b) const noexcept { return a < b; }
+struct less {
+    inline bool operator()(string_view a, string_view b) const noexcept { return a < b; }
 };
 
 /**
@@ -3771,10 +3771,10 @@ struct string_view_less {
  *
  *  Unlike the STL analog, doesn't require C++14 or including the heavy `<functional>` header.
  *  Can be used to combine STL classes with StringZilla logic, like:
- *      `std::unordered_map<std::string, int, sz::string_view_hash, sz::string_view_equal_to>`.
+ *      `std::unordered_map<std::string, int, sz::hash, sz::equal_to>`.
  */
-struct string_view_equal_to {
-    bool operator()(string_view a, string_view b) const noexcept { return a == b; }
+struct equal_to {
+    inline bool operator()(string_view a, string_view b) const noexcept { return a == b; }
 };
 
 /**
@@ -3783,10 +3783,10 @@ struct string_view_equal_to {
  *
  *  Unlike the STL analog, doesn't require C++14 or including the heavy `<functional>` header.
  *  Can be used to combine STL classes with StringZilla logic, like:
- *      `std::unordered_map<std::string, int, sz::string_view_hash, sz::string_view_equal_to>`.
+ *      `std::unordered_map<std::string, int, sz::hash, sz::equal_to>`.
  */
-struct string_view_hash {
-    std::size_t operator()(string_view str) const noexcept { return str.hash(); }
+struct hash {
+    inline std::size_t operator()(string_view str) const noexcept { return str.hash(); }
 };
 
 /**  @brief SFINAE-type used to infer the resulting type of concatenating multiple string together. */

scripts/bench_container.cpp

@@ -51,22 +51,23 @@ void bench_tokens(strings_type const &strings) {
     auto const &s = strings;
 
     // StringZilla structures
-    bench<std::map<sz::string, int>>("map<sz::string>", s);
-    bench<std::map<sz::string_view, int>>("map<sz::string_view>", s);
-    bench<std::unordered_map<sz::string, int>>("unordered_map<sz::string>", s);
-    bench<std::unordered_map<sz::string_view, int>>("unordered_map<sz::string_view>", s);
+    bench<std::map<sz::string, int>>("std::map<sz::string>", s);
+    bench<std::map<sz::string_view, int>>("std::map<sz::string_view>", s);
+    bench<std::unordered_map<sz::string, int>>("std::umap<sz::string>", s);
+    bench<std::unordered_map<sz::string_view, int>>("std::umap<sz::string_view>", s);
 
     // Pure STL
-    bench<std::map<std::string, int>>("map<std::string>", s);
-    bench<std::map<std::string_view, int>>("map<std::string_view>", s);
-    bench<std::unordered_map<std::string, int>>("unordered_map<std::string>", s);
-    bench<std::unordered_map<std::string_view, int>>("unordered_map<std::string_view>", s);
+    bench<std::map<std::string, int>>("std::map<std::string>", s);
+    bench<std::map<std::string_view, int>>("std::map<std::string_view>", s);
+    bench<std::unordered_map<std::string, int>>("std::umap<std::string>", s);
+    bench<std::unordered_map<std::string_view, int>>("std::umap<std::string_view>", s);
 
     // STL structures with StringZilla operations
-    // bench<std::map<std::string, int, sz::less>>("map<std::string>", s);
-    // bench<std::map<std::string_view, int, sz::less>>("map<std::string_view>", s);
-    // bench<std::unordered_map<std::string, int, sz::hash, sz::equal_to>>("unordered_map<std::string>", s);
-    // bench<std::unordered_map<std::string_view, int, sz::hash, sz::equal_to>>("unordered_map<std::string_view>", s);
+    bench<std::map<std::string, int, sz::less>>("std::map<std::string, sz::less>", s);
+    bench<std::map<std::string_view, int, sz::less>>("std::map<std::string_view, sz::less>", s);
+    bench<std::unordered_map<std::string, int, sz::hash, sz::equal_to>>("std::umap<std::string, sz::hash>", s);
+    bench<std::unordered_map<std::string_view, int, sz::hash, sz::equal_to>>("std::umap<std::string_view, sz::hash>",
+                                                                             s);
 }
 
 int main(int argc, char const **argv) {
@@ -77,6 +78,8 @@ int main(int argc, char const **argv) {
     // Baseline benchmarks for real words, coming in all lengths
     std::printf("Benchmarking on real words:\n");
     bench_tokens(dataset.tokens);
+    std::printf("Benchmarking on real lines:\n");
+    bench_tokens(dataset.lines);
 
     // Run benchmarks on tokens of different length
     for (std::size_t token_length : {1, 2, 3, 4, 5, 6, 7, 8, 16, 32}) {

scripts/test.cpp

@@ -1915,8 +1915,8 @@ static void test_stl_containers() {
     assert(sorted_words_sz.empty());
     assert(words_sz.empty());
 
-    std::map<std::string, int, sz::string_view_less> sorted_words_stl;
-    std::unordered_map<std::string, int, sz::string_view_hash, sz::string_view_equal_to> words_stl;
+    std::map<std::string, int, sz::less> sorted_words_stl;
+    std::unordered_map<std::string, int, sz::hash, sz::equal_to> words_stl;
     assert(sorted_words_stl.empty());
     assert(words_stl.empty());
 }