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,28 @@
-{-|
-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 #-}
+{-# INLINEABLE manyBuilder #-}
 manyBuilder :: Alternative m => m a -> m (A.Builder a)
-manyBuilder m = let
-  loop = ((<>) <$> A.singleton <$> m <*> loop) <|> pure mempty
-  in loop
+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 #-}
+{-# 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,12 +1,11 @@
 module VectorBuilder.Builder
-(
-  Builder,
-  empty,
-  singleton,
-  size,
-  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,16 @@
-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.
@@ -21,7 +18,6 @@
 size :: Builder element -> Int
 size (Builder s _) = s
 
-
 -- * Initialisation
 
 -- |
@@ -40,7 +36,7 @@
 
 -- |
 -- 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
@@ -52,7 +48,6 @@
 foldable foldable =
   Builder (length foldable) (A.writeFoldable foldable)
 
-
 -- * Updates
 
 {-# INLINE snoc #-}
@@ -79,13 +74,19 @@
 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
 
@@ -110,4 +111,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
@@ -32,4 +30,4 @@
 {-# 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)
+  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,19 +1,17 @@
 -- |
 -- 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 #-}
+{-# INLINEABLE build #-}
 build :: MVector vector element => A.Builder element -> ST s (vector s element)
 build (A.Builder size (C.Update update)) =
   do
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,33 @@
-{-|
-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 +35,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 +50,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,21 +1,18 @@
 module VectorBuilder.Prelude
-(
-  module Exports,
-  strict,
-)
+  ( module Exports,
+    strict,
+  )
 where
 
--- base
--------------------------
 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, mapM_, sequence_, forM_, msum, mapM, sequence, forM)
-import Control.Monad.IO.Class 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
@@ -31,19 +28,18 @@
 import Data.Function as Exports hiding (id, (.))
 import Data.Functor as Exports
 import Data.Functor.Compose as Exports
-import Data.Functor.Contravariant as Exports
-import Data.Int as Exports
 import Data.IORef as Exports
+import Data.Int as Exports
 import Data.Ix as Exports
-import Data.List as Exports hiding (sortOn, isSubsequenceOf, uncons, concat, foldr, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, find, maximumBy, minimumBy, mapAccumL, mapAccumR, foldl')
-import Data.List.NonEmpty as Exports (NonEmpty(..))
+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.Semigroup as Exports (Semigroup(..))
 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
@@ -56,12 +52,11 @@
 import Foreign.Ptr as Exports
 import Foreign.StablePtr as Exports
 import Foreign.Storable as Exports
-import GHC.Conc as Exports hiding (orElse, withMVar, threadWaitWriteSTM, threadWaitWrite, threadWaitReadSTM, threadWaitRead)
-import GHC.Exts as Exports (lazy, inline, sortWith, groupWith, IsList(..))
+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 Prelude as Exports hiding (fail, concat, foldr, mapM_, sequence_, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, mapM, sequence, id, (.))
 import System.Environment as Exports
 import System.Exit as Exports
 import System.IO
@@ -71,10 +66,11 @@
 import System.Mem.StableName as Exports
 import System.Timeout as Exports
 import Text.ParserCombinators.ReadP as Exports (ReadP, ReadS, readP_to_S, readS_to_P)
-import Text.ParserCombinators.ReadPrec as Exports (ReadPrec, readPrec_to_P, readP_to_Prec, readPrec_to_S, readS_to_Prec)
-import Text.Printf as Exports (printf, hPrintf)
-import Text.Read as Exports (Read(..), readMaybe, readEither)
+import Text.ParserCombinators.ReadPrec as Exports (ReadPrec, readP_to_Prec, readPrec_to_P, readPrec_to_S, readS_to_Prec)
+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,17 +1,15 @@
 -- |
 -- 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
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 Test.Tasty.Runners
 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 =
   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))
-    ]
-  ]
-
+    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
diff --git a/vector-builder.cabal b/vector-builder.cabal
--- a/vector-builder.cabal
+++ b/vector-builder.cabal
@@ -1,7 +1,7 @@
 name:
   vector-builder
 version:
-  0.3.8.2
+  0.3.8.3
 synopsis:
   Vector builder
 description: