diff --git a/Setup.hs b/Setup.hs
deleted file mode 100644
--- a/Setup.hs
+++ /dev/null
@@ -1,2 +0,0 @@
-import Distribution.Simple
-main = defaultMain
diff --git a/library/VectorBuilder/Alternative.hs b/library/VectorBuilder/Alternative.hs
--- a/library/VectorBuilder/Alternative.hs
+++ b/library/VectorBuilder/Alternative.hs
@@ -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
diff --git a/library/VectorBuilder/Builder.hs b/library/VectorBuilder/Builder.hs
--- a/library/VectorBuilder/Builder.hs
+++ b/library/VectorBuilder/Builder.hs
@@ -1,10 +1,11 @@
 module VectorBuilder.Builder
-(
-  Builder,
-  empty,
-  singleton,
-  vector,
-)
+  ( Builder,
+    empty,
+    singleton,
+    size,
+    vector,
+    foldable,
+  )
 where
 
 import VectorBuilder.Core.Builder
diff --git a/library/VectorBuilder/Core/Builder.hs b/library/VectorBuilder/Core/Builder.hs
--- a/library/VectorBuilder/Core/Builder.hs
+++ b/library/VectorBuilder/Core/Builder.hs
@@ -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
diff --git a/library/VectorBuilder/Core/Update.hs b/library/VectorBuilder/Core/Update.hs
--- a/library/VectorBuilder/Core/Update.hs
+++ b/library/VectorBuilder/Core/Update.hs
@@ -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)
diff --git a/library/VectorBuilder/MVector.hs b/library/VectorBuilder/MVector.hs
--- a/library/VectorBuilder/MVector.hs
+++ b/library/VectorBuilder/MVector.hs
@@ -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
diff --git a/library/VectorBuilder/MonadPlus.hs b/library/VectorBuilder/MonadPlus.hs
--- a/library/VectorBuilder/MonadPlus.hs
+++ b/library/VectorBuilder/MonadPlus.hs
@@ -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)
diff --git a/library/VectorBuilder/Prelude.hs b/library/VectorBuilder/Prelude.hs
--- a/library/VectorBuilder/Prelude.hs
+++ b/library/VectorBuilder/Prelude.hs
@@ -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
diff --git a/library/VectorBuilder/Vector.hs b/library/VectorBuilder/Vector.hs
--- a/library/VectorBuilder/Vector.hs
+++ b/library/VectorBuilder/Vector.hs
@@ -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)
diff --git a/tests/Main.hs b/tests/Main.hs
--- a/tests/Main.hs
+++ b/tests/Main.hs
@@ -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))
+          ]
+      ]
diff --git a/tests/Main/Sample.hs b/tests/Main/Sample.hs
--- a/tests/Main/Sample.hs
+++ b/tests/Main/Sample.hs
@@ -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"
diff --git a/vector-builder.cabal b/vector-builder.cabal
--- a/vector-builder.cabal
+++ b/vector-builder.cabal
@@ -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