-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | A class for types that can be converted to a hash value
--   
--   This package defines a class, Hashable, for types that can be
--   converted to a hash value. This class exists for the benefit of
--   hashing-based data structures. The package provides instances for
--   basic types and a way to combine hash values.
--   
--   Hashable is intended exclusively for use in in-memory data
--   structures.
--   
--   Hashable does not have a fixed standard. This allows it
--   to improve over time.
--   
--   Because it does not have a fixed standard, different computers or
--   computers on different versions of the code will observe different
--   hash values. As such, hashable is not recommended for use other
--   than in-memory datastructures. Specifically, hashable is not
--   intended for network use or in applications which persist hashed
--   values. For stable hashing use named hashes: sha256, crc32, xxhash
--   etc.
@package hashable
@version 1.5.0.0

-- | Lifting of the Hashable class to unary and binary type
--   constructors. These classes are needed to express the constraints on
--   arguments of types that are parameterized by type constructors.
--   Fixed-point data types and monad transformers are such types.
module Data.Hashable.Lifted
class (Eq1 t, forall a. Hashable a => Hashable t a) => Hashable1 (t :: Type -> Type)

-- | Lift a hashing function through the type constructor.
liftHashWithSalt :: Hashable1 t => (Int -> a -> Int) -> Int -> t a -> Int
($dmliftHashWithSalt) :: (Hashable1 t, Generic1 t, GHashable One (Rep1 t)) => (Int -> a -> Int) -> Int -> t a -> Int
class (Eq2 t, forall a. Hashable a => Hashable1 t a) => Hashable2 (t :: Type -> Type -> Type)

