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,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
diff --git a/library/VectorBuilder/Builder.hs b/library/VectorBuilder/Builder.hs
--- a/library/VectorBuilder/Builder.hs
+++ b/library/VectorBuilder/Builder.hs
@@ -1,11 +1,11 @@
 module VectorBuilder.Builder
-(
-  Builder,
-  empty,
-  singleton,
-  vector,
-  foldable,
-)
+  ( 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,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
-
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)
 
@@ -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)
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,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)
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,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))
+          ]
+      ]
diff --git a/tests/Main/Sample.hs b/tests/Main/Sample.hs
--- a/tests/Main/Sample.hs
+++ b/tests/Main/Sample.hs
@@ -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"
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.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