úÎWRB     NoneQCompile-time constant; True on LE, False on BE, and compile-time error otherwise.None 3;˜A class for hash functions which take a running hash value and incrementally mix in bytes (or chunks of bytes). 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 additional 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.Hash in one byte.#Hash in a 2-byte word. Defaults to ) on bytes from most to least significant.#Hash in a 4-byte word. Defaults to ) on bytes 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 (wr>t avalanche, bit independence, etc.) when passed to a "good"  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). The FNV-1a hash algorithm. See *http://www.isthe.com/chongo/tech/comp/fnv/«Hash a value using the standard spec-prescribed 32-bit seed value. For relevant instances of primitive types, we expect this to produce values following the FNV1a spec.  hashFNV32 =   «Hash a value using the standard spec-prescribed 64-bit seed value. For relevant instances of primitive types, we expect this to produce values following the FNV1a spec.$This may be slow on 32-bit machines.  hashFNV64 =    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 a(ÿ 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.)  ( h64) b =  $ (h64 ``xor`` fromIntegral b) *   *  (  h32) b =   $ (h32 ``xor`` fromIntegral b) *   Z +,-./ 0123456789:;<=>?@ABBConstructor number. We recommend starting from 0 and incrementing.Hash value to mix our byte intoNew hash valueCDEFGHIJKLMNOPQRST !"UVWXYZ[\#$%&'()*   R  +,-./ 0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST !"UVWXYZ[\#$%&'()*]        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abhashabler-0.1.0.2Data.HashablerMachDepsHashmix8mix16mix32HashablehashFNV64fnv64FNV32fnv32 fnvPrime32 fnvPrime64fnvOffsetBasis32fnvOffsetBasis64 hashFNV32 hashFNV64mixConstructor 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 $fHashFNV64 $fHashFNV32 getThreadIdcoerceInt32Word32coerceInt64Word64 _byteSwap32 _byteSwap64bytes16bytes32bytes64 _bytes64_64 _bytes64_32words32 bytesFloat bytesDouble floatToWord doubleToWordcastViaSTArray _signBytemagnitudeAsWordmixSignificantMachWord64_hash32Integer _integerWordshash32BigNatByteArrayBytes_hash32_Int_64_hash32_Word_64 typeRepInt32hashBytesUnrolled64hashText hashByteArray hashFoldl'hashLeftUnfolded$fHashable(,,,,,,,)$fHashable(,,,,,,)$fHashable(,,,,,)$fHashable(,,,,)$fHashable(,,,)$fHashable(,,) $fHashable(,)$fHashableEither$fHashableMaybe $fHashable[]$fHashableOrdering$fHashableUnique$fHashableWord64$fHashableWord32$fHashableWord16$fHashableWord8$fHashableInt64$fHashableInt32$fHashableInt16$fHashableInt8