packages feed

hw-prim 0.6.3.0 → 0.6.3.1

raw patch · 21 files changed

+277/−47 lines, 21 filesdep ~bytestringdep ~criteriondep ~doctestPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: bytestring, criterion, doctest, ghc-prim, hedgehog, hspec, transformers, vector

API changes (from Hackage documentation)

- HaskellWorks.Data.Decode: data DecodeError
+ HaskellWorks.Data.Decode: newtype DecodeError

Files

LICENSE view
@@ -1,4 +1,4 @@-Copyright John Ky (c) 2016+Copyright John Ky (c) 2016-2021  All rights reserved.
hw-prim.cabal view
@@ -1,7 +1,7 @@ cabal-version: 2.2  name:                   hw-prim-version:                0.6.3.0+version:                0.6.3.1 synopsis:               Primitive functions and data types description:            Primitive functions and data types. category:               Data@@ -10,10 +10,10 @@ bug-reports:            https://github.com/haskell-works/hw-prim/issues author:                 John Ky maintainer:             newhoggy@gmail.com-copyright:              2016-2020 John Ky+copyright:              2016-2021 John Ky license:                BSD-3-Clause license-file:           LICENSE-tested-with:            GHC == 8.10.1, GHC == 8.8.3, GHC == 8.6.5, GHC == 8.4.4+tested-with:            GHC == 9.2.2, GHC == 9.0.1, GHC == 8.10.7, GHC == 8.8.4, GHC == 8.6.5 build-type:             Simple extra-source-files:     README.md @@ -28,21 +28,21 @@  common base                       { build-depends: base                       >= 4.11       && < 5      } -common bytestring                 { build-depends: bytestring                 >= 0.9        && < 0.11   }+common bytestring                 { build-depends: bytestring                 >= 0.9        && < 0.12   } common criterion                  { build-depends: criterion                  >= 1.2        && < 1.6    } common deepseq                    { build-depends: deepseq                    >= 1.4        && < 1.5    } common directory                  { build-depends: directory                  >= 1.2        && < 1.4    }-common doctest                    { build-depends: doctest                    >= 0.16.2     && < 0.17   }+common doctest                    { build-depends: doctest                    >= 0.16.2     && < 0.21   } common doctest-discover           { build-depends: doctest-discover           >= 0.2        && < 0.3    } common exceptions                 { build-depends: exceptions                 >= 0.8        && < 0.11   }-common ghc-prim                   { build-depends: ghc-prim                   >= 0.5        && < 0.7    }-common hedgehog                   { build-depends: hedgehog                   >= 1.0        && < 1.1    }-common hspec                      { build-depends: hspec                      >= 2.4        && < 2.8    }+common ghc-prim                   { build-depends: ghc-prim                   >= 0.5        && < 0.9    }+common hedgehog                   { build-depends: hedgehog                   >= 1.0        && < 1.2    }+common hspec                      { build-depends: hspec                      >= 2.4        && < 2.10   } common hw-hspec-hedgehog          { build-depends: hw-hspec-hedgehog          >= 0.1        && < 0.2    } common mmap                       { build-depends: mmap                       >= 0.5        && < 0.6    } common QuickCheck                 { build-depends: QuickCheck                 >= 2.10       && < 2.15   }-common semigroups                 { build-depends: semigroups                 >= 0.8.4      && < 0.20   }-common transformers               { build-depends: transformers               >= 0.4        && < 0.6    }+common semigroups                 { build-depends: semigroups                 >= 0.8.4      && < 0.21   }+common transformers               { build-depends: transformers               >= 0.4        && < 0.7    } common unliftio-core              { build-depends: unliftio-core              >= 0.1.2.0    && < 0.3    } common vector                     { build-depends: vector                     >= 0.12       && < 0.13   } @@ -163,7 +163,7 @@                       , hw-prim   default-language:     Haskell2010   type:                 exitcode-stdio-1.0-  ghc-options:          -threaded+  ghc-options:          -threaded -rtsopts -with-rtsopts=-N   main-is:              DoctestDriver.hs   HS-Source-Dirs:       doctest   build-tool-depends:   doctest-discover:doctest-discover
src/HaskellWorks/Data/Branchless.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE CPP       #-} {-# LANGUAGE MagicHash #-}  module HaskellWorks.Data.Branchless@@ -26,66 +27,291 @@ import GHC.Prim import GHC.Word (Word16 (..), Word32 (..), Word64 (..), Word8 (..)) +-- | Branchless less-than comparison+--+-- Return 1 if the first argument is less-than the second argument, otherwise return 0.+--+-- >>> ltWord8 5 5+-- 0+-- >>> ltWord8 4 5+-- 1+-- >>> ltWord8 6 5+-- 0 ltWord8 :: Word8 -> Word8 -> Word8+#if MIN_VERSION_base(4,16,0)+ltWord8 (W8# a#) (W8# b#) = fromIntegral (I# (ltWord8# a# b#))+#else ltWord8 (W8# a#) (W8# b#) = fromIntegral (I8# (ltWord# a# b#))+#endif {-# INLINE ltWord8 #-} +-- | Branchless less-than comparison+--+-- Return 1 if the first argument is less-than the second argument, otherwise return 0.+--+-- >>> ltWord16 5 5+-- 0+-- >>> ltWord16 4 5+-- 1+-- >>> ltWord16 6 5+-- 0 ltWord16 :: Word16 -> Word16 -> Word16+#if MIN_VERSION_base(4,16,0)+ltWord16 (W16# a#) (W16# b#) = fromIntegral (I# (ltWord16# a# b#))+#else ltWord16 (W16# a#) (W16# b#) = fromIntegral (I16# (ltWord# a# b#))+#endif {-# INLINE ltWord16 #-} +-- | Branchless less-than comparison+--+-- Return 1 if the first argument is less-than the second argument, otherwise return 0.+--+-- >>> ltWord32 5 5+-- 0+-- >>> ltWord32 4 5+-- 1+-- >>> ltWord32 6 5+-- 0 ltWord32 :: Word32 -> Word32 -> Word32+#if MIN_VERSION_base(4,16,0)+ltWord32 (W32# a#) (W32# b#) = fromIntegral (I# (ltWord32# a# b#))+#else ltWord32 (W32# a#) (W32# b#) = fromIntegral (I32# (ltWord# a# b#))+#endif {-# INLINE ltWord32 #-} +-- | Branchless less-than comparison+--+-- Return 1 if the first argument is less-than the second argument, otherwise return 0.+--+-- >>> ltWord64 5 5+-- 0+-- >>> ltWord64 4 5+-- 1+-- >>> ltWord64 6 5+-- 0 ltWord64 :: Word64 -> Word64 -> Word64+#if MIN_VERSION_base(4,16,0)+ltWord64 (W64# a#) (W64# b#) = fromIntegral (I# (ltWord# a# b#))+#else ltWord64 (W64# a#) (W64# b#) = fromIntegral (I64# (ltWord# a# b#))+#endif {-# INLINE ltWord64 #-} +-- | Branchless less-than-or-equal-to comparison+--+-- Return 1 if the first argument is less-than-or-equal-to the second argument, otherwise return 0.+--+-- >>> leWord8 5 5+-- 1+-- >>> leWord8 4 5+-- 1+-- >>> leWord8 6 5+-- 0 leWord8 :: Word8 -> Word8 -> Word8+#if MIN_VERSION_base(4,16,0)+leWord8 (W8# a#) (W8# b#) = fromIntegral (I# (leWord8# a# b#))+#else leWord8 (W8# a#) (W8# b#) = fromIntegral (I8# (leWord# a# b#))+#endif+ {-# INLINE leWord8 #-} +-- | Branchless less-than-or-equal-to comparison+--+-- Return 1 if the first argument is less-than-or-equal-to the second argument, otherwise return 0.+--+-- >>> leWord16 5 5+-- 1+-- >>> leWord16 4 5+-- 1+-- >>> leWord16 6 5+-- 0 leWord16 :: Word16 -> Word16 -> Word16+#if MIN_VERSION_base(4,16,0)+leWord16 (W16# a#) (W16# b#) = fromIntegral (I# (leWord16# a# b#))+#else leWord16 (W16# a#) (W16# b#) = fromIntegral (I16# (leWord# a# b#))+#endif {-# INLINE leWord16 #-} +-- | Branchless less-than-or-equal-to comparison+--+-- Return 1 if the first argument is less-than-or-equal-to the second argument, otherwise return 0.+--+-- >>> leWord32 5 5+-- 1+-- >>> leWord32 4 5+-- 1+-- >>> leWord32 6 5+-- 0 leWord32 :: Word32 -> Word32 -> Word32+#if MIN_VERSION_base(4,16,0)+leWord32 (W32# a#) (W32# b#) = fromIntegral (I# (leWord32# a# b#))+#else leWord32 (W32# a#) (W32# b#) = fromIntegral (I32# (leWord# a# b#))+#endif {-# INLINE leWord32 #-} +-- | Branchless less-than-or-equal-to comparison+--+-- Return 1 if the first argument is less-than-or-equal-to the second argument, otherwise return 0.+--+-- >>> leWord64 5 5+-- 1+-- >>> leWord64 4 5+-- 1+-- >>> leWord64 6 5+-- 0 leWord64 :: Word64 -> Word64 -> Word64+#if MIN_VERSION_base(4,16,0)+leWord64 (W64# a#) (W64# b#) = fromIntegral (I# (leWord# a# b#))+#else leWord64 (W64# a#) (W64# b#) = fromIntegral (I64# (leWord# a# b#))+#endif {-# INLINE leWord64 #-} +-- | Branchless greater-than comparison+--+-- Return 1 if the first argument is greater-than the second argument, otherwise return 0.+--+-- >>> gtWord8 5 5+-- 0+-- >>> gtWord8 4 5+-- 0+-- >>> gtWord8 6 5+-- 1 gtWord8 :: Word8 -> Word8 -> Word8+#if MIN_VERSION_base(4,16,0)+gtWord8 (W8# a#) (W8# b#) = fromIntegral (I# (gtWord8# a# b#))+#else gtWord8 (W8# a#) (W8# b#) = fromIntegral (I8# (gtWord# a# b#))+#endif {-# INLINE gtWord8 #-} +-- | Branchless greater-than comparison+--+-- Return 1 if the first argument is greater-than the second argument, otherwise return 0.+--+-- >>> gtWord16 5 5+-- 0+-- >>> gtWord16 4 5+-- 0+-- >>> gtWord16 6 5+-- 1 gtWord16 :: Word16 -> Word16 -> Word16+#if MIN_VERSION_base(4,16,0)+gtWord16 (W16# a#) (W16# b#) = fromIntegral (I# (gtWord16# a# b#))+#else gtWord16 (W16# a#) (W16# b#) = fromIntegral (I16# (gtWord# a# b#))+#endif {-# INLINE gtWord16 #-} +-- | Branchless greater-than comparison+--+-- Return 1 if the first argument is greater-than the second argument, otherwise return 0.+--+-- >>> gtWord32 5 5+-- 0+-- >>> gtWord32 4 5+-- 0+-- >>> gtWord32 6 5+-- 1 gtWord32 :: Word32 -> Word32 -> Word32+#if MIN_VERSION_base(4,16,0)+gtWord32 (W32# a#) (W32# b#) = fromIntegral (I# (gtWord32# a# b#))+#else gtWord32 (W32# a#) (W32# b#) = fromIntegral (I32# (gtWord# a# b#))+#endif {-# INLINE gtWord32 #-} +-- | Branchless greater-than comparison+--+-- Return 1 if the first argument is greater-than the second argument, otherwise return 0.+--+-- >>> gtWord64 5 5+-- 0+-- >>> gtWord64 4 5+-- 0+-- >>> gtWord64 6 5+-- 1 gtWord64 :: Word64 -> Word64 -> Word64+#if MIN_VERSION_base(4,16,0)+gtWord64 (W64# a#) (W64# b#) = fromIntegral (I# (gtWord# a# b#))+#else gtWord64 (W64# a#) (W64# b#) = fromIntegral (I64# (gtWord# a# b#))+#endif {-# INLINE gtWord64 #-} +-- | Branchless greater-than-or-equal-to comparison+--+-- Return 1 if the first argument is greater-than-or-equal-to the second argument, otherwise return 0.+--+-- >>> geWord8 5 5+-- 1+-- >>> geWord8 4 5+-- 0+-- >>> geWord8 6 5+-- 1 geWord8 :: Word8 -> Word8 -> Word8+#if MIN_VERSION_base(4,16,0)+geWord8 (W8# a#) (W8# b#) = fromIntegral (I# (geWord8# a# b#))+#else geWord8 (W8# a#) (W8# b#) = fromIntegral (I8# (geWord# a# b#))+#endif {-# INLINE geWord8 #-} +-- | Branchless greater-than-or-equal-to comparison+--+-- Return 1 if the first argument is greater-than-or-equal-to the second argument, otherwise return 0.+--+-- >>> geWord16 5 5+-- 1+-- >>> geWord16 4 5+-- 0+-- >>> geWord16 6 5+-- 1 geWord16 :: Word16 -> Word16 -> Word16+#if MIN_VERSION_base(4,16,0)+geWord16 (W16# a#) (W16# b#) = fromIntegral (I# (geWord16# a# b#))+#else geWord16 (W16# a#) (W16# b#) = fromIntegral (I16# (geWord# a# b#))+#endif {-# INLINE geWord16 #-} +-- | Branchless greater-than-or-equal-to comparison+--+-- Return 1 if the first argument is greater-than-or-equal-to the second argument, otherwise return 0.+--+-- >>> geWord32 5 5+-- 1+-- >>> geWord32 4 5+-- 0+-- >>> geWord32 6 5+-- 1 geWord32 :: Word32 -> Word32 -> Word32+#if MIN_VERSION_base(4,16,0)+geWord32 (W32# a#) (W32# b#) = fromIntegral (I# (geWord32# a# b#))+#else geWord32 (W32# a#) (W32# b#) = fromIntegral (I32# (geWord# a# b#))+#endif {-# INLINE geWord32 #-} +-- | Branchless greater-than-or-equal-to comparison+--+-- Return 1 if the first argument is greater-than-or-equal-to the second argument, otherwise return 0.+--+-- >>> geWord64 5 5+-- 1+-- >>> geWord64 4 5+-- 0+-- >>> geWord64 6 5+-- 1 geWord64 :: Word64 -> Word64 -> Word64+#if MIN_VERSION_base(4,16,0)+geWord64 (W64# a#) (W64# b#) = fromIntegral (I# (geWord# a# b#))+#else geWord64 (W64# a#) (W64# b#) = fromIntegral (I64# (geWord# a# b#))+#endif {-# INLINE geWord64 #-}
src/HaskellWorks/Data/Decode.hs view
@@ -5,7 +5,7 @@   , DecodeError(..)   ) where -data DecodeError = DecodeError String deriving (Eq, Show)+newtype DecodeError = DecodeError String deriving (Eq, Show)  class Decode s t where   decode :: s -> Either DecodeError t
src/HaskellWorks/Data/Ops.hs view
@@ -1,5 +1,4 @@-{-# LANGUAGE PatternSynonyms #-}-{-# LANGUAGE Rank2Types      #-}+{-# LANGUAGE Rank2Types #-}  module HaskellWorks.Data.Ops   ( (<|)
src/HaskellWorks/Data/Positioning.hs view
@@ -1,5 +1,4 @@-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE TypeSynonymInstances       #-}+{-# LANGUAGE TypeSynonymInstances #-}  module HaskellWorks.Data.Positioning   ( Count
src/HaskellWorks/Data/Vector/AsVector64ns.hs view
@@ -2,13 +2,11 @@ {-# LANGUAGE FlexibleInstances   #-} {-# LANGUAGE Rank2Types          #-} {-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TupleSections       #-}  module HaskellWorks.Data.Vector.AsVector64ns   ( AsVector64ns(..)   ) where -import Control.Applicative                  ((<$>)) import Data.Word import HaskellWorks.Data.Vector.AsVector8ns (asVector8ns)
src/HaskellWorks/Data/Vector/AsVector64s.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts    #-} {-# LANGUAGE FlexibleInstances   #-} {-# LANGUAGE Rank2Types          #-}@@ -8,7 +9,6 @@   ( AsVector64s(..)   ) where -import Control.Applicative ((<$>)) import Control.Monad.ST import Data.Word import Foreign.ForeignPtr@@ -18,6 +18,10 @@ import qualified Data.ByteString.Lazy         as LBS import qualified Data.Vector.Storable         as DVS import qualified Data.Vector.Storable.Mutable as DVSM++#if !MIN_VERSION_base(4,13,0)+import Control.Applicative ((<$>)) -- Fix warning in ghc >= 9.2+#endif  class AsVector64s a where   -- | Represent the value as a list of Vector of 'n' Word64 chunks.  The last chunk will
src/HaskellWorks/Data/Vector/AsVector8ns.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE CPP                 #-} {-# LANGUAGE FlexibleContexts    #-} {-# LANGUAGE FlexibleInstances   #-} {-# LANGUAGE Rank2Types          #-}@@ -8,11 +9,9 @@   ( AsVector8ns(..)   ) where -import Control.Applicative ((<$>)) import Control.Monad.ST import Data.Word import Foreign.ForeignPtr--- import HaskellWorks.Data.ByteString (ToByteString (..)) import HaskellWorks.Data.Vector.AsVector8  import qualified Data.ByteString              as BS@@ -20,6 +19,10 @@ import qualified Data.ByteString.Lazy         as LBS import qualified Data.Vector.Storable         as DVS import qualified Data.Vector.Storable.Mutable as DVSM++#if !MIN_VERSION_base(4,13,0)+import Control.Applicative ((<$>)) -- Fix warning in ghc >= 9.2+#endif  class AsVector8ns a where   -- | Represent the value as a list of Vector of 'n' Word8 chunks.  The last chunk will
src/HaskellWorks/Data/Vector/AsVector8s.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE CPP                 #-} {-# LANGUAGE FlexibleContexts    #-} {-# LANGUAGE FlexibleInstances   #-} {-# LANGUAGE Rank2Types          #-}@@ -8,7 +9,6 @@   ( AsVector8s(..)   ) where -import Control.Applicative ((<$>)) import Control.Monad.ST import Data.Word import Foreign.ForeignPtr@@ -18,6 +18,10 @@ import qualified Data.ByteString.Lazy         as LBS import qualified Data.Vector.Storable         as DVS import qualified Data.Vector.Storable.Mutable as DVSM++#if !MIN_VERSION_base(4,13,0)+import Control.Applicative ((<$>)) -- Fix warning in ghc >= 9.2+#endif  class AsVector8s a where   -- | Represent the value as a list of Vector of 'n' Word8 chunks.  The last chunk will
src/HaskellWorks/Data/Vector/Storable.hs view
@@ -26,7 +26,7 @@ import qualified Data.Vector.Storable.Mutable as DVSM import qualified System.IO.MMap               as IO -{-# ANN module ("HLint: ignore Redundant do"        :: String) #-}+{- HLINT ignore "Redundant do" -}  padded :: Int -> DVS.Vector Word8 -> DVS.Vector Word8 padded n v = v <> DVS.replicate ((n - DVS.length v) `max` 0) 0@@ -114,7 +114,7 @@           (ibmvRemaining, bpmvRemaining) <- go ibmv bpmv xs           let ibl = ((DVSM.length ibmv - ibmvRemaining + 7) `div` 8) * 8           let bpl = ((DVSM.length bpmv - bpmvRemaining + 7) `div` 8) * 8-          return [ DVSM.take ibl ibmv, DVSM.take bpl bpmv]+          return [DVSM.take ibl ibmv, DVSM.take bpl bpmv]         go :: DVSM.MVector s Word8 -> DVSM.MVector s Word8 -> [(BS.ByteString, BS.ByteString)] -> ST s (Int, Int)         go ibmv bpmv ((ib, bp):ys) = do           DVS.copy (DVSM.take (BS.length ib) ibmv) (asVector8 ib)
test/HaskellWorks/Data/ByteStringSpec.hs view
@@ -13,7 +13,7 @@ import qualified Hedgehog.Gen                  as G import qualified Hedgehog.Range                as R -{-# ANN module ("HLint: ignore Redundant do" :: String) #-}+{- HLINT ignore "Redundant do" -}  spec :: Spec spec = describe "HaskellWorks.Data.ByteStringSpec" $ do@@ -37,7 +37,7 @@     bss       <- forAll $ (BS.pack <$>) <$> G.list (R.linear 0 8) (G.list (R.linear 0 24) (G.word8 R.constantBounded))     chunkSize <- forAll $ G.int (R.linear 1 4)     forM_ (reverse (BS.resegmentPadded chunkSize bss)) $ \bs -> do-      (BS.length bs) `mod` chunkSize === 0+      BS.length bs `mod` chunkSize === 0   it "rechunk does not modify data" $ requireProperty $ do     bss       <- forAll $ (BS.pack <$>) <$> G.list (R.linear 0 8) (G.list (R.linear 0 24) (G.word8 R.constantBounded))     chunkSize <- forAll $ G.int (R.linear 1 4)@@ -46,7 +46,7 @@     bss       <- forAll $ (BS.pack <$>) <$> G.list (R.linear 0 8) (G.list (R.linear 0 24) (G.word8 R.constantBounded))     chunkSize <- forAll $ G.int (R.linear 1 4)     forM_ (drop 1 (reverse (BS.rechunk chunkSize bss))) $ \bs -> do-      (BS.length bs) `mod` chunkSize === 0+      BS.length bs `mod` chunkSize === 0   it "rechunk creates correctly sized segments" $ requireProperty $ do     ws <- forAll $ G.list (R.linear 0 (LBSI.defaultChunkSize `div` 4)) (G.word64 R.constantBounded)     fold (BS.toByteStrings ws) === BS.toByteString ws
test/HaskellWorks/Data/FoldableSpec.hs view
@@ -1,5 +1,5 @@ {-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}-{-# LANGUAGE OverloadedLists     #-}+ {-# LANGUAGE ScopedTypeVariables #-}  module HaskellWorks.Data.FoldableSpec (spec) where@@ -13,7 +13,7 @@ import qualified Hedgehog.Gen   as G import qualified Hedgehog.Range as R -{-# ANN module ("HLint: ignore Redundant do" :: String) #-}+{- HLINT ignore "Redundant do" -}  spec :: Spec spec = describe "HaskellWorks.Data.FoldableSpec" $ do
test/HaskellWorks/Data/FromByteStringSpec.hs view
@@ -11,7 +11,7 @@ import qualified Data.ByteString      as BS import qualified Data.Vector.Storable as DVS -{-# ANN module ("HLint: ignore Redundant do" :: String) #-}+{- HLINT ignore "Redundant do" -}  spec :: Spec spec = describe "HaskellWorks.Data.FromByteStringSpec" $ do
test/HaskellWorks/Data/FromForeignRegionSpec.hs view
@@ -1,9 +1,6 @@ {-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}-{-# LANGUAGE BangPatterns               #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE OverloadedLists            #-}-{-# LANGUAGE ScopedTypeVariables        #-}-{-# LANGUAGE StandaloneDeriving         #-}+{-# LANGUAGE BangPatterns        #-}+{-# LANGUAGE ScopedTypeVariables #-}  module HaskellWorks.Data.FromForeignRegionSpec (spec) where @@ -21,7 +18,7 @@ import qualified System.Directory                    as IO import qualified System.IO                           as IO -{-# ANN module ("HLint: ignore Redundant do" :: String) #-}+{- HLINT ignore "Redundant do" -}  spec :: Spec spec = describe "HaskellWorks.Data.FromForeignRegionSpec" $ do@@ -32,5 +29,5 @@     liftIO $ BS.hPut h (BS.pack ws)     liftIO $ IO.hClose h     !(_ :: DVS.Vector Word64) <- liftIO $ IO.mmapFromForeignRegion fp-    liftIO $ IO.removeFile fp+    -- liftIO $ IO.removeFile fp     True === True
test/HaskellWorks/Data/SearchSpec.hs view
@@ -5,7 +5,7 @@ import HaskellWorks.Data.Search import Test.Hspec -{-# ANN module ("HLint: ignore Redundant do" :: String) #-}+{- HLINT ignore "Redundant do" -}  spec :: Spec spec = describe "HaskellWorks.Data.SearchSpec" $ do
test/HaskellWorks/Data/Vector/AsVector64nsSpec.hs view
@@ -17,7 +17,7 @@ import qualified Hedgehog.Gen         as G import qualified Hedgehog.Range       as R -{-# ANN module ("HLint: ignore Redundant do" :: String) #-}+{- HLINT ignore "Redundant do" -}  spec :: Spec spec = describe "HaskellWorks.Data.Vector.AsVector64nsSpec" $ do
test/HaskellWorks/Data/Vector/AsVector64sSpec.hs view
@@ -17,7 +17,7 @@ import qualified Hedgehog.Gen         as G import qualified Hedgehog.Range       as R -{-# ANN module ("HLint: ignore Redundant do" :: String) #-}+{- HLINT ignore "Redundant do" -}  spec :: Spec spec = describe "HaskellWorks.Data.Vector.AsVector64sSpec" $ do
test/HaskellWorks/Data/Vector/AsVector8nsSpec.hs view
@@ -17,7 +17,7 @@ import qualified Hedgehog.Gen         as G import qualified Hedgehog.Range       as R -{-# ANN module ("HLint: ignore Redundant do" :: String) #-}+{- HLINT ignore "Redundant do" -}  spec :: Spec spec = describe "HaskellWorks.Data.Vector.AsVector8nsSpec" $ do
test/HaskellWorks/Data/Vector/AsVector8sSpec.hs view
@@ -17,7 +17,7 @@ import qualified Hedgehog.Gen         as G import qualified Hedgehog.Range       as R -{-# ANN module ("HLint: ignore Redundant do" :: String) #-}+{- HLINT ignore "Redundant do" -}  spec :: Spec spec = describe "HaskellWorks.Data.Vector.AsVector8sSpec" $ do
test/HaskellWorks/Data/Vector/StorableSpec.hs view
@@ -22,7 +22,7 @@ import qualified Hedgehog.Gen                      as G import qualified Hedgehog.Range                    as R -{-# ANN module ("HLint: ignore Redundant do" :: String) #-}+{- HLINT ignore "Redundant do" -}  spec :: Spec spec = describe "HaskellWorks.Data.Vector.StorableSpec" $ do@@ -42,8 +42,8 @@   describe "construct64UnzipN" $ do     it "property" $ requireProperty $ do       abss  <- forAll $ G.list (R.linear 1 8) $ (,)-        <$> (fmap BS.pack (G.list (R.linear 1 8) (G.word8 R.constantBounded)))-        <*> (fmap BS.pack (G.list (R.linear 1 8) (G.word8 R.constantBounded)))+        <$> fmap BS.pack (G.list (R.linear 1 8) (G.word8 R.constantBounded))+        <*> fmap BS.pack (G.list (R.linear 1 8) (G.word8 R.constantBounded))       ass   <- forAll $ pure $ fmap fst abss       bss   <- forAll $ pure $ fmap snd abss       as    <- forAll $ pure $ mconcat ass@@ -70,7 +70,7 @@     vb === evb  dupList :: [a] -> [a]-dupList (a:as) = (a:a:dupList as)+dupList (a:as) = a:a:dupList as dupList []     = []  stepb :: Storable a => a -> DVSM.MVector s a -> ST s Int