diff --git a/indexation.cabal b/indexation.cabal
--- a/indexation.cabal
+++ b/indexation.cabal
@@ -1,5 +1,5 @@
 name: indexation
-version: 0.4.2.1
+version: 0.4.2.2
 category: Data
 synopsis: Tools for entity indexation
 description: A set of tools for indexing entities
@@ -31,7 +31,7 @@
     Indexation.Types
     Indexation.Vector
   build-depends:
-    base >=4.7 && <5,
+    base >=4.11 && <5,
     bytestring >=0.10.8 && <0.11,
     cereal >=0.5.5 && <0.6,
     deferred-folds >=0.6 && <0.7,
diff --git a/library/Indexation/Vector.hs b/library/Indexation/Vector.hs
--- a/library/Indexation/Vector.hs
+++ b/library/Indexation/Vector.hs
@@ -3,8 +3,8 @@
 
 import Indexation.Prelude
 import Data.Vector
-import qualified Data.Vector.Mutable as A
-import qualified Data.HashMap.Strict as B
+import qualified Data.Vector.Mutable as MutableVector
+import qualified Data.HashMap.Strict as HashMap
 import qualified DeferredFolds.UnfoldM as UnfoldM
 import qualified ListT
 
@@ -16,13 +16,13 @@
 populate :: Monad effect => Int -> effect (Int, element) -> effect (Vector element)
 populate size effect =
   do
-    mv <- return (unsafeDupablePerformIO (A.unsafeNew size))
+    mv <- return (unsafeDupablePerformIO (MutableVector.unsafeNew size))
     let
       loop stepsRemaining =
         if stepsRemaining > 0
           then do
             (index, element) <- effect
-            () <- return (unsafeDupablePerformIO (A.write mv index element))
+            () <- return (unsafeDupablePerformIO (MutableVector.write mv index element))
             loop (pred stepsRemaining)
           else do
             !v <- return (unsafeDupablePerformIO (freeze mv))
@@ -35,26 +35,27 @@
 {-# INLINE indexHashMapWithSize #-}
 indexHashMapWithSize :: Int -> HashMap element Int -> Vector element
 indexHashMapWithSize size hashMap =
-  unsafePerformIO $ do
-    mv <- A.unsafeNew size
-    let
-      step () element index = unsafeDupablePerformIO (A.write mv index element)
-      !() = B.foldlWithKey' step () hashMap
-      in freeze mv
+  runST $ do
+    mv <- MutableVector.new size
+    HashMap.foldrWithKey
+      (\ element index action -> MutableVector.write mv index element >> action)
+      (return ())
+      hashMap
+    freeze mv
 
 {-# NOINLINE unfoldM #-}
 unfoldM :: Monad m => Int -> UnfoldM m (Int, element) -> m (Vector element)
 unfoldM size unfoldM =
   let
-    step mv (index, element) = return (unsafeDupablePerformIO (A.write mv index element $> mv))
+    step mv (index, element) = return (unsafeDupablePerformIO (MutableVector.write mv index element $> mv))
     in do
-      !mv <- return (unsafeDupablePerformIO (A.unsafeNew size))
+      !mv <- return (unsafeDupablePerformIO (MutableVector.unsafeNew size))
       UnfoldM.foldlM' step mv unfoldM
       !iv <- return (unsafeDupablePerformIO (unsafeFreeze mv))
       return iv
 
 listTInIO :: Int -> ListT IO (Int, element) -> IO (Vector element)
 listTInIO size listT = do
-  mv <- A.unsafeNew size
-  flip ListT.traverse_ listT $ \ (index, element) -> A.write mv index element
+  mv <- MutableVector.unsafeNew size
+  flip ListT.traverse_ listT $ \ (index, element) -> MutableVector.write mv index element
   unsafeFreeze mv