Data.Hashable

hashable-1.5.0.0: A class for types that can be converted to a hash value

Copyright | (c) Milan Straka 2010 (c) Johan Tibell 2011 (c) Bryan O'Sullivan 2011 2012
License | BSD-3-Clause
Maintainer | johan.tibell@gmail.com
Stability | provisional
Portability | portable
Safe Haskell | Safe
Language | Haskell2010

Data.Hashable

Contents

- Hashing and security
- Computing hash values
- Creating new instances
  - Generic instances
    - Understanding a compiler error
  - Writing instances by hand
    - Hashing contructors with multiple fields
    - Hashing types with multiple constructors
- Caching hashes

Description

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

Synopsis

- class Eq a => Hashable a where
  - hashWithSalt :: Int -> a -> Int
  - hash :: a -> Int
- hashUsing :: Hashable b => (a -> b) -> Int -> a -> Int
- hashPtr :: Ptr a -> Int -> IO Int
- hashPtrWithSalt :: Ptr a -> Int -> Salt -> IO Salt
- hashByteArray :: ByteArray# -> Int -> Int -> Int
- hashByteArrayWithSalt :: ByteArray# -> Int -> Int -> Salt -> Salt
- defaultHashWithSalt :: Hashable a => Int -> a -> Int
- defaultHash :: Hashable a => a -> Int
- data Hashed a
- hashed :: Hashable a => a -> Hashed a
- hashedHash :: Hashed a -> Int
- unhashed :: Hashed a -> a
- mapHashed :: Hashable b => (a -> b) -> Hashed a -> Hashed b
- traverseHashed :: (Hashable b, Functor f) => (a -> f b) -> Hashed a -> f (Hashed b)

# Hashing and security

Applications that use hash-based data structures to store input from untrusted users can be susceptible to "hash DoS", a class of denial-of-service attack that uses deliberately chosen colliding inputs to force an application into unexpectedly behaving with quadratic time complexity.

At this time, the string hashing functions used in this library are susceptible to such attacks and users are recommended to either use a `Map` to store keys derived from untrusted input or to use a hash function (e.g. SipHash) that's resistant to such attacks. A future version of this library might ship with such hash functions.

# Computing hash values

class Eq a => Hashable a where #

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

Minimal complete definition

Nothing

Methods

hashWithSalt :: Int -> a -> Int infixl 0 #

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.

default hashWithSalt :: (Generic a, GHashable Zero (Rep a)) => Int -> a -> Int #

hash :: 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.

#### Instances

Instances details

