Reduce hashing API surface

Now, only `std::hash` is supported to hash `fine::Term` and `fine::Atom`
data structures.

Due to the way `fine::Atom` is implemented, we cannot delegate to
`enif_hash` to hash an atom, but must instead hash the atom's string
representation.

Author: brodeuralexis

c_include/fine.hpp

@@ -44,15 +44,6 @@ template <typename T> ERL_NIF_TERM encode(ErlNifEnv *env, const T &value);
 template <typename T, typename SFINAE = void> struct Decoder;
 template <typename T, typename SFINAE = void> struct Encoder;
 
-enum class HashAlgorithm {
-  INTERNAL = ERL_NIF_INTERNAL_HASH,
-  PHASH2 = ERL_NIF_PHASH2,
-};
-
-namespace __private__ {
-template <typename T> struct Hasher;
-}
-
 namespace __private__ {
 std::vector<ErlNifFunc> &get_erl_nif_funcs();
 int load(ErlNifEnv *env, void **priv_data, ERL_NIF_TERM load_info);
@@ -74,13 +65,16 @@ inline ERL_NIF_TERM make_atom(ErlNifEnv *env, const char *msg) {
 // A representation of an atom term.
 class Atom {
 public:
-  Atom(std::string name) : name(name), term(std::nullopt) {
+  Atom(std::string name) : name(std::move(name)), term(std::nullopt) {
     if (!Atom::initialized) {
       Atom::atoms.push_back(this);
     }
   }
 
-  std::string to_string() const { return this->name; }
+public:
+  const std::string &to_string() const & noexcept { return this->name; }
+
+  std::string to_string() && noexcept { return this->name; }
 
   bool operator==(const Atom &other) const { return this->name == other.name; }
 
@@ -99,7 +93,8 @@ class Atom {
   }
 
   friend struct Encoder<Atom>;
-  friend struct __private__::Hasher<Atom>;
+  friend struct Decoder<Atom>;
+  friend struct ::std::hash<Atom>;
 
   friend int __private__::load(ErlNifEnv *env, void **priv_data,
                                ERL_NIF_TERM load_info);
@@ -1081,34 +1076,6 @@ inline int load(ErlNifEnv *env, void **, ERL_NIF_TERM) {
 }
 } // namespace __private__
 
-// Hash
-namespace __private__ {
-template <> struct Hasher<Atom> {
-  static std::uint64_t hash(HashAlgorithm algorithm, const Atom &atom,
-                            std::uint64_t salt = 0) noexcept {
-    return enif_hash(static_cast<ErlNifHash>(algorithm), *atom.term, salt);
-  }
-};
-
-template <> struct Hasher<Term> {
-  static std::uint64_t hash(HashAlgorithm algorithm, const Term &term,
-                            std::uint64_t salt = 0) noexcept {
-    return enif_hash(static_cast<ErlNifHash>(algorithm), term, salt);
-  }
-};
-} // namespace __private__
-
-template <HashAlgorithm A = HashAlgorithm::PHASH2, typename T>
-inline static std::uint64_t hash(const T &value, std::uint64_t salt = 0) {
-  return __private__::Hasher<T>::hash(A, value, salt);
-}
-
-template <typename T>
-inline static std::uint64_t hash(HashAlgorithm algorithm, const T &value,
-                                 std::uint64_t salt = 0) {
-  return __private__::Hasher<T>::hash(algorithm, value, salt);
-}
-
 // Macros
 
 #define FINE_NIF(name, flags)                                                  \
@@ -1169,13 +1136,13 @@ inline static std::uint64_t hash(HashAlgorithm algorithm, const T &value,
 namespace std {
 template <> struct hash<::fine::Term> {
   size_t operator()(const ::fine::Term &term) noexcept {
-    return ::fine::hash<::fine::HashAlgorithm::PHASH2>(term);
+    return enif_hash(ERL_NIF_INTERNAL_HASH, term, 0);
   }
 };
 
 template <> struct hash<::fine::Atom> {
-  size_t operator()(const ::fine::Term &term) noexcept {
-    return ::fine::hash<::fine::HashAlgorithm::PHASH2>(term);
+  size_t operator()(const ::fine::Atom &atom) noexcept {
+    return std::hash<std::string_view>{}(atom.to_string());
   }
 };
 } // namespace std

test/c_src/finest.cpp

@@ -1,5 +1,6 @@
 #include <cstring>
 #include <exception>
+#include <functional>
 #include <memory_resource>
 #include <optional>
 #include <stdexcept>
@@ -325,12 +326,15 @@ std::nullopt_t shared_mutex_shared_lock_test(ErlNifEnv *) {
 }
 FINE_NIF(shared_mutex_shared_lock_test, 0);
 
-std::uint64_t hash_test(ErlNifEnv *, fine::Term term) noexcept {
-  // Ensure the use of PHASH2. INTERNAL is not guaranteed to be stable across
-  // ERTS instances, even less so ERTS versions.
-  return fine::hash<fine::HashAlgorithm::PHASH2>(term);
+std::uint64_t term_hash_test(ErlNifEnv *, fine::Term term) noexcept {
+  return std::invoke(std::hash<fine::Term>{}, term);
 }
-FINE_NIF(hash_test, 0);
+FINE_NIF(term_hash_test, 0);
+
+std::uint64_t atom_hash_test(ErlNifEnv *, fine::Atom atom) noexcept {
+  return std::invoke(std::hash<fine::Atom>{}, atom);
+}
+FINE_NIF(atom_hash_test, 0);
 
 } // namespace finest
 

test/lib/finest/nif.ex

@@ -59,7 +59,8 @@ defmodule Finest.NIF do
   def shared_mutex_unique_lock_test(), do: err!()
   def shared_mutex_shared_lock_test(), do: err!()
 
-  def hash_test(_term), do: err!()
+  def term_hash_test(_term), do: err!()
+  def atom_hash_test(_term), do: err!()
 
   defp err!(), do: :erlang.nif_error(:not_loaded)
 end

test/test/finest_test.exs

@@ -315,9 +315,15 @@ defmodule FinestTest do
   end
 
   describe "hash" do
-    test "phash2" do
-      for elem <- [42, "fine", ["it", %{"should" => {"just", "work"}}]] do
-        assert NIF.hash_test(elem) == :erlang.phash2(elem)
+    test "term" do
+      for value <- [42, "fine", ["it", %{"should" => {"just", "work"}}], :atom] do
+        assert NIF.term_hash_test(value) == NIF.term_hash_test(value)
+      end
+    end
+
+    test "atom" do
+      for value <- [:ok, :error, :"with spaces", Enum, nil, true, false] do
+        assert NIF.atom_hash_test(value) == NIF.atom_hash_test(value)
       end
     end
   end