packages feed

vector-builder 0.3.6 → 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,30 +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 --{-# INLINABLE many #-}-many :: Alternative m => m a -> m (Vector a)+{-# 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 #-}-some :: Alternative m => m a -> m (Vector a)+{-# 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,10 +1,11 @@ module VectorBuilder.Builder-(-  Builder,-  empty,-  singleton,-  vector,-)+  ( Builder,+    empty,+    singleton,+    size,+    vector,+    foldable,+  ) where  import VectorBuilder.Core.Builder
library/VectorBuilder/Core/Builder.hs view
@@ -1,18 +1,21 @@-module VectorBuilder.Core.Builder-where+module VectorBuilder.Core.Builder where -import VectorBuilder.Prelude hiding (empty)-import qualified VectorBuilder.Core.Update as A import qualified Data.Vector.Generic as B-+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 @@ -32,13 +35,17 @@  -- | -- 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 =+  Builder (length foldable) (A.writeFoldable foldable)  -- * Updates @@ -62,6 +69,23 @@ append =   flip prepend +{-# INLINE concat #-}+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+        )+    )  -- * Instances @@ -71,6 +95,8 @@   {-# INLINE (<>) #-}   (<>) =     prepend+  sconcat =+    concat  -- | -- Provides support for /O(1)/ concatenation.@@ -81,5 +107,6 @@   {-# INLINE mappend #-}   mappend =     (<>)--+  {-# 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) @@ -28,3 +26,8 @@ empty :: Update element empty =   Update (\_ _ -> pure ())++{-# INLINE writeFoldable #-}+writeFoldable :: (Foldable foldable) => foldable element -> Update element+writeFoldable 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,41 +1,57 @@-{-|-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 --{-# INLINABLE many #-}-many :: MonadPlus m => m a -> m (Vector a)+{-# INLINEABLE many #-}+many :: (MonadPlus m, C.Vector vector element) => m element -> m (vector element) many m =-  liftM B.build loop+  liftM B.build (manyBuilder m)++{-# INLINEABLE manyBuilder #-}+manyBuilder :: (MonadPlus m) => m element -> m (A.Builder element)+manyBuilder m =+  loop mempty   where-    loop =+    loop !builder =       mplus-        (do-          !element <- m-          remainders <- loop-          return (A.singleton element <> remainders))-        (return mempty)+        ( do+            !element <- m+            loop (builder <> A.singleton element)+        )+        (return builder) -{-# INLINABLE sepBy #-}-sepBy :: MonadPlus m => m element -> m separator -> m (Vector element)+{-# INLINEABLE many1 #-}+many1 :: (MonadPlus m, C.Vector vector element) => m element -> m (vector element)+many1 m =+  do+    firstElement <- m+    builder <- manyBuilder m+    return (B.build (A.singleton firstElement <> builder))++{-# INLINEABLE sepBy #-}+sepBy :: (MonadPlus m, C.Vector vector element) => m element -> m separator -> m (vector element) sepBy elementM separatorM =-  mplus (sepBy1 elementM separatorM) (return mempty)+  mplus (sepBy1 elementM separatorM) (return C.empty) -{-# INLINABLE sepBy1 #-}-sepBy1 :: MonadPlus m => m element -> m separator -> m (Vector element)+{-# INLINEABLE sepBy1 #-}+sepBy1 :: (MonadPlus m, C.Vector vector element) => m element -> m separator -> m (vector element) sepBy1 elementM separatorM =-  liftM B.build loop+  do+    firstElement <- elementM+    builder <- loop (A.singleton firstElement)+    return (B.build builder)   where-    loop =-      do-        !element <- elementM-        remainders <- mplus (separatorM >> loop) (return mempty)-        return (A.singleton element <> remainders)+    loop builder =+      mplus+        ( 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,32 +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.Alternative as F import qualified VectorBuilder.Builder as A+import qualified VectorBuilder.MonadPlus as H import qualified VectorBuilder.Vector as B-import qualified VectorBuilder.Alternative as F-import qualified Main.Sample as C-import qualified Data.Attoparsec.Text as D-import qualified Data.Vector as E-+import Prelude +main :: IO () main =-  defaultMain $-  testGroup "All tests"-  [-    testProperty "" $ \(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) "")-  ]-+  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,16 +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)+data Sample a+  = Empty+  | Singleton a+  | Vector (Vector a)+  | List [a]   deriving (Show)  toBuilder :: Sample a -> A.Builder a@@ -19,6 +19,7 @@     Empty -> A.empty     Singleton a -> A.singleton a     Vector a -> A.vector a+    List a -> A.foldable a  toVector :: Sample a -> Vector a toVector =@@ -26,12 +27,15 @@     Empty -> B.empty     Singleton a -> B.singleton a     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, 2)+      constructorIndex <- C.choose (0 :: Int, 3)       case constructorIndex of         0 -> return Empty         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.6-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.@@ -29,126 +27,128 @@   >  where   >    builder =   >      B.vector vector <>-  >      foldMap B.singleton list <>+  >      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.6 && <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-  build-depends:-    attoparsec >=0.13 && <0.14,-    QuickCheck >=2.8.1 && <3,-    quickcheck-instances >=0.3.11 && <0.4,-    rerebase ==1.*,-    tasty >=1.0.1 && <1.2,-    tasty-hunit >=0.10 && <0.11,-    tasty-quickcheck >=0.10 && <0.11,-    vector-builder---- benchmark foldl-benchmark---   type:---     exitcode-stdio-1.0---   hs-source-dirs:---     foldl-benchmark---   main-is:---     Main.hs---   ghc-options:---     -O2---     -threaded---     "-with-rtsopts=-N"---     -rtsopts---   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---   build-depends:---     vector-builder,---     foldl >=1.2 && <2,---     -- benchmarking:---     criterion >=1.1 && <2,---     -- general:---     rerebase <2+    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 --- test-suite foldl-profiling---   type:---     exitcode-stdio-1.0---   hs-source-dirs:---     foldl-profiling---   main-is:---     Main.hs---   ghc-options:---     -O2---     -threaded---     "-with-rtsopts=-N"---     -rtsopts---   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---   build-depends:---     vector-builder,---     foldl >=1.2 && <2,---     -- benchmarking:---     criterion >=1.1 && <2,---     -- general:---     bug ==1.*,---     rerebase <2+  default-language:   Haskell2010+  build-depends:+    , 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