Hashable ByteArray # | This instance was available since 1.4.1.0 only for GHC-9.4+ Since: 1.4.2.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteArray -> Int # hash :: ByteArray -> Int #
Hashable ByteString # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Hashable ByteString # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Hashable ShortByteString # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ShortByteString -> Int # hash :: ShortByteString -> Int #
Hashable IntSet # | Since: 1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntSet -> Int # hash :: IntSet -> Int #
Hashable BigNat # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> BigNat -> Int # hash :: BigNat -> Int #
Hashable Void # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Void -> Int # hash :: Void -> Int #
Hashable ThreadId # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ThreadId -> Int # hash :: ThreadId -> Int #
Hashable SomeTypeRep # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> SomeTypeRep -> Int # hash :: SomeTypeRep -> Int #
Hashable Unique # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Unique -> Int # hash :: Unique -> Int #
Hashable Version # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Version -> Int # hash :: Version -> Int #
Hashable Fingerprint # | Since: 1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Fingerprint -> Int # hash :: Fingerprint -> Int #
Hashable IntPtr # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntPtr -> Int # hash :: IntPtr -> Int #
Hashable WordPtr # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WordPtr -> Int # hash :: WordPtr -> Int #
Hashable Int16 # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int16 -> Int # hash :: Int16 -> Int #
Hashable Int32 # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int32 -> Int # hash :: Int32 -> Int #
Hashable Int64 # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int64 -> Int # hash :: Int64 -> Int #
Hashable Int8 # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int8 -> Int # hash :: Int8 -> Int #
Hashable Word16 # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word16 -> Int # hash :: Word16 -> Int #
Hashable Word32 # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word32 -> Int # hash :: Word32 -> Int #
Hashable Word64 # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word64 -> Int # hash :: Word64 -> Int #
Hashable Word8 # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word8 -> Int # hash :: Word8 -> Int #
Hashable Ordering # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ordering -> Int # hash :: Ordering -> Int #
Hashable OsString # | Since: 1.4.2.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> OsString -> Int # hash :: OsString -> Int #
Hashable PosixString # | Since: 1.4.2.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> PosixString -> Int # hash :: PosixString -> Int #
Hashable WindowsString # | Since: 1.4.2.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WindowsString -> Int # hash :: WindowsString -> Int #
Hashable Text # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Hashable Text # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Hashable Integer # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Integer -> Int # hash :: Integer -> Int #
Hashable Natural # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Natural -> Int # hash :: Natural -> Int #
Hashable () # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> () -> Int # hash :: () -> Int #
Hashable Bool # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Bool -> Int # hash :: Bool -> Int #
Hashable Char # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Char -> Int # hash :: Char -> Int #
Hashable Double # | Note: prior to `hashable-1.3.0.0`, `hash 0.0 /= hash (-0.0)` The `hash` of NaN is not well defined. Since: 1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Double -> Int # hash :: Double -> Int #
Hashable Float # | Note: prior to `hashable-1.3.0.0`, `hash 0.0 /= hash (-0.0)` The `hash` of NaN is not well defined. Since: 1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Float -> Int # hash :: Float -> Int #
Hashable Int # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int -> Int # hash :: Int -> Int #
Hashable Word # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word -> Int # hash :: Word -> Int #
Hashable a => Hashable (Complex a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Complex a -> Int # hash :: Complex a -> Int #
Hashable a => Hashable (First a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> First a -> Int # hash :: First a -> Int #
Hashable a => Hashable (Last a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Last a -> Int # hash :: Last a -> Int #
Hashable a => Hashable (Max a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Max a -> Int # hash :: Max a -> Int #
Hashable a => Hashable (Min a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Min a -> Int # hash :: Min a -> Int #
Hashable a => Hashable (WrappedMonoid a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WrappedMonoid a -> Int # hash :: WrappedMonoid a -> Int #
Hashable v => Hashable (IntMap v) # | Since: 1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntMap v -> Int # hash :: IntMap v -> Int #
Hashable v => Hashable (Seq v) # | Since: 1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Seq v -> Int # hash :: Seq v -> Int #
Hashable v => Hashable (Set v) # | Since: 1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Set v -> Int # hash :: Set v -> Int #
Hashable v => Hashable (Tree v) # | Since: 1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Tree v -> Int # hash :: Tree v -> Int #
Hashable a => Hashable (NonEmpty a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> NonEmpty a -> Int # hash :: NonEmpty a -> Int #
Hashable a => Hashable (Identity a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Identity a -> Int # hash :: Identity a -> Int #
Hashable (FunPtr a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> FunPtr a -> Int # hash :: FunPtr a -> Int #
Hashable (Ptr a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ptr a -> Int # hash :: Ptr a -> Int #
Hashable a => Hashable (Ratio a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ratio a -> Int # hash :: Ratio a -> Int #
Hashable (StableName a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> StableName a -> Int # hash :: StableName a -> Int #
Eq a => Hashable (Hashed a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Hashed a -> Int # hash :: Hashed a -> Int #
Hashable a => Hashable (Maybe a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Maybe a -> Int # hash :: Maybe a -> Int #
Hashable a => Hashable (Solo a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Solo a -> Int # hash :: Solo a -> Int #
Hashable a => Hashable [a] # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> [a] -> Int # hash :: [a] -> Int #
Hashable (Fixed a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Fixed a -> Int # hash :: Fixed a -> Int #
Hashable a => Hashable (Arg a b) # | Note: Prior to `hashable-1.3.0.0` the hash computation included the second argument of `Arg` which wasn't consistent with its `Eq` instance. Since `hashable-1.5.0.0`, `hash (Semi.arg a _) = hash a` Since: 1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Arg a b -> Int # hash :: Arg a b -> Int #
(Hashable k, Hashable v) => Hashable (Map k v) # | Since: 1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Map k v -> Int # hash :: Map k v -> Int #
(Hashable a, Hashable b) => Hashable (Either a b) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Either a b -> Int # hash :: Either a b -> Int #
Hashable (Proxy a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Proxy a -> Int # hash :: Proxy a -> Int #
Hashable (TypeRep a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> TypeRep a -> Int # hash :: TypeRep a -> Int #
(Hashable a1, Hashable a2) => Hashable (a1, a2) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2) -> Int # hash :: (a1, a2) -> Int #
Hashable a => Hashable (Const a b) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Const a b -> Int # hash :: Const a b -> Int #
(Hashable a1, Hashable a2, Hashable a3) => Hashable (a1, a2, a3) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3) -> Int # hash :: (a1, a2, a3) -> Int #
(Hashable (f a), Hashable (g a)) => Hashable (Product f g a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Product f g a -> Int # hash :: Product f g a -> Int #
(Hashable (f a), Hashable (g a)) => Hashable (Sum f g a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Sum f g a -> Int # hash :: Sum f g a -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4) => Hashable (a1, a2, a3, a4) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4) -> Int # hash :: (a1, a2, a3, a4) -> Int #
Hashable (f (g a)) => Hashable (Compose f g a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Compose f g a -> Int # hash :: Compose f g a -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5) => Hashable (a1, a2, a3, a4, a5) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5) -> Int # hash :: (a1, a2, a3, a4, a5) -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6) => Hashable (a1, a2, a3, a4, a5, a6) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5, a6) -> Int # hash :: (a1, a2, a3, a4, a5, a6) -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6, Hashable a7) => Hashable (a1, a2, a3, a4, a5, a6, a7) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5, a6, a7) -> Int # hash :: (a1, a2, a3, a4, a5, a6, a7) -> Int #

# Creating new instances

There are two ways to create new instances: by deriving instances automatically using GHC's generic programming support or by writing instances manually.

## Generic instances

The recommended way to make instances of `Hashable` for most types is to use the compiler's support for automatically generating default instances using GHC.Generics.

    {-# LANGUAGE DeriveGeneric #-}

    import GHC.Generics (Generic)
    import Data.Hashable

    data Foo a = Foo a String
                 deriving (Eq, Generic)

    instance Hashable a => Hashable (Foo a)

    data Colour = Red | Green | Blue
                  deriving Generic

    instance Hashable Colour

If you omit a body for the instance declaration, GHC will generate a default instance that correctly and efficiently hashes every constructor and parameter.

The default implementations are provided by `genericHashWithSalt` and `genericLiftHashWithSalt`; those together with the generic type class `GHashable` and auxiliary functions are exported from the Data.Hashable.Generic module.

### Understanding a compiler error

Suppose you intend to use the generic machinery to automatically generate a `Hashable` instance.

    data Oops = Oops
         -- forgot to add "deriving Generic" here!

    instance Hashable Oops

And imagine that, as in the example above, you forget to add a "`deriving `Generic``" clause to your data type. At compile time, you will get an error message from GHC that begins roughly as follows:

    No instance for (GHashable (Rep Oops))

This error can be confusing, as `GHashable` is not exported (it is an internal typeclass used by this library's generics machinery). The correct fix is simply to add the missing "`deriving `Generic``".

## Writing instances by hand

To maintain high quality hashes, new `Hashable` instances should be built using existing `Hashable` instances, combinators, and hash functions.

The functions below can be used when creating new instances of `Hashable`. For example, for many string-like types the `hashWithSalt` method can be defined in terms of either `hashPtrWithSalt` or `hashByteArrayWithSalt`. Here's how you could implement an instance for the `ByteString` data type, from the `bytestring` package:

    import qualified Data.ByteString as B
    import qualified Data.ByteString.Internal as B
    import qualified Data.ByteString.Unsafe as B
    import Data.Hashable
    import Foreign.Ptr (castPtr)

    instance Hashable B.ByteString where
        hashWithSalt salt bs = B.inlinePerformIO $
                               B.unsafeUseAsCStringLen bs $ \(p, len) ->
                               hashPtrWithSalt p (fromIntegral len) salt

### Hashing contructors with multiple fields

Hash constructors with multiple fields by chaining `hashWithSalt`:

    data Date = Date Int Int Int

    instance Hashable Date where
        hashWithSalt s (Date yr mo dy) =
            s `hashWithSalt`
            yr `hashWithSalt`
            mo `hashWithSalt` dy

If you need to chain hashes together, use `hashWithSalt` and follow this recipe:

    combineTwo h1 h2 = h1 `hashWithSalt` h2

### Hashing types with multiple constructors

For a type with several value constructors, there are a few possible approaches to writing a `Hashable` instance.

If the type is an instance of `Enum`, the easiest path is to convert it to an `Int`, and use the existing `Hashable` instance for `Int`.

    data Color = Red | Green | Blue
                 deriving Enum

    instance Hashable Color where
        hashWithSalt = hashUsing fromEnum

If the type's constructors accept parameters, it is important to distinguish the constructors. To distinguish the constructors, add a different integer to the hash computation of each constructor:

    data Time = Days Int
              | Weeks Int
              | Months Int

    instance Hashable Time where
        hashWithSalt s (Days n)   = s `hashWithSalt`
                                    (0::Int) `hashWithSalt` n
        hashWithSalt s (Weeks n)  = s `hashWithSalt`
                                    (1::Int) `hashWithSalt` n
        hashWithSalt s (Months n) = s `hashWithSalt`
                                    (2::Int) `hashWithSalt` n

hashUsing #

Arguments

:: Hashable b |
=> (a -> b) | Transformation function.
-> Int | Salt.
-> a | Value to transform.
-> Int |

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

Since: 1.2.0.0

hashPtr #

Arguments

:: Ptr a | pointer to the data to hash
-> Int | length, in bytes
-> IO Int | hash value

Compute a hash value for the content of this pointer.

hashPtrWithSalt #

Arguments

:: Ptr a | pointer to the data to hash
-> Int | length, in bytes
-> Salt | salt
-> IO Salt | hash value

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.

hashByteArray #

Arguments

:: ByteArray# | data to hash
-> Int | offset, in bytes
-> Int | length, in bytes
-> Int | hash value

Compute a hash value for the content of this `ByteArray#`, beginning at the specified offset, using specified number of bytes.

hashByteArrayWithSalt #

Arguments

:: ByteArray# | data to hash
-> Int | offset, in bytes
-> Int | length, in bytes
-> Salt | salt
-> Salt | hash value

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.

defaultHashWithSalt :: Hashable a => Int -> a -> Int #

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`.

Since: 1.4.3.0

defaultHash :: Hashable a => a -> Int #

Default implementation of `hash` based on `hashWithSalt`.

Since: 1.4.3.0

# Caching hashes

data Hashed a #

A hashable value along with the result of the `hash` function.

#### Instances

Instances details

Eq1 Hashed # |
Instance details Defined in Data.Hashable.Class Methods liftEq :: (a -> b -> Bool) -> Hashed a -> Hashed b -> Bool #
Ord1 Hashed # |
Instance details Defined in Data.Hashable.Class Methods liftCompare :: (a -> b -> Ordering) -> Hashed a -> Hashed b -> Ordering #
Show1 Hashed # |
Instance details Defined in Data.Hashable.Class Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Hashed a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Hashed a] -> ShowS #
Foldable Hashed # |
Instance details Defined in Data.Hashable.Class Methods fold :: Monoid m => Hashed m -> m # foldMap :: Monoid m => (a -> m) -> Hashed a -> m # foldMap' :: Monoid m => (a -> m) -> Hashed a -> m # foldr :: (a -> b -> b) -> b -> Hashed a -> b # foldr' :: (a -> b -> b) -> b -> Hashed a -> b # foldl :: (b -> a -> b) -> b -> Hashed a -> b # foldl' :: (b -> a -> b) -> b -> Hashed a -> b # foldr1 :: (a -> a -> a) -> Hashed a -> a # foldl1 :: (a -> a -> a) -> Hashed a -> a # toList :: Hashed a -> [a] # null :: Hashed a -> Bool # length :: Hashed a -> Int # elem :: Eq a => a -> Hashed a -> Bool # maximum :: Ord a => Hashed a -> a # minimum :: Ord a => Hashed a -> a # sum :: Num a => Hashed a -> a # product :: Num a => Hashed a -> a #
Hashable1 Hashed # |
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Hashed a -> Int #
NFData a => NFData (Hashed a) # |
Instance details Defined in Data.Hashable.Class Methods rnf :: Hashed a -> () #
(IsString a, Hashable a) => IsString (Hashed a) # |
Instance details Defined in Data.Hashable.Class Methods fromString :: String -> Hashed a #
Show a => Show (Hashed a) # |
Instance details Defined in Data.Hashable.Class Methods showsPrec :: Int -> Hashed a -> ShowS # show :: Hashed a -> String # showList :: [Hashed a] -> ShowS #
Eq a => Eq (Hashed a) # | Uses precomputed hash to detect inequality faster
Instance details Defined in Data.Hashable.Class Methods (==) :: Hashed a -> Hashed a -> Bool # (/=) :: Hashed a -> Hashed a -> Bool #
Ord a => Ord (Hashed a) # |
Instance details Defined in Data.Hashable.Class Methods compare :: Hashed a -> Hashed a -> Ordering # (<) :: Hashed a -> Hashed a -> Bool # (<=) :: Hashed a -> Hashed a -> Bool # (>) :: Hashed a -> Hashed a -> Bool # (>=) :: Hashed a -> Hashed a -> Bool # max :: Hashed a -> Hashed a -> Hashed a # min :: Hashed a -> Hashed a -> Hashed a #
Eq a => Hashable (Hashed a) # |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Hashed a -> Int # hash :: Hashed a -> Int #

hashed :: Hashable a => a -> Hashed a #

Wrap a hashable value, caching the `hash` function result.

hashedHash :: Hashed a -> Int #

`hash` has `Eq` requirement.

Since: 1.4.0.0

unhashed :: Hashed a -> a #

Unwrap hashed value.

mapHashed :: Hashable b => (a -> b) -> Hashed a -> Hashed b #

`Hashed` cannot be `Functor`

traverseHashed :: (Hashable b, Functor f) => (a -> f b) -> Hashed a -> f (Hashed b) #

`Hashed` cannot be `Traversable`