úÎhbb     NoneQCompile-time constant; True on LE, False on BE, and compile-time error otherwise.None 3;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. Exceptions are NOTE-ed in instance docs.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) hash = const . mixConstructor 0 2hash h = hash h . \b-> if b then (1::Word8) else 0The (now deprecated)  versionTags& field is ignored, and we follow the / instance which does not ignore trailing zeros. NOTEE: No promise of stability across runs or platforms. Implemented via !."NOTE=: no promise of consistency across platforms or GHC versions.#NOTE5: no promise of consistency across runs or platforms.$Hash 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.%eHere 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.&Lazy Text, hashed as big endian UTF-16.'Strict Text, hashed as big endian UTF-16.(%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 a0ÿ 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.1  (2 h64) b = 2 $ (h64 ``xor`` fromIntegral b) *  3  (4 h32) b = 4 $ (h32 ``xor`` fromIntegral b) *  j256478 9:;<=>?@ABCDEFGHIJKLMNBConstructor number. We recommend starting from 0 and incrementing.%Hash state value to mix our byte intoNew hash stateOPQRSTUVWXYZ[\]^_`abcdefg "#$%&'()*hijklmno+,-./013:256478 9:;<=>?@ABCDEFGHIJKLMNOPQRSTZ256478  9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg "#$%&'()*hijklmno+,-./013Nonepbytes remaining for a full mq#we'll accumulate this as we consumeQA 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.(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.rstuvwxpqyz{|rstuvwxpqyz{|None   }       !"#$%&'()*+,-./0123456789:8;:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvvwxyz{|}~€ hashabler-1.0Data.HashablerMachDepsData.Hashabler.InternalData.Hashabler.SipHash HashStatemix8mix16mix32mix64HashablehashHash128 hashWord128_0 hashWord128_1Hash64 hashWord64Hash32 hashWord32 fnvPrime32 fnvPrime64fnvOffsetBasis32fnvOffsetBasis64 hashFNV32 hashFNV64mixConstructorSipKey siphash64 siphash128 littleEndian $fHashable()$fHashableBool$fHashableVersionghc-prim GHC.ClassesEq$fHashableStableNamebaseSystem.Mem.StableNamehashStableName$fHashableTypeRep$fHashableThreadId$fHashableChar$fHashableByteArray$fHashableText$fHashableText0$fHashableShortByteString$fHashableByteString$fHashableByteString0$fHashableDouble$fHashableFloat$fHashableWord $fHashableInt$fHashableRatio$fHashableInteger$fHashStateFNV64FNV64$fHashStateFNV32FNV32fnv64fnv32 getThreadIdcoerceInt32Word32coerceInt64Word64 _byteSwap32 _byteSwap64bytes16bytes32bytes64 _bytes64_64 _bytes64_32words32 floatToWord doubleToWordcastViaSTArray _signBytemagnitudeAsWordmixSignificantMachWord64_hash32Integer _integerWordshash32BigNatByteArrayBytes_hash32_Int_64_hash32_Word_64 typeRepInt32hashByteStringhashText hashByteArray hashFoldl'hashLeftUnfolded$fHashable(,,,,,,,,,,,,,,)$fHashable(,,,,,,,,,,,,,)$fHashable(,,,,,,,,,,,,)$fHashable(,,,,,,,,,,,)$fHashable(,,,,,,,,,,)$fHashable(,,,,,,,,,)$fHashable(,,,,,,,,)$fHashable(,,,,,,,)$fHashable(,,,,,,)$fHashable(,,,,,)$fHashable(,,,,)$fHashable(,,,)$fHashable(,,) $fHashable(,)$fHashableEither$fHashableMaybe $fHashable[]$fHashableOrdering$fHashableUnique$fHashableWord64$fHashableWord32$fHashableWord16$fHashableWord8$fHashableInt64$fHashableInt32$fHashableInt16$fHashableInt8bytesRemaininginlenSipStatev0v1v2v3mPartrotlsipRoundsiphashForWord$fHashStateSipState