úÎIàDƒNone   Noneportable provisionaljohan.tibell@gmail.comNone3The class of types that can be generically hashed. :The class of types that can be converted to a hash value. <Return a hash value for the argument, using the given salt. The general contract of  is: : If a value is hashed using the same salt during distinct 7 runs of an application, the result must remain the A same. (This is necessary to make it possible to store hashes  on persistent media.) * If two values are equal according to the   method, then  applying the " method on each of the two values  must5 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  / method on each of the two values must produce ? distinct integer results. (Every programmer will be aware ? that producing distinct integer results for unequal values 7 will improve the performance of hashing-based data  structures.) =This method can be used to compute different hash values for 6 the same input by providing a different salt in each @ application of the method. This implies that any instance that  defines  must make use of the salt in its  implementation. !-A default salt used in the implementation of . ?To reduce the probability of hash collisions, the value of the @ default salt will vary from one program invocation to the next * unless this package is compiled with the  fixed-salt flag set. :Return a hash value for the argument. Defined in terms of   and a default salt. DAt application startup time, the default salt is initialized with a  new value from the system'%s cryptographic pseudo-random number * generator. This means that the result of  will vary from one  application run to the next. 9If you need hashes that do not vary from run to run, use  2 instead, and supply a salt of your choosing. (Be C aware that if you hash untrusted, uncontrolled input data using a ? fixed salt, you may expose your application to hash collision  attacks.) Transform a value into a  value, then hash the ) transformed value using the given salt. ?This is a useful shorthand in cases where a type can easily be 7 mapped to another type that is already an instance of .  Example:  data Foo = Foo | Bar  deriving (Enum)   instance Hashable Foo where ' hashWithSalt = hashUsing fromEnum "=Hash an integer of at most the native width supported by the  machine. #Hash a 64-bit integer. $EA value with bit pattern (01)* (or 5* in hexa), for any size of Int. M It is used as data constructor distinguisher. GHC computes its value during  compilation. %>Compute the hash of a ThreadId. For GHC, we happen to know a  trick to make this fast. &OCompute the hash of a TypeRep, in various GHC versions we can do this quickly. 6Compute a hash value for the content of this pointer. ?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 E segments of memory as if they were one contiguous segment, by using 2 the output of one hash as the salt for the next. -Compute a hash value for the content of this ', E beginning at the specified offset, using specified number of bytes.  Availability: GHC. -Compute a hash value for the content of this ', using  an initial salt. =This function can for example be used to hash non-contiguous E segments of memory as if they were one contiguous segment, by using 2 the output of one hash as the salt for the next. Availability: GHC. ?()*+,-./0!Transformation function. Salt. Value to transform. "#$%&pointer to the data to hash length, in bytes  hash value pointer to the data to hash length, in bytes salt  hash value 12345 data to hash offset, in bytes length, in bytes  hash value  data to hash offset, in bytes length, in bytes salt  hash value 6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW (=()*+,-./0!"#$%&123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW GHC >= 7.2 provisionalbos@serpentine.comNoneXYZ[\]^_`abcdefgh XYZ[\]^_`abcdefghportable provisionaljohan.tibell@gmail.comNonei      !"#$%&'()*+,$-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^__`abcdefghijklmnohashable-1.2.0.2 Data.HashableData.Hashable.SipHashData.Hashable.RandomSourceData.Hashable.ClassData.Hashable.GenericHashable hashWithSalthash hashUsinghashPtrhashPtrWithSalt hashByteArrayhashByteArrayWithSaltSipv0v1v2v3LE64fromLE64 fromWord64 initStatesipRound fullBlock runRounds lastBlockfinalizehashByteStringpeekBytepeekLE64 $fShowLE64c_getRandomBytesgetRandomBytesgetRandomBytes_ GHashableghc-prim GHC.Classes== defaultSalt hashNativehash64 distinguisher hashThreadId hashTypeRepGHC.Prim ByteArray# ghashWithSaltc_siphash24_chunkc_siphash_initc_wang64c_wang32c_siphash24_chunk_offsetc_siphash24_offset c_siphash24 getThreadIdk0hashLazyByteStringWithSalthashLazyTextWithSaltfromSaltk1$fHashableTypeRep$fHashableThreadId$fHashableText$fHashableText0$fHashableByteString$fHashableByteString0 $fHashable[]$fHashableStableName$fHashable(,,,,,,)$fHashable(,,,,,)$fHashable(,,,,)$fHashable(,,,)$fHashable(,,) $fHashable(,)$fHashableEither$fHashableMaybe$fHashableDouble$fHashableFloat$fHashableRatio$fHashableInteger$fHashableChar$fHashableOrdering$fHashableBool $fHashable()$fHashableWord64$fHashableWord32$fHashableWord16$fHashableWord8$fHashableWord$fHashableInt64$fHashableInt32$fHashableInt16$fHashableInt8 $fHashableIntTaggedunTaggedSumSizesumSizeGSumhashSum $fSumSizeM1 $fSumSize:+:$fGSumM1 $fGSum:+:$fGHashable:+: $fGHashableK1 $fGHashableM1$fGHashable:*: $fGHashableU1 $fGHashableV1