From 8c7a245a266e371d1fb4d8947e12a2668d1bd897 Mon Sep 17 00:00:00 2001 From: Efraim Flashner Date: Wed, 15 Nov 2023 12:44:41 +0200 Subject: [PATCH] gnu: ghc-bloomfilter: Update to 2.0.1.2. * gnu/packages/haskell-xyz.scm (ghc-bloomfilter): Update to 2.0.1.2. [source]: Remove patch. Add snippet to fix building on 32-bit systems. [arguments]: Remove field. [home-page]: Update to new home-page. * gnu/packages/patches/ghc-bloomfilter-ghc9.2.patch: Remove file. * gnu/local.mk (dist_patch_DATA): Remove it. Change-Id: Ie61d079b001f804fd28acaca2acd3127b88935d4 --- gnu/local.mk | 1 - gnu/packages/haskell-xyz.scm | 23 +- .../patches/ghc-bloomfilter-ghc9.2.patch | 303 ------------------ 3 files changed, 9 insertions(+), 318 deletions(-) delete mode 100644 gnu/packages/patches/ghc-bloomfilter-ghc9.2.patch diff --git a/gnu/local.mk b/gnu/local.mk index a7dff407e1..4961b82efa 100644 --- a/gnu/local.mk +++ b/gnu/local.mk @@ -1270,7 +1270,6 @@ dist_patch_DATA = \ %D%/packages/patches/ghc-testsuite-dlopen-pie.patch \ %D%/packages/patches/ghc-testsuite-grep-compat.patch \ %D%/packages/patches/ghc-basement-fix-32bit.patch \ - %D%/packages/patches/ghc-bloomfilter-ghc9.2.patch \ %D%/packages/patches/ghc-bytestring-handle-ghc9.patch \ %D%/packages/patches/ghc-language-haskell-extract-ghc-8.10.patch \ %D%/packages/patches/ghostscript-CVE-2023-36664.patch \ diff --git a/gnu/packages/haskell-xyz.scm b/gnu/packages/haskell-xyz.scm index cc235a77d5..b9039d3875 100644 --- a/gnu/packages/haskell-xyz.scm +++ b/gnu/packages/haskell-xyz.scm @@ -1063,31 +1063,26 @@ library for Haskell.") (define-public ghc-bloomfilter (package (name "ghc-bloomfilter") - (version "2.0.1.0") + (version "2.0.1.2") (source (origin (method url-fetch) (uri (hackage-uri "bloomfilter" version)) (sha256 (base32 - "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc")) - (patches (search-patches "ghc-bloomfilter-ghc9.2.patch")))) + "0klb26ldkw32axv3927w489j71r2rc9pangsvznqjbljib9970hp")) + (snippet + #~(begin (use-modules (guix build utils)) + ;; https://github.com/bos/bloomfilter/issues/7 + (substitute* "Data/BloomFilter/Easy.hs" + ((" in if roundedBits <= 0 \\|\\| maxbitstoolarge roundedBits") + " in if roundedBits <= 0")))))) (build-system haskell-build-system) (properties '((upstream-name . "bloomfilter"))) (native-inputs (list ghc-quickcheck ghc-random ghc-test-framework ghc-test-framework-quickcheck2)) - (arguments - `(#:cabal-revision ("2" - "1hi6hwvhv7lxqv0l6hv2854g1rvc52zcmr3ldvnaan1l1b666867") - #:phases - (modify-phases %standard-phases - (add-before 'configure 'update-constraints - (lambda _ - (substitute* "bloomfilter.cabal" - (("\\b(base)\\s+[^,]+" all dep) - dep))))))) - (home-page "https://github.com/bos/bloomfilter") + (home-page "https://github.com/haskell-pkg-janitors/bloomfilter") (synopsis "Pure and impure Bloom filter implementations") (description "This package provides both mutable and immutable Bloom filter data types, along with a family of hash functions and an easy-to-use diff --git a/gnu/packages/patches/ghc-bloomfilter-ghc9.2.patch b/gnu/packages/patches/ghc-bloomfilter-ghc9.2.patch deleted file mode 100644 index 97caf2cc9b..0000000000 --- a/gnu/packages/patches/ghc-bloomfilter-ghc9.2.patch +++ /dev/null @@ -1,303 +0,0 @@ -Taken from https://github.com/bos/bloomfilter/pull/20 - -From fb79b39c44404fd791a3bed973e9d844fb084f1e Mon Sep 17 00:00:00 2001 -From: Simon Jakobi -Date: Fri, 12 Nov 2021 01:37:36 +0100 -Subject: [PATCH] Fix build with GHC 9.2 - -The `FastShift.shift{L,R}` methods are replaced with `unsafeShift{L,R}` -introduced in base-4.5. - -Fixes #19. ---- - Data/BloomFilter.hs | 16 +++++------ - Data/BloomFilter/Hash.hs | 15 +++++----- - Data/BloomFilter/Mutable.hs | 20 +++++++------- - Data/BloomFilter/Util.hs | 55 ++++++------------------------------- - bloomfilter.cabal | 2 +- - 5 files changed, 34 insertions(+), 74 deletions(-) - -diff --git a/Data/BloomFilter.hs b/Data/BloomFilter.hs -index 2210cef..6b47c21 100644 ---- a/Data/BloomFilter.hs -+++ b/Data/BloomFilter.hs -@@ -78,8 +78,8 @@ import Control.DeepSeq (NFData(..)) - import Data.Array.Base (unsafeAt) - import qualified Data.Array.Base as ST - import Data.Array.Unboxed (UArray) --import Data.Bits ((.&.)) --import Data.BloomFilter.Util (FastShift(..), (:*)(..)) -+import Data.Bits ((.&.), unsafeShiftL, unsafeShiftR) -+import Data.BloomFilter.Util ((:*)(..)) - import qualified Data.BloomFilter.Mutable as MB - import qualified Data.BloomFilter.Mutable.Internal as MB - import Data.BloomFilter.Mutable.Internal (Hash, MBloom) -@@ -98,7 +98,7 @@ data Bloom a = B { - } - - instance Show (Bloom a) where -- show ub = "Bloom { " ++ show ((1::Int) `shiftL` shift ub) ++ " bits } " -+ show ub = "Bloom { " ++ show ((1::Int) `unsafeShiftL` shift ub) ++ " bits } " - - instance NFData (Bloom a) where - rnf !_ = () -@@ -172,7 +172,7 @@ singleton hash numBits elt = create hash numBits (\mb -> MB.insert mb elt) - -- | Given a filter's mask and a hash value, compute an offset into - -- a word array and a bit offset within that word. - hashIdx :: Int -> Word32 -> (Int :* Int) --hashIdx mask x = (y `shiftR` logBitsInHash) :* (y .&. hashMask) -+hashIdx mask x = (y `unsafeShiftR` logBitsInHash) :* (y .&. hashMask) - where hashMask = 31 -- bitsInHash - 1 - y = fromIntegral x .&. mask - -@@ -191,7 +191,7 @@ hashesU ub elt = hashIdx (mask ub) `map` hashes ub elt - -- /still/ some possibility that @True@ will be returned. - elem :: a -> Bloom a -> Bool - elem elt ub = all test (hashesU ub elt) -- where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `shiftL` bit) /= 0 -+ where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `unsafeShiftL` bit) /= 0 - - modify :: (forall s. (MBloom s a -> ST s z)) -- ^ mutation function (result is discarded) - -> Bloom a -@@ -255,11 +255,11 @@ insertList elts = modify $ \mb -> mapM_ (MB.insert mb) elts - -- is /still/ some possibility that @True@ will be returned. - notElem :: a -> Bloom a -> Bool - notElem elt ub = any test (hashesU ub elt) -- where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `shiftL` bit) == 0 -+ where test (off :* bit) = (bitArray ub `unsafeAt` off) .&. (1 `unsafeShiftL` bit) == 0 - - -- | Return the size of an immutable Bloom filter, in bits. - length :: Bloom a -> Int --length = shiftL 1 . shift -+length = unsafeShiftL 1 . shift - - -- | Build an immutable Bloom filter from a seed value. The seeding - -- function populates the filter as follows. -@@ -318,7 +318,7 @@ fromList hashes numBits = unfold hashes numBits convert - logPower2 :: Int -> Int - logPower2 k = go 0 k - where go j 1 = j -- go j n = go (j+1) (n `shiftR` 1) -+ go j n = go (j+1) (n `unsafeShiftR` 1) - - -- $overview - -- -diff --git a/Data/BloomFilter/Hash.hs b/Data/BloomFilter/Hash.hs -index 132a3a4..d071fd4 100644 ---- a/Data/BloomFilter/Hash.hs -+++ b/Data/BloomFilter/Hash.hs -@@ -38,8 +38,7 @@ module Data.BloomFilter.Hash - ) where - - import Control.Monad (foldM) --import Data.Bits ((.&.), (.|.), xor) --import Data.BloomFilter.Util (FastShift(..)) -+import Data.Bits ((.&.), (.|.), unsafeShiftL, unsafeShiftR, xor) - import Data.List (unfoldr) - import Data.Int (Int8, Int16, Int32, Int64) - import Data.Word (Word8, Word16, Word32, Word64) -@@ -91,11 +90,11 @@ class Hashable a where - -> Word64 -- ^ salt - -> IO Word64 - hashIO64 v salt = do -- let s1 = fromIntegral (salt `shiftR` 32) .&. maxBound -+ let s1 = fromIntegral (salt `unsafeShiftR` 32) .&. maxBound - s2 = fromIntegral salt - h1 <- hashIO32 v s1 - h2 <- hashIO32 v s2 -- return $ (fromIntegral h1 `shiftL` 32) .|. fromIntegral h2 -+ return $ (fromIntegral h1 `unsafeShiftL` 32) .|. fromIntegral h2 - - -- | Compute a 32-bit hash. - hash32 :: Hashable a => a -> Word32 -@@ -149,8 +148,8 @@ cheapHashes :: Hashable a => Int -- ^ number of hashes to compute - cheapHashes k v = go 0 - where go i | i == j = [] - | otherwise = hash : go (i + 1) -- where !hash = h1 + (h2 `shiftR` i) -- h1 = fromIntegral (h `shiftR` 32) -+ where !hash = h1 + (h2 `unsafeShiftR` i) -+ h1 = fromIntegral (h `unsafeShiftR` 32) - h2 = fromIntegral h - h = hashSalt64 0x9150a946c4a8966e v - j = fromIntegral k -@@ -163,7 +162,7 @@ instance Hashable Integer where - (salt `xor` 0x3ece731e) - | otherwise = hashIO32 (unfoldr go k) salt - where go 0 = Nothing -- go i = Just (fromIntegral i :: Word32, i `shiftR` 32) -+ go i = Just (fromIntegral i :: Word32, i `unsafeShiftR` 32) - - instance Hashable Bool where - hashIO32 = hashOne32 -@@ -224,7 +223,7 @@ instance Hashable Word64 where - -- | A fast unchecked shift. Nasty, but otherwise GHC 6.8.2 does a - -- test and branch on every shift. - div4 :: CSize -> CSize --div4 k = fromIntegral ((fromIntegral k :: HTYPE_SIZE_T) `shiftR` 2) -+div4 k = fromIntegral ((fromIntegral k :: HTYPE_SIZE_T) `unsafeShiftR` 2) - - alignedHash :: Ptr a -> CSize -> Word32 -> IO Word32 - alignedHash ptr bytes salt -diff --git a/Data/BloomFilter/Mutable.hs b/Data/BloomFilter/Mutable.hs -index edff1fc..0bb5cc9 100644 ---- a/Data/BloomFilter/Mutable.hs -+++ b/Data/BloomFilter/Mutable.hs -@@ -65,9 +65,9 @@ module Data.BloomFilter.Mutable - import Control.Monad (liftM, forM_) - import Control.Monad.ST (ST) - import Data.Array.Base (unsafeRead, unsafeWrite) --import Data.Bits ((.&.), (.|.)) -+import Data.Bits ((.&.), (.|.), unsafeShiftL, unsafeShiftR) - import Data.BloomFilter.Array (newArray) --import Data.BloomFilter.Util (FastShift(..), (:*)(..), nextPowerOfTwo) -+import Data.BloomFilter.Util ((:*)(..), nextPowerOfTwo) - import Data.Word (Word32) - import Data.BloomFilter.Mutable.Internal - -@@ -86,9 +86,9 @@ new hash numBits = MB hash shft msk `liftM` newArray numElems numBytes - | numBits > maxHash = maxHash - | isPowerOfTwo numBits = numBits - | otherwise = nextPowerOfTwo numBits -- numElems = max 2 (twoBits `shiftR` logBitsInHash) -- numBytes = numElems `shiftL` logBytesInHash -- trueBits = numElems `shiftL` logBitsInHash -+ numElems = max 2 (twoBits `unsafeShiftR` logBitsInHash) -+ numBytes = numElems `unsafeShiftL` logBytesInHash -+ trueBits = numElems `unsafeShiftL` logBitsInHash - shft = logPower2 trueBits - msk = trueBits - 1 - isPowerOfTwo n = n .&. (n - 1) == 0 -@@ -109,7 +109,7 @@ logBytesInHash = 2 -- logPower2 (sizeOf (undefined :: Hash)) - -- | Given a filter's mask and a hash value, compute an offset into - -- a word array and a bit offset within that word. - hashIdx :: Int -> Word32 -> (Int :* Int) --hashIdx msk x = (y `shiftR` logBitsInHash) :* (y .&. hashMask) -+hashIdx msk x = (y `unsafeShiftR` logBitsInHash) :* (y .&. hashMask) - where hashMask = 31 -- bitsInHash - 1 - y = fromIntegral x .&. msk - -@@ -125,7 +125,7 @@ insert mb elt = do - let mu = bitArray mb - forM_ (hashesM mb elt) $ \(word :* bit) -> do - old <- unsafeRead mu word -- unsafeWrite mu word (old .|. (1 `shiftL` bit)) -+ unsafeWrite mu word (old .|. (1 `unsafeShiftL` bit)) - - -- | Query a mutable Bloom filter for membership. If the value is - -- present, return @True@. If the value is not present, there is -@@ -135,7 +135,7 @@ elem elt mb = loop (hashesM mb elt) - where mu = bitArray mb - loop ((word :* bit):wbs) = do - i <- unsafeRead mu word -- if i .&. (1 `shiftL` bit) == 0 -+ if i .&. (1 `unsafeShiftL` bit) == 0 - then return False - else loop wbs - loop _ = return True -@@ -145,7 +145,7 @@ elem elt mb = loop (hashesM mb elt) - - -- | Return the size of a mutable Bloom filter, in bits. - length :: MBloom s a -> Int --length = shiftL 1 . shift -+length = unsafeShiftL 1 . shift - - - -- | Slow, crummy way of computing the integer log of an integer known -@@ -153,7 +153,7 @@ length = shiftL 1 . shift - logPower2 :: Int -> Int - logPower2 k = go 0 k - where go j 1 = j -- go j n = go (j+1) (n `shiftR` 1) -+ go j n = go (j+1) (n `unsafeShiftR` 1) - - -- $overview - -- -diff --git a/Data/BloomFilter/Util.hs b/Data/BloomFilter/Util.hs -index 7f695dc..6ade6e5 100644 ---- a/Data/BloomFilter/Util.hs -+++ b/Data/BloomFilter/Util.hs -@@ -2,15 +2,11 @@ - - module Data.BloomFilter.Util - ( -- FastShift(..) -- , nextPowerOfTwo -+ nextPowerOfTwo - , (:*)(..) - ) where - --import Data.Bits ((.|.)) --import qualified Data.Bits as Bits --import GHC.Base --import GHC.Word -+import Data.Bits ((.|.), unsafeShiftR) - - -- | A strict pair type. - data a :* b = !a :* !b -@@ -22,46 +18,11 @@ nextPowerOfTwo :: Int -> Int - {-# INLINE nextPowerOfTwo #-} - nextPowerOfTwo n = - let a = n - 1 -- b = a .|. (a `shiftR` 1) -- c = b .|. (b `shiftR` 2) -- d = c .|. (c `shiftR` 4) -- e = d .|. (d `shiftR` 8) -- f = e .|. (e `shiftR` 16) -- g = f .|. (f `shiftR` 32) -- in case we're on a 64-bit host -+ b = a .|. (a `unsafeShiftR` 1) -+ c = b .|. (b `unsafeShiftR` 2) -+ d = c .|. (c `unsafeShiftR` 4) -+ e = d .|. (d `unsafeShiftR` 8) -+ f = e .|. (e `unsafeShiftR` 16) -+ g = f .|. (f `unsafeShiftR` 32) -- in case we're on a 64-bit host - !h = g + 1 - in h -- ---- | This is a workaround for poor optimisation in GHC 6.8.2. It ---- fails to notice constant-width shifts, and adds a test and branch ---- to every shift. This imposes about a 10% performance hit. --class FastShift a where -- shiftL :: a -> Int -> a -- shiftR :: a -> Int -> a -- --instance FastShift Word32 where -- {-# INLINE shiftL #-} -- shiftL (W32# x#) (I# i#) = W32# (x# `uncheckedShiftL#` i#) -- -- {-# INLINE shiftR #-} -- shiftR (W32# x#) (I# i#) = W32# (x# `uncheckedShiftRL#` i#) -- --instance FastShift Word64 where -- {-# INLINE shiftL #-} -- shiftL (W64# x#) (I# i#) = W64# (x# `uncheckedShiftL64#` i#) -- -- {-# INLINE shiftR #-} -- shiftR (W64# x#) (I# i#) = W64# (x# `uncheckedShiftRL64#` i#) -- --instance FastShift Int where -- {-# INLINE shiftL #-} -- shiftL (I# x#) (I# i#) = I# (x# `iShiftL#` i#) -- -- {-# INLINE shiftR #-} -- shiftR (I# x#) (I# i#) = I# (x# `iShiftRA#` i#) -- --instance FastShift Integer where -- {-# INLINE shiftL #-} -- shiftL = Bits.shiftL -- -- {-# INLINE shiftR #-} -- shiftR = Bits.shiftR -diff --git a/bloomfilter.cabal b/bloomfilter.cabal -index 821a5d7..c621f7f 100644 ---- a/bloomfilter.cabal -+++ b/bloomfilter.cabal -@@ -18,7 +18,7 @@ extra-source-files: README.markdown cbits/lookup3.c cbits/lookup3.h - library - build-depends: - array, -- base >= 4.4 && < 5, -+ base >= 4.5 && < 5, - bytestring >= 0.9, - deepseq - exposed-modules: Data.BloomFilter