y%      !"#$None%QCompile-time constant; True on LE, False on BE, and compile-time error otherwise.%%%None +:BDIT(jTypes whose hashes can be compared across platforms. This is somewhat like a limited, but cross-platform &.Instances are expected to be universally-unique, and should be generated randomly. Type parameters can be hashed together using , like: ninstance (StableHashable b) => StableHashable (A b) where typeHash = mixType (TypeHash 530184177609460980)When   instances change, the ` must be changed to a new random value. This lets us "version" a set of hashes; if we store a ' along with a set of hashes in program A , in program B/ we can compare the stored value with our own 0 and verify that hashes we generate in program B can be meaningfully compared.Note, obviously this doesn't ensure that values were hashed with the same hashing algorithm, and you should come up with your own means to serialize that information if you need to.#A value that uniquely identifies a ? type. This serves to both version a type with respect to its  > instance, and distinguish types from each other (similar to '7) across program runs, platforms and library versions.eA class for defining how a hash function consumes input data. Bytes are fed to these methods in our  O instances, which promise to call these methods in a platform-independent way. Instances of  only need to define , but may additionally handle mix-ing in larger word chunks for performance reasons. For instance a hash function which operates on four bytes at a time might make use of , and perhaps in  pad with three additional 0s.Endianness is normalized in  Y instances, so these mix methods can expect to receive identical words across platforms.Mix in one byte.&Mix in a 2-byte word. Defaults to two * on bytes from most to least significant.'Mix in a 4-byte word. Defaults to four * on bytes from most to least significant. &Mix in a 8-byte word. Defaults to two 2 on 32-byte words from most to least significant. {A class of types that can be converted into a hash value. We expect all instances to display "good" hashing properties (wrLt avalanche, bit independence, etc.) when passed to an ideal hash function.We try to ensure that bytes are extracted from values in a way that is portable across architectures (where possible), and straightforward to replicate on other platforms and in other languages. Portable instances are also instances of ", and non-portable instances are NOTE"-ed in instance docs here as well.See the section  #principled"Defining Hashable instances"/ for details of what we expect from instances. Add the bytes from the second argument into the hash, producing a new hash value. This is essentially a left fold of the methods of & over individual bytes extracted from a.For some instances of , this method might be a complete hashing algorithm, or might comprise the core of a hashing algorithm (perhaps with some final mixing), or might do something completely apart from hashing (e.g. simply cons bytes into a list for debugging).5Implementations must ensure that, for the same data:  Word16/32/64& arguments passed into the methods of , and...the choice of mix function itself......are consistent across architectures of different word size and endianness. For example do not define an instance which conditionally implements   only on 64-bit architectures.BHash a value using the standard spec-prescribed 32-bit seed value.  hashFNV32 =  . fnv32 .    hHash a value using the standard spec-prescribed 64-bit seed value. This may be slow on 32-bit machines.  hashFNV64 =  . fnv64 .     (mixConstructor n h = h `mix8` (0xFF - n)A helper for implementing  by (9-ing type parameters with a new random hash value. E.g.:  instance (StableHashable a, StableHashable b) => StableHashable (a, b) where typeHash = mixType (mixType (TypeHash 12071780118071628513)) __ a new random value for (,) ____ mix in the type hash for a1 __ mix in the type hash for b )mThe value here depends on whether we're on a 32 or 64-bit platform. See also the instance documentation for  .*mThe value here depends on whether we're on a 32 or 64-bit platform. See also the instance documentation for  .+ hash = const . mixConstructor 0, 2hash h = hash h . \b-> if b then (1::Word8) else 0-NOTEE: No promise of stability across runs or platforms. Implemented via ../The (now deprecated)  versionTags& field is ignored, and we follow the 0/ instance which does not ignore trailing zeros.1NOTEE: No promise of stability across runs or platforms. Implemented via 2.3NOTE=: no promise of consistency across platforms or GHC versions.4NOTE5: no promise of consistency across runs or platforms.5Hash a Char as big endian UTF-16. Note that Char permits values in the reserved unicode range U+D800 to U+DFFF; these Char values are added to the hash just as if they were valid 16-bit characters.6eHere we hash each byte of the array in turn. If using this to hash some data stored internally as a  ByteArray#, be aware that depending on the size and alignment requirements of that data, as well as the endianness of your machine, this might result in different hash values across different architectures.7Lazy Text, hashed as big endian UTF-16.8Strict Text, hashed as big endian UTF-16.9%Exposed only in bytestring >= v0.10.4:Lazy  ByteString;Strict  ByteString<fHash a Double as IEEE 754 double-precision format bytes. This is terribly slow; direct complaints to /http://hackage.haskell.org/trac/ghc/ticket/4092=eHash a Float as IEEE 754 single-precision format bytes. This is terribly slow; direct complaints to /http://hackage.haskell.org/trac/ghc/ticket/4092>NOTE: WordF has platform-dependent size. When hashing on 64-bit machines if the Word value to be hashed falls in the 32-bit Word range, we first cast it to a Word32. This should help ensure that programs that are correct across architectures will also produce the same hash values.?NOTE: IntF has platform-dependent size. When hashing on 64-bit machines if the Int value to be hashed falls in the 32-bit Int range, we first cast it to an Int32. This should help ensure that programs that are correct across architectures will also produce the same hash values.@ 4hash s a = s `hash` numerator a `hash` denominator aA hash _ _ = absurdExposed only in GHC 7.10BThe Natural's value is represented in 32-bit chunks (at least one, for zero; but no more than necessary), then bytes are added to the hash from most to least significant (including all initial padding 0s). Finally  0' is called on the resulting hash value.Exposed only in GHC 7.10CThe BigNat's value is represented in 32-bit chunks (at least one, for zero; but no more than necessary), then bytes are added to the hash from most to least significant (including all initial padding 0s). Finally  0' is called on the resulting hash value.Exposed only in GHC 7.10.D Arbitrary-precision integers are hashed as follows: the magnitude is represented with 32-bit chunks (at least one, for zero; but no more than necessary), then bytes are added to the hash from most to least significant (including all initial padding 0s). Finally . is called on the resulting hash value, with  (1::Word8) if the Integer was negative, otherwise with 0.E  (F h64) b = F $ (h64 `(` fromIntegral b) *  G  (H h32) b = H $ (h32 `(` fromIntegral b) *  FIJHKL MNOPQRSTUVWXYZ[\]^_`abcBConstructor number. We recommend starting from 0 and incrementing.%Hash state value to mix our byte intoNew hash statedefghijklmnopqrstuvwxyz{|}~)*+,-/13456789:;<=>?@ABCDEGCFIJHKL MNOPQRSTUVWXYZ[\]^_`abcdefghiFIJHKL   MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)*+,-/13456789:;<=>?@ABCDEGNone!"bytes remaining for a full m#we'll accumulate this as we consume QA 128-bit secret key. This should be generated randomly and must be kept secret."(An implementation of 64-bit siphash-2-4.This function is fast on 64-bit machines, and provides very good hashing properties and protection against hash flooding attacks.kThis uses the "standard" recommended parameters of 2 and 4 rounds, recommended by the original paper, but #, may be a faster and equally secure choice.#(An implementation of 64-bit siphash-1-3.9This is somewhat faster than siphash-2-4 (implemented in "), while the authors claim it should still offer good protection against known attacks. This is currently the standard hash function used in the Rust language.$)An implementation of 128-bit siphash-2-4.This function is fast on 64-bit machines, and provides very good hashing properties and protection against hash flooding attacks. !"#$ !"#$  !"#$None%  !"#$%  !"#$        !!"#$%&'(&')&*+,-./0&1234567&89:;<=>?@ABCDEFGHIJKLMNOMPOQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&hashabler-1.3.0-Ju5VH1wxs7eLOpP8l5xDTVData.HashablerMachDepsData.Hashabler.InternalData.Hashabler.SipHashStableHashabletypeHashTypeHash typeHashWord HashStatemix8mix16mix32mix64HashablehashHash128 hashWord128_0 hashWord128_1Hash64 hashWord64Hash32 hashWord32 fnvPrime32 fnvPrime64fnvOffsetBasis32fnvOffsetBasis64 hashFNV32 hashFNV64mixConstructormixType typeHashOftypeHashOfProxySipKey siphash64 siphash64_1_3 siphash128 littleEndianbaseData.Typeable.InternalTypeableTypeRep Data.Bitsxor$fStableHashableWord$fStableHashableInt $fHashable()$fHashableBool$fHashableUnique Data.Unique hashUnique$fHashableVersionghc-prim GHC.ClassesEq$fHashableStableNameSystem.Mem.StableNamehashStableName$fHashableTypeRep$fHashableThreadId$fHashableChar$fHashableByteArray$fHashableText$fHashableText0$fHashableShortByteString$fHashableByteString$fHashableByteString0$fHashableDouble$fHashableFloat$fHashableWord $fHashableInt$fHashableRatio$fHashableVoid$fHashableNatural$fHashableBigNat$fHashableInteger$fHashStateFNV64FNV64$fHashStateFNV32FNV32fnv64fnv32 getThreadIdcoerceInt32Word32coerceInt64Word64 _byteSwap32 _byteSwap64bytes16bytes32bytes64 _bytes64_64 _bytes64_32words32 floatToWord doubleToWordcastViaSTArray _signBytemagnitudeAsWordmixSignificantMachWord64_hash32Integer _integerWordshash32BigNatByteshash32BigNatByteArrayBytes_hash32_Int_64_hash32_Word_64 typeRepInt32hashByteStringhashText hashByteArray hashFoldl'hashLeftUnfolded $fStableHashable(,,,,,,,,,,,,,,)$fStableHashable(,,,,,,,,,,,,,)$fStableHashable(,,,,,,,,,,,,)$fStableHashable(,,,,,,,,,,,)$fStableHashable(,,,,,,,,,,)$fStableHashable(,,,,,,,,,)$fStableHashable(,,,,,,,,)$fStableHashable(,,,,,,,)$fStableHashable(,,,,,,)$fStableHashable(,,,,,)$fStableHashable(,,,,)$fStableHashable(,,,)$fStableHashable(,,)$fStableHashable(,)$fStableHashable()$fStableHashableEither$fStableHashableMaybe$fStableHashable[]$fStableHashableOrdering$fStableHashableBool$fStableHashableVersion$fStableHashableChar$fStableHashableByteArray$fStableHashableText$fStableHashableText0$fStableHashableShortByteString$fStableHashableByteString$fStableHashableByteString0$fStableHashableWord64$fStableHashableWord32$fStableHashableWord16$fStableHashableWord8$fStableHashableInt64$fStableHashableInt32$fStableHashableInt16$fStableHashableInt8$fStableHashableDouble$fStableHashableFloat$fStableHashableRatio$fStableHashableVoid$fStableHashableNatural$fStableHashableBigNat$fStableHashableInteger$fHashable(,,,,,,,,,,,,,,)$fHashable(,,,,,,,,,,,,,)$fHashable(,,,,,,,,,,,,)$fHashable(,,,,,,,,,,,)$fHashable(,,,,,,,,,,)$fHashable(,,,,,,,,,)$fHashable(,,,,,,,,)$fHashable(,,,,,,,)$fHashable(,,,,,,)$fHashable(,,,,,)$fHashable(,,,,)$fHashable(,,,)$fHashable(,,) $fHashable(,)$fHashableEither$fHashableMaybe $fHashable[]$fHashableOrdering$fHashableWord64$fHashableWord32$fHashableWord16$fHashableWord8$fHashableInt64$fHashableInt32$fHashableInt16$fHashableInt8bytesRemaininginlenSip_1Sip_2SipStatev0v1v2v3mPartrotlsipRound sipRoundssiphashForWord$fHashStateSip_1$fHashStateSip_2