A class for types that can be converted to a hash value http://github.com/tibbe/hashable

Version on this page:
LTS Haskell 11.0:
Stackage Nightly 2018-03-17:
Latest on Hackage:

See all snapshots hashable appears in

Maintained by johan.tibell@gmail.com

Module documentation for

The hashable package

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.



  • Add Hashable and Hashable1 instances for Complex

  • Fix undefined behavior in hashable_fn_hash() implementation due to signed integer overflow (#152)

  • Mark Data.Hashable.Lifted as Trustworthy (re SafeHaskell)

  • Support GHC 8.4


  • Use typeRepFingerprint from Type.Reflection.Unsafe

  • Bump minimum version of base to 4.4.


  • Add support for type-indexed Typeable.

  • Rework the Generic hashable for sums.


  • Add Hashable1 and Hashable2

  • Add instances for: Eq1, Ord1, Show1, Ptr, FunPtr, IntPtr, WordPtr

  • Add Hashed type for caching the hash function result.


  • Add instances for: Unique, Version, Fixed, NonEmpty, Min, Max, Arg, First, Last, WrappedMonoid, Option

  • Support GHC 8.0


  • Support integer-simple.


  • Add support for GHC 7.10 typeRepFingerprint


  • Added support for random 1.1.*.


  • Silence integer literal overflow warning

  • Add support for GHC 7.10 integer-gmp2 & Natural

  • Add instance for Data.Void

  • Make the SSE .cabal flags manual

  • Add an upper bound on bytestring


  • Add instances for Data.ByteString.Short

  • Use a 32-bit default salt on 32-bit archs.


  • Revert instances to their 1.1 implementations to regain the performance we had then.

  • Remove use of random salt altogether. Without using SipHash the benefit is unclear (i.e. collision attacks still work) and the complexity is no longer worth it.

  • Documentation improvements.


  • Fix for GHC 7.0.


  • Stop using SipHash. The current implementation still has segfault causing bugs that we won't be able to fix soon.

  • Stop using Wang hash. It degrades performance of fixed-size integer hashing too much.


  • Fix linking issue when SSE was disabled.

  • Hash small signed Integers correctly.


  • Add flags to control usage of SSE.


  • Fix another segfault caused by SSE2 code.


  • More portability fixes.

  • Force stack alignment to 16 bytes everywhere. Fixes a segfault.

  • Fix bug where code relied on rewrite rules firing for correctness.


  • Update docs to match code.

  • Work around bug in GHCi runtime linker, which never call static initializers.


  • Make building of SSE 4.1 code conditional, as it doesn't work on all platforms.

  • Use a fixed salt, but allow random salting. Random salting by default broke people's code.


  • Work around ghci linker bug on Windows.


  • Fix performance bug in SSE implementation of SipHash.

  • Fix segfault due to incorrect stack alignment on Windows.


  • Switch string hashing from FNV-1 to SipHash, in an effort to prevent collision attacks.

  • Switch fixed-size integer hashing to Wang hash.

  • The default salt now switched on every program run, in an effort to prevent collision attacks.

  • Move hash method out of Hashable type class.

  • Add support for generic instance deriving.

  • Add instance for Ordering.


  • Bug fix for bytestring < 0.10.0.


  • Switch string hashing from Bernstein to FNV-1

  • Faster instance for Integer.

  • Update dependency on base, ghc-prim

  • Now works with GHC 7.6.


  • Add instance for TypeRep.

  • Update dependency on test-framework.


  • Bug fix for GHC 7.4


  • Update dependency on test-framework.

  • Improve documentation of combine.


  • Add instances for Interger, Ratio, Float, Double, and StableName.

  • Fix hash collision issues for lists and tuples when using a user-specified salt.


  • Improved instances for tuples and lists.

  • Add instances for StableName, Float, Double, Integer, and Ratio.


  • Add hashWithSalt, which allows the user to create different hash values for the same input by providing different seeds. This is useful for application like Cuckoo hashing which need a family of hash functions.

  • Fix a bug in the Hashable instance for Int64/Word64 on 32-bit platforms.

  • Improved resilience to leading zero in the input being hashed.


  • Add instance for: strict and lazy Texts, ThreadId

  • Add hashPtrWithSalt and hashByteArrayWithSalt.

  • Faster ByteArray# hashing.

  • Fix a signedness bug that affected ByteString.

  • Fix ByteString hashing to work correctly on both 32 and 64-bit platforms.


  • Fix bug in Hashable instance for lazy ByteStrings where differences in the internal structure of the ByteString could cause different hash values for ByteStrings that are equal according to ==.


  • Add two helpers for creating Hashable instances: hashPtr and hashByteArray.


  • Separate Hashable class to its own package from hashmap
comments powered byDisqus