diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ -Copyright John Ky (c) 2016 +Copyright John Ky (c) 2016-2021 All rights reserved. diff --git a/hw-prim.cabal b/hw-prim.cabal --- a/hw-prim.cabal +++ b/hw-prim.cabal @@ -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 diff --git a/src/HaskellWorks/Data/Branchless.hs b/src/HaskellWorks/Data/Branchless.hs --- a/src/HaskellWorks/Data/Branchless.hs +++ b/src/HaskellWorks/Data/Branchless.hs @@ -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 #-} diff --git a/src/HaskellWorks/Data/Decode.hs b/src/HaskellWorks/Data/Decode.hs --- a/src/HaskellWorks/Data/Decode.hs +++ b/src/HaskellWorks/Data/Decode.hs @@ -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 diff --git a/src/HaskellWorks/Data/Ops.hs b/src/HaskellWorks/Data/Ops.hs --- a/src/HaskellWorks/Data/Ops.hs +++ b/src/HaskellWorks/Data/Ops.hs @@ -1,5 +1,4 @@ -{-# LANGUAGE PatternSynonyms #-} -{-# LANGUAGE Rank2Types #-} +{-# LANGUAGE Rank2Types #-} module HaskellWorks.Data.Ops ( (<|) diff --git a/src/HaskellWorks/Data/Positioning.hs b/src/HaskellWorks/Data/Positioning.hs --- a/src/HaskellWorks/Data/Positioning.hs +++ b/src/HaskellWorks/Data/Positioning.hs @@ -1,5 +1,4 @@ -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE TypeSynonymInstances #-} +{-# LANGUAGE TypeSynonymInstances #-} module HaskellWorks.Data.Positioning ( Count diff --git a/src/HaskellWorks/Data/Vector/AsVector64ns.hs b/src/HaskellWorks/Data/Vector/AsVector64ns.hs --- a/src/HaskellWorks/Data/Vector/AsVector64ns.hs +++ b/src/HaskellWorks/Data/Vector/AsVector64ns.hs @@ -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) diff --git a/src/HaskellWorks/Data/Vector/AsVector64s.hs b/src/HaskellWorks/Data/Vector/AsVector64s.hs --- a/src/HaskellWorks/Data/Vector/AsVector64s.hs +++ b/src/HaskellWorks/Data/Vector/AsVector64s.hs @@ -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 diff --git a/src/HaskellWorks/Data/Vector/AsVector8ns.hs b/src/HaskellWorks/Data/Vector/AsVector8ns.hs --- a/src/HaskellWorks/Data/Vector/AsVector8ns.hs +++ b/src/HaskellWorks/Data/Vector/AsVector8ns.hs @@ -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 diff --git a/src/HaskellWorks/Data/Vector/AsVector8s.hs b/src/HaskellWorks/Data/Vector/AsVector8s.hs --- a/src/HaskellWorks/Data/Vector/AsVector8s.hs +++ b/src/HaskellWorks/Data/Vector/AsVector8s.hs @@ -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 diff --git a/src/HaskellWorks/Data/Vector/Storable.hs b/src/HaskellWorks/Data/Vector/Storable.hs --- a/src/HaskellWorks/Data/Vector/Storable.hs +++ b/src/HaskellWorks/Data/Vector/Storable.hs @@ -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) diff --git a/test/HaskellWorks/Data/ByteStringSpec.hs b/test/HaskellWorks/Data/ByteStringSpec.hs --- a/test/HaskellWorks/Data/ByteStringSpec.hs +++ b/test/HaskellWorks/Data/ByteStringSpec.hs @@ -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 diff --git a/test/HaskellWorks/Data/FoldableSpec.hs b/test/HaskellWorks/Data/FoldableSpec.hs --- a/test/HaskellWorks/Data/FoldableSpec.hs +++ b/test/HaskellWorks/Data/FoldableSpec.hs @@ -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 diff --git a/test/HaskellWorks/Data/FromByteStringSpec.hs b/test/HaskellWorks/Data/FromByteStringSpec.hs --- a/test/HaskellWorks/Data/FromByteStringSpec.hs +++ b/test/HaskellWorks/Data/FromByteStringSpec.hs @@ -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 diff --git a/test/HaskellWorks/Data/FromForeignRegionSpec.hs b/test/HaskellWorks/Data/FromForeignRegionSpec.hs --- a/test/HaskellWorks/Data/FromForeignRegionSpec.hs +++ b/test/HaskellWorks/Data/FromForeignRegionSpec.hs @@ -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 diff --git a/test/HaskellWorks/Data/SearchSpec.hs b/test/HaskellWorks/Data/SearchSpec.hs --- a/test/HaskellWorks/Data/SearchSpec.hs +++ b/test/HaskellWorks/Data/SearchSpec.hs @@ -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 diff --git a/test/HaskellWorks/Data/Vector/AsVector64nsSpec.hs b/test/HaskellWorks/Data/Vector/AsVector64nsSpec.hs --- a/test/HaskellWorks/Data/Vector/AsVector64nsSpec.hs +++ b/test/HaskellWorks/Data/Vector/AsVector64nsSpec.hs @@ -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 diff --git a/test/HaskellWorks/Data/Vector/AsVector64sSpec.hs b/test/HaskellWorks/Data/Vector/AsVector64sSpec.hs --- a/test/HaskellWorks/Data/Vector/AsVector64sSpec.hs +++ b/test/HaskellWorks/Data/Vector/AsVector64sSpec.hs @@ -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 diff --git a/test/HaskellWorks/Data/Vector/AsVector8nsSpec.hs b/test/HaskellWorks/Data/Vector/AsVector8nsSpec.hs --- a/test/HaskellWorks/Data/Vector/AsVector8nsSpec.hs +++ b/test/HaskellWorks/Data/Vector/AsVector8nsSpec.hs @@ -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 diff --git a/test/HaskellWorks/Data/Vector/AsVector8sSpec.hs b/test/HaskellWorks/Data/Vector/AsVector8sSpec.hs --- a/test/HaskellWorks/Data/Vector/AsVector8sSpec.hs +++ b/test/HaskellWorks/Data/Vector/AsVector8sSpec.hs @@ -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 diff --git a/test/HaskellWorks/Data/Vector/StorableSpec.hs b/test/HaskellWorks/Data/Vector/StorableSpec.hs --- a/test/HaskellWorks/Data/Vector/StorableSpec.hs +++ b/test/HaskellWorks/Data/Vector/StorableSpec.hs @@ -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