packages feed

vector-builder 0.3.7.2 → 0.3.8.7

raw patch · 12 files changed

Files

− Setup.hs 
@@ -1,2 +0,0 @@-import Distribution.Simple-main = defaultMain
library/VectorBuilder/Alternative.hs view
@@ -1,31 +1,27 @@-{-|-Alternative utilities.-For instance, they can be applied with parsing libraries.--}-module VectorBuilder.Alternative-where+-- |+-- Alternative utilities.+-- For instance, they can be applied with parsing libraries.+module VectorBuilder.Alternative where -import VectorBuilder.Prelude hiding (many, some)-import Data.Vector (Vector)+import qualified Data.Vector.Generic as C import qualified VectorBuilder.Builder as A+import VectorBuilder.Prelude hiding (many, some) import qualified VectorBuilder.Vector as B-import qualified Data.Vector.Generic as C --{-# INLINABLE many #-}+{-# INLINEABLE many #-} many :: (Alternative m, C.Vector vector a) => m a -> m (vector a) many = fmap B.build . manyBuilder -{-# INLINABLE manyBuilder #-}-manyBuilder :: Alternative m => m a -> m (A.Builder a)-manyBuilder m = let-  loop = ((<>) <$> A.singleton <$> m <*> loop) <|> pure mempty-  in loop+{-# INLINEABLE manyBuilder #-}+manyBuilder :: (Alternative m) => m a -> m (A.Builder a)+manyBuilder m =+  let loop = ((<>) <$> A.singleton <$> m <*> loop) <|> pure mempty+   in loop -{-# INLINABLE some #-}+{-# INLINEABLE some #-} some :: (Alternative m, C.Vector vector a) => m a -> m (vector a) some m = B.build <$> someBuilder m -{-# INLINABLE someBuilder #-}-someBuilder :: Alternative m => m a -> m (A.Builder a)+{-# INLINEABLE someBuilder #-}+someBuilder :: (Alternative m) => m a -> m (A.Builder a) someBuilder m = (<>) <$> A.singleton <$> m <*> manyBuilder m
library/VectorBuilder/Builder.hs view
@@ -1,11 +1,11 @@ module VectorBuilder.Builder-(-  Builder,-  empty,-  singleton,-  vector,-  foldable,-)+  ( Builder,+    empty,+    singleton,+    size,+    vector,+    foldable,+  ) where  import VectorBuilder.Core.Builder
library/VectorBuilder/Core/Builder.hs view
@@ -1,19 +1,21 @@-module VectorBuilder.Core.Builder-where+module VectorBuilder.Core.Builder where -import VectorBuilder.Prelude hiding (empty, concat)-import qualified VectorBuilder.Core.Update as A import qualified Data.Vector.Generic as B-import qualified Data.Vector.Generic.Mutable as C-+import qualified VectorBuilder.Core.Update as A+import VectorBuilder.Prelude hiding (concat, empty)  -- | -- An abstraction over the size of a vector for the process of its construction.--- +-- -- It postpones the actual construction of a vector until the execution of the builder.-data Builder element =-  Builder !Int !(A.Update element)+data Builder element+  = Builder !Int !(A.Update element) +-- |+-- Gets the size of a Builder.+{-# INLINE size #-}+size :: Builder element -> Int+size (Builder s _) = s  -- * Initialisation @@ -33,19 +35,18 @@  -- | -- Builder from an immutable vector of elements.--- +-- -- Supports all kinds of vectors: boxed, unboxed, primitive, storable. {-# INLINE vector #-}-vector :: B.Vector vector element => vector element -> Builder element+vector :: (B.Vector vector element) => vector element -> Builder element vector vector =   Builder (B.length vector) (A.writeMany vector)  {-# INLINE foldable #-}-foldable :: Foldable foldable => foldable element -> Builder element+foldable :: (Foldable foldable) => foldable element -> Builder element foldable foldable =   Builder (length foldable) (A.writeFoldable foldable) - -- * Updates  {-# INLINE snoc #-}@@ -69,16 +70,22 @@   flip prepend  {-# INLINE concat #-}-concat :: Foldable foldable => foldable (Builder element) -> Builder element+concat :: (Foldable foldable) => foldable (Builder element) -> Builder element concat builders =   Builder-    (let-      step size (Builder builderSize _) = size + builderSize-      in foldl' step 0 builders)-    (A.Update (\mVector offset -> foldM_ (\index (Builder size (A.Update st)) ->-      st mVector index $> index + size)-      offset-      builders))+    ( let step size (Builder builderSize _) = size + builderSize+       in foldl' step 0 builders+    )+    ( A.Update+        ( \mVector offset ->+            foldM_+              ( \index (Builder size (A.Update st)) ->+                  st mVector index $> index + size+              )+              offset+              builders+        )+    )  -- * Instances @@ -103,4 +110,3 @@   {-# INLINE mconcat #-}   mconcat =     concat-
library/VectorBuilder/Core/Update.hs view
@@ -1,13 +1,11 @@-module VectorBuilder.Core.Update-where+module VectorBuilder.Core.Update where -import VectorBuilder.Prelude-import qualified Data.Vector.Generic.Mutable as A import qualified Data.Vector.Generic as B-+import qualified Data.Vector.Generic.Mutable as A+import VectorBuilder.Prelude -newtype Update element =-  Update (forall s vector. A.MVector vector element => vector s element -> Int -> ST s ())+newtype Update element+  = Update (forall s vector. (A.MVector vector element) => vector s element -> Int -> ST s ())  {-# INLINE write #-} write :: element -> Update element@@ -15,7 +13,7 @@   Update (\mVector offset -> A.unsafeWrite mVector offset element)  {-# INLINE writeMany #-}-writeMany :: B.Vector vector element => vector element -> Update element+writeMany :: (B.Vector vector element) => vector element -> Update element writeMany appendedVector =   Update (\mVector offset -> B.ifoldM' (\_ index element -> A.unsafeWrite mVector (strict (offset + index)) element) () appendedVector) @@ -30,6 +28,6 @@   Update (\_ _ -> pure ())  {-# INLINE writeFoldable #-}-writeFoldable :: Foldable foldable => foldable element -> Update element+writeFoldable :: (Foldable foldable) => foldable element -> Update element writeFoldable foldable =-  Update (\mVector offset -> foldM_ (\ index element -> A.unsafeWrite mVector index element $> succ index) offset foldable)+  Update (\mVector offset -> foldM_ (\index element -> A.unsafeWrite mVector index element $> succ index) offset foldable)
library/VectorBuilder/MVector.hs view
@@ -1,20 +1,18 @@ -- | -- Extensions to the standard mutable Vector API.-module VectorBuilder.MVector-where+module VectorBuilder.MVector where -import VectorBuilder.Prelude import Data.Vector.Generic.Mutable import qualified VectorBuilder.Core.Builder as A import qualified VectorBuilder.Core.Update as C-+import VectorBuilder.Prelude  -- | -- Construct a mutable vector from a builder.--- +-- -- Supports all kinds of vectors: boxed, unboxed, primitive, storable.-{-# INLINABLE build #-}-build :: MVector vector element => A.Builder element -> ST s (vector s element)+{-# INLINEABLE build #-}+build :: (MVector vector element) => A.Builder element -> ST s (vector s element) build (A.Builder size (C.Update update)) =   do     vector <- unsafeNew size
library/VectorBuilder/MonadPlus.hs view
@@ -1,35 +1,32 @@-{-|-MonadPlus utilities.-For instance, they can be applied with parsing libraries.--}-module VectorBuilder.MonadPlus-where+-- |+-- MonadPlus utilities.+-- For instance, they can be applied with parsing libraries.+module VectorBuilder.MonadPlus where -import VectorBuilder.Prelude-import Data.Vector (Vector)+import qualified Data.Vector.Generic as C import qualified VectorBuilder.Builder as A+import VectorBuilder.Prelude import qualified VectorBuilder.Vector as B-import qualified Data.Vector.Generic as C --{-# INLINABLE many #-}+{-# INLINEABLE many #-} many :: (MonadPlus m, C.Vector vector element) => m element -> m (vector element) many m =   liftM B.build (manyBuilder m) -{-# INLINABLE manyBuilder #-}+{-# INLINEABLE manyBuilder #-} manyBuilder :: (MonadPlus m) => m element -> m (A.Builder element) manyBuilder m =   loop mempty   where     loop !builder =       mplus-        (do-          !element <- m-          loop (builder <> A.singleton element))+        ( do+            !element <- m+            loop (builder <> A.singleton element)+        )         (return builder) -{-# INLINABLE many1 #-}+{-# INLINEABLE many1 #-} many1 :: (MonadPlus m, C.Vector vector element) => m element -> m (vector element) many1 m =   do@@ -37,12 +34,12 @@     builder <- manyBuilder m     return (B.build (A.singleton firstElement <> builder)) -{-# INLINABLE sepBy #-}+{-# INLINEABLE sepBy #-} sepBy :: (MonadPlus m, C.Vector vector element) => m element -> m separator -> m (vector element) sepBy elementM separatorM =   mplus (sepBy1 elementM separatorM) (return C.empty) -{-# INLINABLE sepBy1 #-}+{-# INLINEABLE sepBy1 #-} sepBy1 :: (MonadPlus m, C.Vector vector element) => m element -> m separator -> m (vector element) sepBy1 elementM separatorM =   do@@ -52,8 +49,9 @@   where     loop builder =       mplus-        (do-          separatorM-          !element <- elementM-          loop (builder <> A.singleton element))+        ( do+            separatorM+            !element <- elementM+            loop (builder <> A.singleton element)+        )         (return builder)
library/VectorBuilder/Prelude.hs view
@@ -1,12 +1,74 @@ module VectorBuilder.Prelude-(-  module Exports,-  strict,-)+  ( module Exports,+    strict,+  ) where -import BasePrelude as Exports hiding ((<>))-import Data.Semigroup as Exports (Semigroup(..))+import Control.Applicative as Exports+import Control.Arrow as Exports hiding (first, second)+import Control.Category as Exports+import Control.Concurrent as Exports+import Control.Exception as Exports+import Control.Monad as Exports hiding (fail, forM, forM_, mapM, mapM_, msum, sequence, sequence_)+import Control.Monad.Fail as Exports+import Control.Monad.Fix as Exports hiding (fix)+import Control.Monad.IO.Class as Exports+import Control.Monad.ST as Exports+import Data.Bifunctor as Exports+import Data.Bits as Exports+import Data.Bool as Exports+import Data.Char as Exports+import Data.Coerce as Exports+import Data.Complex as Exports+import Data.Data as Exports+import Data.Dynamic as Exports+import Data.Either as Exports+import Data.Fixed as Exports+import Data.Foldable as Exports hiding (toList)+import Data.Function as Exports hiding (id, (.))+import Data.Functor as Exports hiding (unzip)+import Data.Functor.Compose as Exports+import Data.IORef as Exports+import Data.Int as Exports+import Data.Ix as Exports+import Data.List as Exports hiding (all, and, any, concat, concatMap, elem, find, foldl, foldl', foldl1, foldr, foldr1, isSubsequenceOf, mapAccumL, mapAccumR, maximum, maximumBy, minimum, minimumBy, notElem, or, product, sortOn, sum, uncons)+import Data.List.NonEmpty as Exports (NonEmpty (..))+import Data.Maybe as Exports+import Data.Monoid as Exports hiding (Alt)+import Data.Ord as Exports+import Data.Proxy as Exports+import Data.Ratio as Exports+import Data.STRef as Exports+import Data.Semigroup as Exports (Semigroup (..))+import Data.String as Exports+import Data.Traversable as Exports+import Data.Tuple as Exports+import Data.Unique as Exports+import Data.Version as Exports+import Data.Void as Exports+import Data.Word as Exports+import Debug.Trace as Exports+import Foreign.ForeignPtr as Exports+import Foreign.Ptr as Exports+import Foreign.StablePtr as Exports+import Foreign.Storable as Exports+import GHC.Conc as Exports hiding (orElse, threadWaitRead, threadWaitReadSTM, threadWaitWrite, threadWaitWriteSTM, withMVar)+import GHC.Exts as Exports (IsList (..), groupWith, inline, lazy, sortWith)+import GHC.Generics as Exports (Generic)+import GHC.IO.Exception as Exports+import Numeric as Exports+import System.Environment as Exports+import System.Exit as Exports+import System.IO+import System.IO.Error as Exports+import System.IO.Unsafe as Exports+import System.Mem as Exports+import System.Mem.StableName as Exports+import System.Timeout as Exports+import Text.Printf as Exports (hPrintf, printf)+import Text.Read as Exports (Read (..), readEither, readMaybe)+import Unsafe.Coerce as Exports+import Prelude as Exports hiding (all, and, any, concat, concatMap, elem, fail, foldl, foldl1, foldr, foldr1, id, mapM, mapM_, maximum, minimum, notElem, or, product, sequence, sequence_, sum, (.))  {-# INLINE strict #-} strict :: a -> a
library/VectorBuilder/Vector.hs view
@@ -1,19 +1,17 @@ -- | -- Extensions to the standard immutable Vector API.-module VectorBuilder.Vector-where+module VectorBuilder.Vector where -import VectorBuilder.Prelude import Data.Vector.Generic import qualified VectorBuilder.Core.Builder as A import qualified VectorBuilder.MVector as B-+import VectorBuilder.Prelude  -- | -- Construct an immutable vector from a builder.--- +-- -- Supports all kinds of vectors: boxed, unboxed, primitive, storable. {-# INLINE build #-}-build :: Vector vector element => A.Builder element -> vector element+build :: (Vector vector element) => A.Builder element -> vector element build builder =   runST (B.build builder >>= unsafeFreeze)
tests/Main.hs view
@@ -1,61 +1,58 @@ module Main where -import Prelude+import qualified Data.Attoparsec.Text as D+import qualified Data.Text as G+import qualified Data.Vector as E+import qualified Main.Sample as C import Test.Tasty-import Test.Tasty.Runners import Test.Tasty.HUnit import Test.Tasty.QuickCheck-import qualified VectorBuilder.Builder as A-import qualified VectorBuilder.Vector as B import qualified VectorBuilder.Alternative as F+import qualified VectorBuilder.Builder as A import qualified VectorBuilder.MonadPlus as H-import qualified Main.Sample as C-import qualified Data.Attoparsec.Text as D-import qualified Data.Vector as E-import qualified Data.Text as G-+import qualified VectorBuilder.Vector as B+import Prelude +main :: IO () main =-  defaultMain $-  testGroup "All tests"-  [-    testProperty "samples" $ \(samples :: [C.Sample Int]) ->-      foldMap C.toVector samples ===-      B.build (foldMap C.toBuilder samples)-    ,-    testCase "Alternative.some" $ assertEqual ""-      (Right (E.fromList "1234"))-      (D.parseOnly (F.some D.anyChar) "1234")-    ,-    testCase "Alternative.some on empty" $ assertEqual ""-      (Left "not enough input")-      (D.parseOnly (F.some D.anyChar :: D.Parser (Vector Char)) "")-    ,-    testProperty "mconcat" $ \(samples :: [C.Sample Int]) ->-      foldMap C.toVector samples ===-      B.build (mconcat (map C.toBuilder samples))-    ,-    testProperty "foldable" $ \(elements :: [Int]) ->-      E.fromList elements ===-      B.build (A.foldable elements)-    ,-    testGroup "MonadPlus"-    [-      testProperty "many" $ \(elements :: [Char]) ->-        Right (E.fromList elements) ===-        D.parseOnly (H.many D.anyChar) (fromString elements)-      ,-      testProperty "many1" $ \(elements :: [Char]) ->-        (if null elements-          then Left "not enough input"-          else Right (E.fromList elements)) ===-        D.parseOnly (H.many1 D.anyChar) (fromString elements)-      ,-      testProperty "sepBy1" $ \(elements :: [Char]) ->-        (if null elements-          then Left "not enough input"-          else Right (E.fromList elements)) ===-        D.parseOnly (H.sepBy1 D.anyChar (D.char ',')) (G.intersperse ',' (fromString elements))-    ]-  ]-+  defaultMain+    $ testGroup+      "All tests"+      [ testProperty "samples" $ \(samples :: [C.Sample Int]) ->+          foldMap C.toVector samples+            === B.build (foldMap C.toBuilder samples),+        testCase "Alternative.some"+          $ assertEqual+            ""+            (Right (E.fromList "1234"))+            (D.parseOnly (F.some D.anyChar) "1234"),+        testCase "Alternative.some on empty"+          $ assertEqual+            ""+            (Left "not enough input")+            (D.parseOnly (F.some D.anyChar :: D.Parser (Vector Char)) ""),+        testProperty "mconcat" $ \(samples :: [C.Sample Int]) ->+          foldMap C.toVector samples+            === B.build (mconcat (map C.toBuilder samples)),+        testProperty "foldable" $ \(elements :: [Int]) ->+          E.fromList elements+            === B.build (A.foldable elements),+        testGroup+          "MonadPlus"+          [ testProperty "many" $ \(elements :: [Char]) ->+              Right (E.fromList elements)+                === D.parseOnly (H.many D.anyChar) (fromString elements),+            testProperty "many1" $ \(elements :: [Char]) ->+              ( if null elements+                  then Left "not enough input"+                  else Right (E.fromList elements)+              )+                === D.parseOnly (H.many1 D.anyChar) (fromString elements),+            testProperty "sepBy1" $ \(elements :: [Char]) ->+              ( if null elements+                  then Left "not enough input"+                  else Right (E.fromList elements)+              )+                === D.parseOnly (H.sepBy1 D.anyChar (D.char ',')) (G.intersperse ',' (fromString elements))+          ]+      ]
tests/Main/Sample.hs view
@@ -1,17 +1,16 @@ module Main.Sample where -import Prelude-import Test.QuickCheck.Instances-import qualified VectorBuilder.Builder as A import qualified Data.Vector as B+import Test.QuickCheck.Instances () import qualified Test.Tasty.QuickCheck as C-+import qualified VectorBuilder.Builder as A+import Prelude -data Sample a =-  Empty |-  Singleton a |-  Vector (Vector a) |-  List [a]+data Sample a+  = Empty+  | Singleton a+  | Vector (Vector a)+  | List [a]   deriving (Show)  toBuilder :: Sample a -> A.Builder a@@ -30,7 +29,7 @@     Vector a -> a     List a -> B.fromList a -instance C.Arbitrary a => C.Arbitrary (Sample a) where+instance (C.Arbitrary a) => C.Arbitrary (Sample a) where   arbitrary =     do       constructorIndex <- C.choose (0 :: Int, 3)@@ -39,3 +38,4 @@         1 -> C.arbitrary >>= return . Singleton         2 -> C.arbitrary >>= return . Vector         3 -> C.arbitrary >>= return . List+        _ -> error "Bug"
vector-builder.cabal view
@@ -1,9 +1,7 @@-name:-  vector-builder-version:-  0.3.7.2-synopsis:-  Vector builder+cabal-version: 3.0+name:          vector-builder+version:       0.3.8.7+synopsis:      Vector builder description:   An API for efficient and convenient construction of vectors.   It provides the composable `Builder` abstraction, which has instances of the `Monoid` and `Semigroup` classes.@@ -31,75 +29,126 @@   >      B.vector vector <>   >      B.foldable list <>   >      B.singleton element-category:-  Vector-homepage:-  https://github.com/nikita-volkov/vector-builder-bug-reports:-  https://github.com/nikita-volkov/vector-builder/issues-author:-  Nikita Volkov <nikita.y.volkov@mail.ru>-maintainer:-  Nikita Volkov <nikita.y.volkov@mail.ru>-copyright:-  (c) 2016, Nikita Volkov-license:-  MIT-license-file:-  LICENSE-build-type:-  Simple-cabal-version:-  >=1.10 +category:      Vector+homepage:      https://github.com/nikita-volkov/vector-builder+bug-reports:   https://github.com/nikita-volkov/vector-builder/issues+author:        Nikita Volkov <nikita.y.volkov@mail.ru>+maintainer:    Nikita Volkov <nikita.y.volkov@mail.ru>+copyright:     (c) 2016, Nikita Volkov+license:       MIT+license-file:  LICENSE+ source-repository head-  type:-    git-  location:-    git://github.com/nikita-volkov/vector-builder.git+  type:     git+  location: https://github.com/nikita-volkov/vector-builder  library-  hs-source-dirs:-    library+  hs-source-dirs:     library   default-extensions:-    Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples-  default-language:-    Haskell2010+    NoImplicitPrelude+    NoMonomorphismRestriction+    Arrows+    BangPatterns+    ConstraintKinds+    DataKinds+    DefaultSignatures+    DeriveDataTypeable+    DeriveFoldable+    DeriveFunctor+    DeriveGeneric+    DeriveTraversable+    EmptyDataDecls+    FlexibleContexts+    FlexibleInstances+    FunctionalDependencies+    GADTs+    GeneralizedNewtypeDeriving+    LambdaCase+    LiberalTypeSynonyms+    MagicHash+    MultiParamTypeClasses+    MultiWayIf+    OverloadedStrings+    ParallelListComp+    PatternGuards+    QuasiQuotes+    RankNTypes+    RecordWildCards+    ScopedTypeVariables+    StandaloneDeriving+    TemplateHaskell+    TupleSections+    TypeFamilies+    TypeOperators+    UnboxedTuples++  default-language:   Haskell2010   exposed-modules:+    VectorBuilder.Alternative     VectorBuilder.Builder+    VectorBuilder.MonadPlus     VectorBuilder.MVector     VectorBuilder.Vector-    VectorBuilder.MonadPlus-    VectorBuilder.Alternative+   other-modules:-    VectorBuilder.Prelude-    VectorBuilder.Core.Update     VectorBuilder.Core.Builder+    VectorBuilder.Core.Update+    VectorBuilder.Prelude+   build-depends:-    vector >=0.11 && <0.13,-    semigroups >=0.16 && <0.20,-    base-prelude <2,-    base >=4.8 && <5+    , base >=4.10 && <5+    , vector >=0.12 && <0.14  test-suite tests-  type:-    exitcode-stdio-1.0-  hs-source-dirs:-    tests-  main-is:-    Main.hs-  other-modules:-    Main.Sample+  type:               exitcode-stdio-1.0+  hs-source-dirs:     tests+  main-is:            Main.hs+  other-modules:      Main.Sample   default-extensions:-    Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples-  default-language:-    Haskell2010+    NoImplicitPrelude+    NoMonomorphismRestriction+    Arrows+    BangPatterns+    ConstraintKinds+    DataKinds+    DefaultSignatures+    DeriveDataTypeable+    DeriveFoldable+    DeriveFunctor+    DeriveGeneric+    DeriveTraversable+    EmptyDataDecls+    FlexibleContexts+    FlexibleInstances+    FunctionalDependencies+    GADTs+    GeneralizedNewtypeDeriving+    LambdaCase+    LiberalTypeSynonyms+    MagicHash+    MultiParamTypeClasses+    MultiWayIf+    OverloadedStrings+    ParallelListComp+    PatternGuards+    QuasiQuotes+    RankNTypes+    RecordWildCards+    ScopedTypeVariables+    StandaloneDeriving+    TemplateHaskell+    TupleSections+    TypeFamilies+    TypeOperators+    UnboxedTuples++  default-language:   Haskell2010   build-depends:-    attoparsec >=0.13 && <0.14,-    QuickCheck >=2.8.1 && <3,-    quickcheck-instances >=0.3.11 && <0.4,-    rerebase <2,-    tasty >=0.12 && <2,-    tasty-hunit >=0.9 && <0.11,-    tasty-quickcheck >=0.9 && <0.11,-    vector-builder+    , attoparsec >=0.13 && <0.15+    , quickcheck-instances >=0.3.11 && <0.5+    , rerebase <2+    , tasty >=0.12 && <2+    , tasty-hunit >=0.9 && <0.11+    , tasty-quickcheck >=0.9 && <0.12+    , vector-builder