Fix compile errors, call natural from hash function

Author: jappeace

Data/HashMap/Internal.hs

@@ -199,8 +199,10 @@ import Data.Coerce (coerce)
 ------------------------------------------------------------------------
 
 -- | Convenience function.  Compute a hash value for the given value.
-hash :: H.Hashable a => Integer -> a -> Hash
-hash salt = fromIntegral . H.hashWithSalt (fromIntegral salt)
+hash ::forall a (salt :: Nat) . H.Hashable a => Proxy salt -> a -> Hash
+hash proxy = fromIntegral . H.hashWithSalt (fromIntegral salt)
+   where
+     salt = natVal proxy -- TODO ensure is unboxed, ensure is a Word
 
 data Leaf k v = L !k v
   deriving (Eq)
@@ -223,6 +225,9 @@ instance NF.NFData2 Leaf where
 
 
 #if WORD_SIZE_IN_BITS == 64
+-- TODO figure out the Natural representation
+-- (I think this negative value causes issues because the underlying type is Word)
+-- there is a (golden) test in hashable to ensure we salt by default correctly
 type DefaultSalt = -2578643520546668380  -- 0xdc36d1615b7400a4
 #else
 type DefaultSalt = 0x087fc72c
@@ -601,9 +606,7 @@ singleton :: (Hashable k) => k -> v -> HashMapT salt k v
 singleton = singleton'
 
 singleton' :: forall k v salt . (Hashable k) => k -> v -> HashMapT salt k v
-singleton' k v = Leaf (hash salt k) (L k v)
-  where
-    salt = natVal (Proxy :: Proxy salt)
+singleton' k v = Leaf (hash (Proxy :: Proxy salt) k) (L k v)
 
 ------------------------------------------------------------------------
 -- * Basic interface
@@ -644,9 +647,7 @@ lookup k m = case lookup# k m of
 {-# INLINE lookup #-}
 
 lookup# :: (Eq k, Hashable k) => k -> HashMapT salt k v -> (# (# #) | v #)
-lookup# k m = lookupCont (\_ -> (# (# #) | #)) (\v _i -> (# | v #)) (hash salt k) k 0 m
-  where
-    salt = natVal (Proxy :: Proxy salt)
+lookup# k m = lookupCont (\_ -> (# (# #) | #)) (\v _i -> (# | v #)) (hash (Proxy :: Proxy salt) k) k 0 m
 {-# INLINABLE lookup# #-}
 
 #else
@@ -828,9 +829,7 @@ bitmapIndexedOrFull b ary
 -- key in this map.  If this map previously contained a mapping for
 -- the key, the old value is replaced.
 insert :: forall k v salt . (Eq k, Hashable k) => k -> v -> HashMapT salt k v -> HashMapT salt k v
-insert k v m = insert' (hash salt k) k v m
-  where
-    salt = natVal (Proxy :: Proxy salt)
+insert k v m = insert' (hash (Proxy :: Proxy salt) k) k v m
 {-# INLINABLE insert #-}
 
 insert' :: forall k v salt . Eq k => Hash -> k -> v -> HashMapT salt k v -> HashMapT salt k v
@@ -961,7 +960,7 @@ setAtPosition i k x ary = A.update ary i (L k x)
 unsafeInsert :: (Eq k) => k -> v -> HashMapT salt k v -> HashMapT salt k v
 unsafeInsert k0 v0 m0 = runST (go h0 k0 v0 0 m0)
   where
-    h0 = hash k0
+    h0 = hash (Proxy :: Proxy salt) k0
     go !h !k x !_ Empty = return $! Leaf h (L k x)
     go h k x s t@(Leaf hy l@(L ky y))
         | hy == h = if ky == k
@@ -1043,7 +1042,7 @@ insertModifying :: (Eq k, Hashable k) => v -> (v -> (# v #)) -> k -> HashMapT sa
             -> HashMapT salt k v
 insertModifying x f k0 m0 = go h0 k0 0 m0
   where
-    !h0 = hash k0
+    !h0 = hash (Proxy :: Proxy salt) k0
     go !h !k !_ Empty = Leaf h (L k x)
     go h k s t@(Leaf hy l@(L ky y))
         | hy == h = if ky == k
@@ -1114,7 +1113,7 @@ unsafeInsertWithKey :: forall k v salt. (Eq k, Hashable k)
                  -> HashMapT salt k v
 unsafeInsertWithKey f k0 v0 m0 = runST (go h0 k0 v0 0 m0)
   where
-    h0 = hash k0
+    h0 = hash (Proxy :: Proxy salt) k0
     go :: Hash -> k -> v -> Shift -> HashMapT salt k v -> ST s (HashMapT salt k v)
     go !h !k x !_ Empty = return $! Leaf h (L k x)
     go h k x s t@(Leaf hy l@(L ky y))
@@ -1147,7 +1146,7 @@ unsafeInsertWithKey f k0 v0 m0 = runST (go h0 k0 v0 0 m0)
 -- | /O(log n)/ Remove the mapping for the specified key from this map
 -- if present.
 delete :: (Eq k, Hashable k) => k -> HashMapT salt k v -> HashMapT salt k v
-delete k m = delete' (hash k) k m
+delete k m = delete' (hash (Proxy :: Proxy salt) k) k m
 {-# INLINABLE delete #-}
 
 delete' :: Eq k => Hash -> k -> HashMapT salt k v -> HashMapT salt k v
@@ -1268,7 +1267,7 @@ adjust f k m = adjust# (\v -> (# f v #)) k m
 adjust# :: (Eq k, Hashable k) => (v -> (# v #)) -> k -> HashMapT salt k v -> HashMapT salt k v
 adjust# f k0 m0 = go h0 k0 0 m0
   where
-    h0 = hash k0
+    h0 = hash (Proxy :: Proxy salt) k0
     go !_ !_ !_ Empty = Empty
     go h k _ t@(Leaf hy (L ky y))
         | hy == h && ky == k = case f y of
@@ -1343,7 +1342,7 @@ alterF :: (Functor f, Eq k, Hashable k)
 -- @f@ and a functor that is similar to Const but not actually Const.
 alterF f = \ !k !m ->
   let
-    !h = hash k
+    !h = hash (Proxy :: Proxy salt) k
     mv = lookup' h k m
   in (<$> f mv) $ \fres ->
     case fres of