diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,11 @@ # Revision history for mono-hash +## 0.1.1.0 -- 2026-10-29 + +* Add anti-instances for `ByteFoldable` w.r.t. `Int`, `Word`, `Ptr`, `FunPtr`, `IntPtr`, `WordPtr`, `Integer`, and `Natural`. +* Add `ByteFoldable` instances for `Bool`, `Float`, `Double`, `Int128`, and `Int256`. +* Raise the `wide-word` lower bound to `0.1.9.0`. + ## 0.1.0.2 -- 2026-10-27 * Internal: replace the hand-rolled `byteSwap32`/`byteSwap64` from `Data.Hash.Mono.Internal` with the equivalents already provided by base in `Data.Word`. diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -3,18 +3,11 @@ [![Hackage](https://img.shields.io/hackage/v/mono-hash.svg)](https://hackage.haskell.org/package/mono-hash) [![Haskell-CI](https://github.com/phagenlocher/mono-hash/actions/workflows/haskell-ci.yml/badge.svg?branch=main)](https://github.com/phagenlocher/mono-hash/actions/workflows/haskell-ci.yml) -Hashing for monomorphic containers: FNV-1/FNV-1a, SipHash, and HalfSipHash for -any [`MonoFoldable`](https://hackage.haskell.org/package/mono-traversable/docs/Data-MonoTraversable.html#t:MonoFoldable), -including `ByteString`, lazy `ByteString`, `Text`, `String`, and lists of -fixed-width words. +Hashing for monomorphic containers: FNV-1/FNV-1a, SipHash, and HalfSipHash for any [`MonoFoldable`](https://hackage.haskell.org/package/mono-traversable/docs/Data-MonoTraversable.html#t:MonoFoldable), including `ByteString`, lazy `ByteString`, `Text`, `String`, and lists of fixed-width words. ## Motivation -This library hashes data in monomorphic containers irrespective of their -structure. Because only the concatenated element bytes matter, changing the -container while keeping the same bytes leaves the hash unchanged. Below, the -`ByteString` and `Vector Word64` hold exactly the same bytes; each formatted -line of the `ByteString` is one `Word64` in the vector: +This library hashes data in monomorphic containers irrespective of their structure. Because only the concatenated element bytes matter, changing the container while keeping the same bytes leaves the hash unchanged. Below, the `ByteString` and `Vector Word64` hold exactly the same bytes; each formatted line of the `ByteString` is one `Word64` in the vector: ```haskell {-# LANGUAGE NumericUnderscores #-} @@ -53,9 +46,7 @@ -- 0x6d003ad777121d05 ``` -The same works for any `MonoFoldable`. `Data.Tree.Tree` from `containers` -already has a `MonoFoldable` instance in `mono-traversable`, and it folds in -pre-order: +The same works for any `MonoFoldable`. `Data.Tree.Tree` from `containers` already has a `MonoFoldable` instance in `mono-traversable`, and it folds in pre-order: ```haskell -- Pre-order traversal: the same 24 bytes as six Word32s. @@ -108,23 +99,13 @@ ## Encoding and byte order -Hashing is defined over the concatenation of the elements' byte encodings. -By design, the encoding is not type-tagged, so `[0x01, 0x02 :: Word8]` and -`[0x0102 :: Word16]` hash the same bytes. +Hashing is defined over the concatenation of the elements' byte encodings. By design, the encoding is not type-tagged, so `[0x01, 0x02 :: Word8]` and `[0x0102 :: Word16]` hash the same bytes. -`Word8` and `Int8` contribute one byte. Wider integers contribute -their bit pattern most significant byte first; signed integers use two's -complement. `Char` contributes UTF-8; a lone surrogate, which `String` can -contain but UTF-8 cannot represent, uses the 3-byte -[WTF-8](https://wtf-8.codeberg.page) form. `String` and `Text` are -hashed character by character, while `ByteString` contributes its raw bytes. -The library provides instances for `Word8`, `Word16`, `Word32`, `Word64`, -`Word128`, `Word256`, `Int8`, `Int16`, `Int32`, `Int64`, and `Char`. +`Word8` and `Int8` contribute one byte. Wider integers contribute their bit pattern most significant byte first; signed integers use two's complement. `Bool` contributes one byte, `0x00` or `0x01`. `Float` and `Double` contribute their raw IEEE-754 bit pattern, four or eight bytes most significant first, so `0.0` and `-0.0` compare equal yet hash differently. `Char` contributes UTF-8; a lone surrogate, which `String` can contain but UTF-8 cannot represent, uses the 3-byte [WTF-8](https://wtf-8.codeberg.page) form. `String` and `Text` are hashed character by character, while `ByteString` contributes its raw bytes. ## Custom element types -Give the element type a `ByteFoldable` instance to hash containers of your -own type: +Give the element type a `ByteFoldable` instance to hash containers of your own type: ```haskell {-# LANGUAGE TypeApplications #-} @@ -142,13 +123,9 @@ fnv1a @Word64 [Rgb 0x12 0x34 0x56] ``` -The bytes an instance emits are the bytes hashed, so changing an instance -changes every hash of containers holding that element type. +The bytes an instance emits are the bytes hashed, so changing an instance changes every hash of containers holding that element type. -Because the encoding is untagged (see above), two element types with the same -underlying bytes hash alike. An instance can prevent this by folding a tag -byte of its own. Here `Rgb` and `Hsl` both hold three `Word8`, yet `0x01` and -`0x02` keep their encodings apart: +Because the encoding is untagged (see above), two element types with the same underlying bytes hash alike. An instance can prevent this by folding a tag byte of its own. Here `Rgb` and `Hsl` both hold three `Word8`, yet `0x01` and `0x02` keep their encodings apart: ```haskell {-# LANGUAGE TypeApplications #-} @@ -174,16 +151,11 @@ -- 0x292dee90a2ab967f ``` -Tags are a convention of the instance and are worth it when distinct types with -overlapping byte layouts would otherwise collide, such as values in a sum -type or records that share a shape. +Tags are a convention of the instance and are worth it when distinct types with overlapping byte layouts would otherwise collide, such as values in a sum type or records that share a shape. ## Formatting and linting -Sources are formatted with [fourmolu](https://github.com/fourmolu/fourmolu) and -linted with [hlint](https://github.com/ndmitchell/hlint). CI checks both, using -the versions pinned in `.github/workflows/ci.yml`, so run them before opening -a pull request: +Sources are formatted with [fourmolu](https://github.com/fourmolu/fourmolu) and linted with [hlint](https://github.com/ndmitchell/hlint). CI checks both, using the versions pinned in `.github/workflows/ci.yml`, so run them before opening a pull request: ```console fourmolu --mode inplace $(git ls-files '*.hs') diff --git a/mono-hash.cabal b/mono-hash.cabal --- a/mono-hash.cabal +++ b/mono-hash.cabal @@ -1,6 +1,6 @@ cabal-version: 3.0 name: mono-hash -version: 0.1.0.2 +version: 0.1.1.0 synopsis: Hashing for monomorphic containers. description: FNV, SipHash, and HalfSipHash hashing for monomorphic containers. @@ -39,7 +39,7 @@ build-depends: base >=4.14.3.0 && <5, mono-traversable >=1.0.21 && <1.1, - wide-word >=0.1.7 && <0.2 + wide-word >=0.1.9.0 && <0.2 hs-source-dirs: src @@ -76,7 +76,7 @@ tasty >=1.4 && <1.6, tasty-hunit >=0.10 && <0.11, text >=1.2 && <2.2, - wide-word >=0.1.7 && <0.2, + wide-word >=0.1.9.0 && <0.2, benchmark mono-hash-bench type: exitcode-stdio-1.0 @@ -96,4 +96,4 @@ deepseq >=1.4 && <1.6, mono-hash, text >=1.2 && <2.2, - wide-word >=0.1.7 && <0.2, + wide-word >=0.1.9.0 && <0.2, diff --git a/src/Data/Hash/Mono/Internal/ByteFoldable.hs b/src/Data/Hash/Mono/Internal/ByteFoldable.hs --- a/src/Data/Hash/Mono/Internal/ByteFoldable.hs +++ b/src/Data/Hash/Mono/Internal/ByteFoldable.hs @@ -1,4 +1,10 @@ +{-# LANGUAGE CPP #-} +{-# LANGUAGE DataKinds #-} {-# LANGUAGE InstanceSigs #-} +#if !MIN_VERSION_base(4,19,0) +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} +#endif -- | Byte encoding for types. module Data.Hash.Mono.Internal.ByteFoldable ( @@ -9,10 +15,32 @@ import Data.Bits (Bits (unsafeShiftR, (.&.))) import Data.Char qualified as Char import Data.Int (Int16, Int32, Int64, Int8) +#if !MIN_VERSION_base(4,19,0) +import Data.Kind (Constraint) +#endif +import Data.WideWord.Int128 (Int128 (..)) +import Data.WideWord.Int256 (Int256 (..)) import Data.WideWord.Word128 (Word128 (..)) import Data.WideWord.Word256 (Word256 (..)) import Data.Word (Word16, Word32, Word64, Word8) +import Foreign.Ptr (FunPtr, IntPtr, Ptr, WordPtr) +import GHC.Float (castDoubleToWord64, castFloatToWord32) +#if MIN_VERSION_base(4,19,0) +import GHC.TypeError (ErrorMessage (Text), Unsatisfiable) +#else +import GHC.TypeLits (ErrorMessage (Text), TypeError) +#endif +import Numeric.Natural (Natural) +#if MIN_VERSION_base(4,19,0) +type AntiInstance msg = Unsatisfiable msg +#else +-- A type synonym here would make older GHC report the TypeError eagerly at +-- the synonym declaration; a type family only expands it at the use site. +type family AntiInstance msg :: Constraint where + AntiInstance msg = TypeError msg +#endif + {- | Types with a fixed byte encoding. An instance must define a fixed order for the bytes to be folded. @@ -61,6 +89,11 @@ n = Char.ord c {-# INLINE foldlBytes #-} +-- | Encoded as one byte, @0x00@ for 'False' and @0x01@ for 'True'. +instance ByteFoldable Bool where + foldlBytes f z b = f z (if b then 0x01 else 0x00) + {-# INLINE foldlBytes #-} + instance ByteFoldable Word8 where foldlBytes f = f {-# INLINE foldlBytes #-} @@ -139,12 +172,42 @@ foldlBytes f z i = foldlBytes f z (fromIntegral i :: Word64) {-# INLINE foldlBytes #-} +{- | Encoded as its raw IEEE-754 single-precision bit pattern, four bytes, most +significant first, the same bytes as the corresponding 'Word32'. + +The bits are reinterpreted rather than converted, and are never normalized: +@0.0@ and @-0.0@ encode differently, and NaN payloads (including the sign bit) +are preserved verbatim. +-} +instance ByteFoldable Float where + foldlBytes f z x = foldlBytes f z (castFloatToWord32 x) + {-# INLINE foldlBytes #-} + +{- | Encoded as its raw IEEE-754 double-precision bit pattern, eight bytes, most +significant first, the same bytes as the corresponding 'Word64'. + +The bits are reinterpreted rather than converted, and are never normalized: +@0.0@ and @-0.0@ encode differently, and NaN payloads (including the sign bit) +are preserved verbatim. +-} +instance ByteFoldable Double where + foldlBytes f z x = foldlBytes f z (castDoubleToWord64 x) + {-# INLINE foldlBytes #-} + -- | Encoded as sixteen bytes, most significant first. instance ByteFoldable Word128 where foldlBytes f z w = foldlBytes f (foldlBytes f z (word128Hi64 w)) (word128Lo64 w) {-# INLINE foldlBytes #-} +{- | Encoded as its two's-complement bit pattern, the same bytes as the +corresponding 'Word128'. +-} +instance ByteFoldable Int128 where + foldlBytes f z i = + foldlBytes f (foldlBytes f z (int128Hi64 i)) (int128Lo64 i) + {-# INLINE foldlBytes #-} + -- | Encoded as thirty-two bytes, most significant first. instance ByteFoldable Word256 where foldlBytes f z w = @@ -161,3 +224,149 @@ ) (word256lo w) {-# INLINE foldlBytes #-} + +{- | Encoded as its two's-complement bit pattern, the same bytes as the +corresponding 'Word256'. +-} +instance ByteFoldable Int256 where + foldlBytes f z i = + foldlBytes + f + ( foldlBytes + f + ( foldlBytes + f + (foldlBytes f z (int256hi i)) + (int256m1 i) + ) + (int256m0 i) + ) + (int256lo i) + {-# INLINE foldlBytes #-} + +{- | Anti-instance: 'Int' is as wide as a machine word, so its byte encoding +would differ between platforms. Use a fixed-width type such as 'Int32' or +'Int64' instead. +-} +instance + ( AntiInstance + ( 'Text + "ByteFoldable for Int cannot exist: Int is platform-dependent; use Int32 or Int64 instead." + ) + ) => + ByteFoldable Int +#if !MIN_VERSION_base(4,19,0) + where + foldlBytes _ _ _ = error "ByteFoldable Int: unreachable" +#endif + +{- | Anti-instance: 'Word' is as wide as a machine word, so its byte encoding +would differ between platforms. Use a fixed-width type such as 'Word32' or +'Word64' instead. +-} +instance + ( AntiInstance + ( 'Text + "ByteFoldable for Word cannot exist: Word is platform-dependent; use Word32 or Word64 instead." + ) + ) => + ByteFoldable Word +#if !MIN_VERSION_base(4,19,0) + where + foldlBytes _ _ _ = error "ByteFoldable Word: unreachable" +#endif + +{- | Anti-instance: 'Integer' is arbitrary-precision and has no fixed width, +so it has no fixed byte encoding. Use a fixed-width integer type instead. +-} +instance + ( AntiInstance + ( 'Text + "ByteFoldable for Integer cannot exist: Integer is arbitrary-precision; use a fixed-width integer type instead." + ) + ) => + ByteFoldable Integer +#if !MIN_VERSION_base(4,19,0) + where + foldlBytes _ _ _ = error "ByteFoldable Integer: unreachable" +#endif + +{- | Anti-instance: 'Natural' is arbitrary-precision and has no fixed width, +so it has no fixed byte encoding. Use a fixed-width unsigned integer type +instead. +-} +instance + ( AntiInstance + ( 'Text + "ByteFoldable for Natural cannot exist: Natural is arbitrary-precision; use a fixed-width unsigned integer type instead." + ) + ) => + ByteFoldable Natural +#if !MIN_VERSION_base(4,19,0) + where + foldlBytes _ _ _ = error "ByteFoldable Natural: unreachable" +#endif + +{- | Anti-instance: 'IntPtr' is as wide as a machine word, so its byte encoding +would differ between platforms. Convert it to a fixed-width type such as +'Int32' or 'Int64' instead. +-} +instance + ( AntiInstance + ( 'Text + "ByteFoldable for IntPtr cannot exist: IntPtr is platform-dependent; use Int32 or Int64 instead." + ) + ) => + ByteFoldable IntPtr +#if !MIN_VERSION_base(4,19,0) + where + foldlBytes _ _ _ = error "ByteFoldable IntPtr: unreachable" +#endif + +{- | Anti-instance: 'WordPtr' is as wide as a machine word, so its byte encoding +would differ between platforms. Convert it to a fixed-width type such as +'Word32' or 'Word64' instead. +-} +instance + ( AntiInstance + ( 'Text + "ByteFoldable for WordPtr cannot exist: WordPtr is platform-dependent; use Word32 or Word64 instead." + ) + ) => + ByteFoldable WordPtr +#if !MIN_VERSION_base(4,19,0) + where + foldlBytes _ _ _ = error "ByteFoldable WordPtr: unreachable" +#endif + +{- | Anti-instance: 'Ptr' is as wide as a machine word, and a pointer value is +not stable across processes. Convert it to a fixed-width type such as 'Word32' +or 'Word64' instead. +-} +instance + ( AntiInstance + ( 'Text + "ByteFoldable for Ptr cannot exist: pointers are platform-dependent and not stable across processes; convert to Word32 or Word64 instead." + ) + ) => + ByteFoldable (Ptr a) +#if !MIN_VERSION_base(4,19,0) + where + foldlBytes _ _ _ = error "ByteFoldable Ptr: unreachable" +#endif + +{- | Anti-instance: 'FunPtr' is as wide as a machine word, and a function +pointer value is not stable across processes. Convert it to a fixed-width type +such as 'Word32' or 'Word64' instead. +-} +instance + ( AntiInstance + ( 'Text + "ByteFoldable for FunPtr cannot exist: function pointers are platform-dependent and not stable across processes; convert to Word32 or Word64 instead." + ) + ) => + ByteFoldable (FunPtr a) +#if !MIN_VERSION_base(4,19,0) + where + foldlBytes _ _ _ = error "ByteFoldable FunPtr: unreachable" +#endif diff --git a/test/Main.hs b/test/Main.hs --- a/test/Main.hs +++ b/test/Main.hs @@ -14,9 +14,12 @@ import Data.Text (Text) import qualified Data.Text as T import qualified Data.Text.Encoding as TE +import Data.WideWord.Int128 (Int128 (..)) +import Data.WideWord.Int256 (Int256 (..)) import Data.WideWord.Word128 (Word128) import Data.WideWord.Word256 (Word256) import Data.Word (Word16, Word32, Word64, Word8) +import GHC.Float (castDoubleToWord64, castFloatToWord32) import qualified Test.Data.ByteFoldable import qualified Test.Data.FNV import qualified Test.Data.HalfSipHash @@ -168,6 +171,80 @@ + (fromIntegral (0x4142434445464748 :: Word64) `shiftL` 64) + fromIntegral (0x5152535455565758 :: Word64) +-- | Positive value with distinct limbs. +int128Sample :: Int128 +int128Sample = Int128 0x0102030405060708 0x1112131415161718 + +-- | Negative value with distinct limbs, exercising sign extension. +int128Negative :: Int128 +int128Negative = Int128 0xffffffffffffff80 0x0102030405060708 + +-- | Positive value with distinct limbs. +int256Sample :: Int256 +int256Sample = + Int256 + 0x2122232425262728 + 0x3132333435363738 + 0x4142434445464748 + 0x5152535455565758 + +-- | Negative value with distinct limbs, exercising sign extension. +int256Negative :: Int256 +int256Negative = + Int256 + 0xffffffffffffffff + 0x2122232425262728 + 0x3132333435363738 + 0x4142434445464748 + +-- | The big-endian two's-complement bytes of @-1@, written out by hand. +int128MinusOneBytes :: BS.ByteString +int128MinusOneBytes = BS.pack (replicate 16 0xff) + +int256MinusOneBytes :: BS.ByteString +int256MinusOneBytes = BS.pack (replicate 32 0xff) + +-- | One byte per value, @0x00@ for 'False' and @0x01@ for 'True'. +boolSamples :: [Bool] +boolSamples = [False, True] + +boolSampleBytes :: BS.ByteString +boolSampleBytes = BS.pack [0x00, 0x01] + +{- | Bit patterns are written out rather than derived, so the test pins the +big-endian layout and the sign of zero. NaN is left out because its payload is +target-dependent; it is checked separately. +-} +floatSamples :: [Float] +floatSamples = [0.0, -0.0, 1.0, -1.0, 1 / 0, -(1 / 0), encodeFloat 1 (-149)] + +floatSampleBytes :: BS.ByteString +floatSampleBytes = + BS.concat + [ BS.pack [0x00, 0x00, 0x00, 0x00] -- 0.0 + , BS.pack [0x80, 0x00, 0x00, 0x00] -- -0.0 + , BS.pack [0x3f, 0x80, 0x00, 0x00] -- 1.0 + , BS.pack [0xbf, 0x80, 0x00, 0x00] -- -1.0 + , BS.pack [0x7f, 0x80, 0x00, 0x00] -- +Inf + , BS.pack [0xff, 0x80, 0x00, 0x00] -- -Inf + , BS.pack [0x00, 0x00, 0x00, 0x01] -- smallest positive subnormal + ] + +doubleSamples :: [Double] +doubleSamples = [0.0, -0.0, 1.0, -1.0, 1 / 0, -(1 / 0), encodeFloat 1 (-1074)] + +doubleSampleBytes :: BS.ByteString +doubleSampleBytes = + BS.concat + [ BS.pack [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] -- 0.0 + , BS.pack [0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] -- -0.0 + , BS.pack [0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] -- 1.0 + , BS.pack [0xbf, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] -- -1.0 + , BS.pack [0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] -- +Inf + , BS.pack [0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00] -- -Inf + , BS.pack [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01] -- smallest positive subnormal + ] + tests :: TestTree tests = testGroup @@ -268,6 +345,24 @@ , testCase "FNV1a Word64 word elements match bytes" $ do fnv1a @Word64 [word128Sample] @?= fnv1a @Word64 (BS.pack (wordBytes 16 word128Sample)) fnv1a @Word64 [word256Sample] @?= fnv1a @Word64 (BS.pack (wordBytes 32 word256Sample)) + , testCase "FNV1a Word64 wide signed elements match two's complement bytes" $ do + fnv1a @Word64 [int128Sample] @?= fnv1a @Word64 (BS.pack (wordBytes 16 int128Sample)) + fnv1a @Word64 [int128Negative] @?= fnv1a @Word64 (BS.pack (wordBytes 16 int128Negative)) + fnv1a @Word64 [int256Sample] @?= fnv1a @Word64 (BS.pack (wordBytes 32 int256Sample)) + fnv1a @Word64 [int256Negative] @?= fnv1a @Word64 (BS.pack (wordBytes 32 int256Negative)) + fnv1a @Word64 [-1 :: Int128] @?= fnv1a @Word64 int128MinusOneBytes + fnv1a @Word64 [-1 :: Int256] @?= fnv1a @Word64 int256MinusOneBytes + , testCase "FNV1a Word64 Bool elements match bytes" $ + fnv1a @Word64 boolSamples @?= fnv1a @Word64 boolSampleBytes + , testCase "FNV1a Word64 Float elements match IEEE-754 bytes" $ + fnv1a @Word64 floatSamples @?= fnv1a @Word64 floatSampleBytes + , testCase "FNV1a Word64 Double elements match IEEE-754 bytes" $ + fnv1a @Word64 doubleSamples @?= fnv1a @Word64 doubleSampleBytes + , testCase "FNV1a Word64 float NaN bits are preserved" $ do + let nanF = 0 / 0 :: Float + nanD = 0 / 0 :: Double + fnv1a @Word64 [nanF] @?= fnv1a @Word64 (BS.pack (wordBytes 4 (castFloatToWord32 nanF))) + fnv1a @Word64 [nanD] @?= fnv1a @Word64 (BS.pack (wordBytes 8 (castDoubleToWord64 nanD))) , testCase "FNV1 Word64 small word elements match bytes" $ do fnv1 @Word64 word16Samples @?= fnv1 @Word64 (packWords 2 word16Samples) fnv1 @Word64 word32Samples @?= fnv1 @Word64 (packWords 4 word32Samples) @@ -292,6 +387,19 @@ , testCase "SipHash-2-4 Word64 word elements match bytes" $ do sipHash @Word64 2 4 Test.Data.SipHash.key [word128Sample] @?= sipHash @Word64 2 4 Test.Data.SipHash.key (BS.pack (wordBytes 16 word128Sample)) sipHash @Word64 2 4 Test.Data.SipHash.key [word256Sample] @?= sipHash @Word64 2 4 Test.Data.SipHash.key (BS.pack (wordBytes 32 word256Sample)) + , testCase "SipHash-2-4 Word64 wide signed elements match two's complement bytes" $ do + sipHash @Word64 2 4 Test.Data.SipHash.key [int128Sample] @?= sipHash @Word64 2 4 Test.Data.SipHash.key (BS.pack (wordBytes 16 int128Sample)) + sipHash @Word64 2 4 Test.Data.SipHash.key [int128Negative] @?= sipHash @Word64 2 4 Test.Data.SipHash.key (BS.pack (wordBytes 16 int128Negative)) + sipHash @Word64 2 4 Test.Data.SipHash.key [int256Sample] @?= sipHash @Word64 2 4 Test.Data.SipHash.key (BS.pack (wordBytes 32 int256Sample)) + sipHash @Word64 2 4 Test.Data.SipHash.key [int256Negative] @?= sipHash @Word64 2 4 Test.Data.SipHash.key (BS.pack (wordBytes 32 int256Negative)) + sipHash @Word64 2 4 Test.Data.SipHash.key [-1 :: Int128] @?= sipHash @Word64 2 4 Test.Data.SipHash.key int128MinusOneBytes + sipHash @Word64 2 4 Test.Data.SipHash.key [-1 :: Int256] @?= sipHash @Word64 2 4 Test.Data.SipHash.key int256MinusOneBytes + , testCase "SipHash-2-4 Word64 Bool elements match bytes" $ + sipHash @Word64 2 4 Test.Data.SipHash.key boolSamples @?= sipHash @Word64 2 4 Test.Data.SipHash.key boolSampleBytes + , testCase "SipHash-2-4 Word64 Float elements match IEEE-754 bytes" $ + sipHash @Word64 2 4 Test.Data.SipHash.key floatSamples @?= sipHash @Word64 2 4 Test.Data.SipHash.key floatSampleBytes + , testCase "SipHash-2-4 Word64 Double elements match IEEE-754 bytes" $ + sipHash @Word64 2 4 Test.Data.SipHash.key doubleSamples @?= sipHash @Word64 2 4 Test.Data.SipHash.key doubleSampleBytes , testCase "SipHash-2-4 Word64 small word elements match bytes" $ do sipHash @Word64 2 4 Test.Data.SipHash.key word16Samples @?= sipHash @Word64 2 4 Test.Data.SipHash.key (packWords 2 word16Samples) sipHash @Word64 2 4 Test.Data.SipHash.key word32Samples @?= sipHash @Word64 2 4 Test.Data.SipHash.key (packWords 4 word32Samples) @@ -312,6 +420,19 @@ , testCase "HalfSipHash-2-4 Word32 word elements match bytes" $ do halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key [word128Sample] @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key (BS.pack (wordBytes 16 word128Sample)) halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key [word256Sample] @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key (BS.pack (wordBytes 32 word256Sample)) + , testCase "HalfSipHash-2-4 Word32 wide signed elements match two's complement bytes" $ do + halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key [int128Sample] @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key (BS.pack (wordBytes 16 int128Sample)) + halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key [int128Negative] @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key (BS.pack (wordBytes 16 int128Negative)) + halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key [int256Sample] @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key (BS.pack (wordBytes 32 int256Sample)) + halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key [int256Negative] @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key (BS.pack (wordBytes 32 int256Negative)) + halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key [-1 :: Int128] @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key int128MinusOneBytes + halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key [-1 :: Int256] @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key int256MinusOneBytes + , testCase "HalfSipHash-2-4 Word32 Bool elements match bytes" $ + halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key boolSamples @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key boolSampleBytes + , testCase "HalfSipHash-2-4 Word32 Float elements match IEEE-754 bytes" $ + halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key floatSamples @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key floatSampleBytes + , testCase "HalfSipHash-2-4 Word32 Double elements match IEEE-754 bytes" $ + halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key doubleSamples @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key doubleSampleBytes , testCase "HalfSipHash-2-4 Word32 small word elements match bytes" $ do halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key word16Samples @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key (packWords 2 word16Samples) halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key word32Samples @?= halfSipHash @Word32 2 4 Test.Data.HalfSipHash.key (packWords 4 word32Samples)