Implement Hash for atoms (#695)

---------

Co-authored-by: Sonny Scroggin <[email protected]>

Author: filmor

rustler/src/types/atom.rs

@@ -1,6 +1,8 @@
 use crate::wrapper::atom;
 use crate::wrapper::NIF_TERM;
 use crate::{Decoder, Encoder, Env, Error, NifResult, Term};
+use std::fmt;
+use std::hash::{Hash, Hasher};
 
 // Atoms are a special case of a term. They can be stored and used on all envs regardless of where
 // it lives and when it is created.
@@ -81,7 +83,6 @@ impl Atom {
     }
 }
 
-use std::fmt;
 impl fmt::Debug for Atom {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         crate::wrapper::term::fmt(self.as_c_arg(), f)
@@ -137,6 +138,15 @@ pub(in crate::types) fn decode_bool(term: Term) -> NifResult<bool> {
     Err(Error::BadArg)
 }
 
+impl Hash for Atom {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        use crate::sys::{enif_hash, ErlNifHash};
+        let hash =
+            unsafe { enif_hash(ErlNifHash::ERL_NIF_INTERNAL_HASH, self.as_c_arg(), 0) as u32 };
+        state.write_u32(hash);
+    }
+}
+
 // This is safe because atoms are never removed/changed once they are created.
 unsafe impl Sync for Atom {}
 unsafe impl Send for Atom {}

rustler_tests/lib/rustler_test.ex

@@ -64,6 +64,7 @@ defmodule RustlerTest do
   def map_from_arrays(_keys, _values), do: err()
   def map_from_pairs(_pairs), do: err()
   def map_generic(_), do: err()
+  def map_atom_keys(_), do: err()
 
   def resource_make(), do: err()
   def resource_set_integer_field(_, _), do: err()

rustler_tests/native/rustler_test/src/test_map.rs

@@ -1,6 +1,6 @@
 use rustler::types::map::MapIterator;
 use rustler::types::tuple::make_tuple;
-use rustler::{Encoder, Env, Error, ListIterator, NifResult, Term};
+use rustler::{Atom, Encoder, Env, Error, ListIterator, NifResult, Term};
 
 #[rustler::nif]
 pub fn sum_map_values(iter: MapIterator) -> NifResult<i64> {
@@ -62,3 +62,10 @@ pub fn map_generic(
 ) -> std::collections::HashMap<i64, String> {
     map
 }
+
+#[rustler::nif]
+pub fn map_atom_keys(
+    map: std::collections::HashMap<Atom, String>,
+) -> std::collections::HashMap<Atom, String> {
+    map
+}