-- | Lift a hashing function through the binary type constructor.
liftHashWithSalt2 :: Hashable2 t => (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> t a b -> Int

-- | Lift the hashWithSalt function through the type constructor.
--   
--   
--   hashWithSalt1 = liftHashWithSalt hashWithSalt
--   
hashWithSalt1 :: (Hashable1 f, Hashable a) => Int -> f a -> Int

-- | Lift the hashWithSalt function through the type constructor.
--   
--   
--   hashWithSalt2 = liftHashWithSalt2 hashWithSalt hashWithSalt
--   
hashWithSalt2 :: (Hashable2 f, Hashable a, Hashable b) => Int -> f a b -> Int

-- | Lift the hashWithSalt function halfway through the type
--   constructor. This function makes a suitable default implementation of
--   liftHashWithSalt, given that the type constructor t in
--   question can unify with f a.
defaultLiftHashWithSalt :: (Hashable2 f, Hashable a) => (Int -> b -> Int) -> Int -> f a b -> Int

-- | Hashable support for GHC generics.
module Data.Hashable.Generic

-- | Generic hashWithSalt.
genericHashWithSalt :: (Generic a, GHashable Zero (Rep a)) => Int -> a -> Int

-- | Generic liftHashWithSalt.
genericLiftHashWithSalt :: (Generic1 t, GHashable One (Rep1 t)) => (Int -> a -> Int) -> Int -> t a -> Int

-- | The class of types that can be generically hashed.
class GHashable arity (f :: Type -> Type)
ghashWithSalt :: GHashable arity f => HashArgs arity a -> Int -> f a -> Int
data One
data Zero
data family HashArgs arity a

-- | This module defines a class, Hashable, for types that can be
--   converted to a hash value. This class exists for the benefit of
--   hashing-based data structures. The module provides instances for most
--   standard types. Efficient instances for other types can be generated
--   automatically and effortlessly using the generics support in GHC 7.4
--   and above.
--   
--   The easiest way to get started is to use the hash function.
--   Here is an example session with ghci.
--   
--   
--   ghci> import Data.Hashable
--   ghci> hash "foo"
--   60853164
--   
module Data.Hashable

-- | The class of types that can be converted to a hash value.
--   
--   Minimal implementation: hashWithSalt.
--   
--   Hashable is intended exclusively for use in in-memory data
--   structures. . Hashable does not have a fixed standard.
--   This allows it to improve over time. . Because it does not have a
--   fixed standard, different computers or computers on different versions
--   of the code will observe different hash values. As such,
--   Hashable is not recommended for use other than in-memory
--   datastructures. Specifically, Hashable is not intended for
--   network use or in applications which persist hashed values. For stable
--   hashing use named hashes: sha256, crc32, xxhash etc.
--   
--   If you are looking for Hashable instance in time
--   package, check time-compat
class Eq a => Hashable a

-- | Return a hash value for the argument, using the given salt.
--   
--   The general contract of hashWithSalt is:
--   
--   
--   
- If two values are equal according to the == method, then
--   applying the hashWithSalt method on each of the two values
--   must produce the same integer result if the same salt is used
--   in each case.
--   
- It is not required that if two values are unequal according
--   to the == method, then applying the hashWithSalt method
--   on each of the two values must produce distinct integer results.
--   However, the programmer should be aware that producing distinct
--   integer results for unequal values may improve the performance of
--   hashing-based data structures.
--   
- This method can be used to compute different hash values for the
--   same input by providing a different salt in each application of the
--   method. This implies that any instance that defines
--   hashWithSalt must make use of the salt in its
--   implementation.
--   
- hashWithSalt may return negative Int values.
--   
hashWithSalt :: Hashable a => Int -> a -> Int
($dmhashWithSalt) :: (Hashable a, Generic a, GHashable Zero (Rep a)) => Int -> a -> Int

-- | Like hashWithSalt, but no salt is used. The default
--   implementation uses hashWithSalt with some default salt.
--   Instances might want to implement this method to provide a more
--   efficient implementation than the default implementation.
hash :: Hashable a => a -> Int
infixl 0 `hashWithSalt`

-- | Transform a value into a Hashable value, then hash the
--   transformed value using the given salt.
--   
--   This is a useful shorthand in cases where a type can easily be mapped
--   to another type that is already an instance of Hashable.
--   Example:
--   
--   
--   data Foo = Foo | Bar
--            deriving (Enum)
--   
--   instance Hashable Foo where
--       hashWithSalt = hashUsing fromEnum
--   
hashUsing :: Hashable b => (a -> b) -> Int -> a -> Int

-- | Compute a hash value for the content of this pointer.
hashPtr :: Ptr a -> Int -> IO Int

-- | Compute a hash value for the content of this pointer, using an initial
--   salt.
--   
--   This function can for example be used to hash non-contiguous segments
--   of memory as if they were one contiguous segment, by using the output
--   of one hash as the salt for the next.
hashPtrWithSalt :: Ptr a -> Int -> Salt -> IO Salt

-- | Compute a hash value for the content of this ByteArray#,
--   beginning at the specified offset, using specified number of bytes.
hashByteArray :: ByteArray# -> Int -> Int -> Int

-- | Compute a hash value for the content of this ByteArray#, using
--   an initial salt.
--   
--   This function can for example be used to hash non-contiguous segments
--   of memory as if they were one contiguous segment, by using the output
--   of one hash as the salt for the next.
hashByteArrayWithSalt :: ByteArray# -> Int -> Int -> Salt -> Salt

-- | Since we support a generic implementation of hashWithSalt we
--   cannot also provide a default implementation for that method for the
--   non-generic instance use case. Instead we provide
--   defaultHashWith.
defaultHashWithSalt :: Hashable a => Int -> a -> Int

-- | Default implementation of hash based on hashWithSalt.
defaultHash :: Hashable a => a -> Int

-- | A hashable value along with the result of the hash function.
data Hashed a

-- | Wrap a hashable value, caching the hash function result.
hashed :: Hashable a => a -> Hashed a

-- | hash has Eq requirement.
hashedHash :: Hashed a -> Int

-- | Unwrap hashed value.
unhashed :: Hashed a -> a

-- | Hashed cannot be Functor
mapHashed :: Hashable b => (a -> b) -> Hashed a -> Hashed b

-- | Hashed cannot be Traversable
traverseHashed :: (Hashable b, Functor f) => (a -> f b) -> Hashed a -> f (Hashed b)
