Add enif_hash support

This is related to #10, and will allow `fine::Atom`s and `fine::Term`s
to be used as `std::map`, and `std::unordered_map` keys.

Author: brodeuralexis

c_include/fine.hpp

@@ -44,6 +44,15 @@ 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);
@@ -90,6 +99,7 @@ class Atom {
   }
 
   friend struct Encoder<Atom>;
+  friend struct __private__::Hasher<Atom>;
 
   friend int __private__::load(ErlNifEnv *env, void **priv_data,
                                ERL_NIF_TERM load_info);
@@ -1071,6 +1081,34 @@ 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::INTERNAL, 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)                                                  \
@@ -1128,4 +1166,18 @@ inline int load(ErlNifEnv *env, void **, ERL_NIF_TERM) {
 
 } // namespace fine
 
+namespace std {
+template <> struct hash<::fine::Term> {
+  size_t operator()(const ::fine::Term &term) noexcept {
+    return ::fine::hash(term);
+  }
+};
+
+template <> struct hash<::fine::Atom> {
+  size_t operator()(const ::fine::Term &term) noexcept {
+    return ::fine::hash(term);
+  }
+};
+} // namespace std
+
 #endif

test/c_src/finest.cpp

@@ -325,6 +325,13 @@ 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);
+}
+FINE_NIF(hash_test, 0);
+
 } // namespace finest
 
 FINE_INIT("Elixir.Finest.NIF");

test/lib/finest/nif.ex

@@ -59,5 +59,7 @@ 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!()
+
   defp err!(), do: :erlang.nif_error(:not_loaded)
 end

test/test/finest_test.exs

@@ -313,4 +313,12 @@ defmodule FinestTest do
       NIF.shared_mutex_shared_lock_test()
     end
   end
+
+  describe "hash" do
+    test "phash2" do
+      for elem <- [42, "fine", ["it", %{"should" => {"just", "work"}}]] do
+        assert NIF.hash_test(elem) == :erlang.phash2(elem)
+      end
+    end
+  end
 end