module Ouroboros.Network.Hashable
  ( Hashable
  , Salt
  , mkSalt
  , mkSaltIO
  , mkUnsafeSalt
  , hashWithSalt
  ) where

import Data.Bifunctor (first)
import Data.Hashable (Hashable)
import Data.Hashable qualified as Hashable
import System.Random (RandomGen, random, randomIO)

newtype Salt = Salt Int
  deriving Int -> Salt -> ShowS
[Salt] -> ShowS
Salt -> String
(Int -> Salt -> ShowS)
-> (Salt -> String) -> ([Salt] -> ShowS) -> Show Salt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Salt -> ShowS
showsPrec :: Int -> Salt -> ShowS
$cshow :: Salt -> String
show :: Salt -> String
$cshowList :: [Salt] -> ShowS
showList :: [Salt] -> ShowS
Show

-- | `Salt` can be constructed from a random generator.
--
mkSalt :: RandomGen g => g -> (Salt, g)
mkSalt :: forall g. RandomGen g => g -> (Salt, g)
mkSalt = (Int -> Salt) -> (Int, g) -> (Salt, g)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Int -> Salt
Salt ((Int, g) -> (Salt, g)) -> (g -> (Int, g)) -> g -> (Salt, g)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g -> (Int, g)
forall g. RandomGen g => g -> (Int, g)
forall a g. (Random a, RandomGen g) => g -> (a, g)
random

-- | Generate a new `Salt` in `IO` monad.
--
mkSaltIO :: IO Salt
mkSaltIO :: IO Salt
mkSaltIO = Int -> Salt
Salt (Int -> Salt) -> IO Int -> IO Salt
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO Int
forall a (m :: * -> *). (Random a, MonadIO m) => m a
randomIO

-- | Unsafe constructor, should only be used in tests.
--
mkUnsafeSalt :: Int -> Salt
mkUnsafeSalt :: Int -> Salt
mkUnsafeSalt = Int -> Salt
Salt

hashWithSalt :: Hashable a => Salt -> a -> Int
hashWithSalt :: forall a. Hashable a => Salt -> a -> Int
hashWithSalt (Salt Int
salt) a
a = Int -> a -> Int
forall a. Hashable a => Int -> a -> Int
Hashable.hashWithSalt Int
salt a
a