05/09: gnu: ghc-bloomfilter: Update to 2.0.1.2.

[guix-commits]

efraim pushed a commit to branch mesa-updates
in repository guix.

commit 8c7a245a266e371d1fb4d8947e12a2668d1bd897
Author: Efraim Flashner <efraim@flashner.co.il>
AuthorDate: Wed Nov 15 12:44:41 2023 +0200

    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 +-
 gnu/packages/patches/ghc-bloomfilter-ghc9.2.patch | 303 ----------------------
 3 files changed, 9 insertions(+), 318 deletions(-)

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 <simon.jakobi@gmail.com>
-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