diff --git a/matrices.cabal b/matrices.cabal
--- a/matrices.cabal
+++ b/matrices.cabal
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                matrices
-version:             0.4.2
+version:             0.4.3
 synopsis:            native matrix based on vector
 description:         This library provide the APIs for creating, indexing,
                      modifying matrices (2d arrays), including dense and
@@ -39,7 +39,7 @@
   -- other-modules:
 
   build-depends:
-      base >=4.0 && <5
+      base >=4.5 && <5
     , vector >=0.9
     , primitive
 
diff --git a/src/Data/Matrix.hs b/src/Data/Matrix.hs
--- a/src/Data/Matrix.hs
+++ b/src/Data/Matrix.hs
@@ -3,8 +3,8 @@
     , module Data.Matrix.Dense.Generic
     )where
 
+import           Data.Matrix.Dense.Generic hiding (Matrix)
 import qualified Data.Matrix.Dense.Generic as MG
-import Data.Matrix.Dense.Generic hiding (Matrix)
-import qualified Data.Vector as V
+import qualified Data.Vector               as V
 
 type Matrix = MG.Matrix V.Vector
diff --git a/src/Data/Matrix/Dense/Generic.hs b/src/Data/Matrix/Dense/Generic.hs
--- a/src/Data/Matrix/Dense/Generic.hs
+++ b/src/Data/Matrix/Dense/Generic.hs
@@ -1,10 +1,10 @@
-{-# LANGUAGE BangPatterns #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE BangPatterns          #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeFamilies          #-}
 module Data.Matrix.Dense.Generic
-    ( 
+    (
     -- * Immutable Matrix
       Matrix(..)
 
@@ -48,7 +48,7 @@
     , fromBlocks
     , isSymmetric
     , force
-    
+
     , Data.Matrix.Dense.Generic.foldl
 
     -- * Mapping
@@ -102,15 +102,15 @@
     , MG.create
     ) where
 
-import Prelude hiding (mapM_, mapM)
-import Control.Arrow ((***), (&&&))
-import Control.Monad (liftM, foldM, foldM_)
-import qualified Data.Foldable as F
-import qualified Data.Vector.Generic as G
-import qualified Data.Vector.Generic.Mutable as GM
+import           Control.Arrow                     ((&&&), (***))
+import           Control.Monad                     (foldM, foldM_, liftM)
+import qualified Data.Foldable                     as F
+import qualified Data.Vector.Generic               as G
+import qualified Data.Vector.Generic.Mutable       as GM
+import           Prelude                           hiding (mapM, mapM_)
 
-import qualified Data.Matrix.Generic as MG
-import Data.Matrix.Dense.Generic.Mutable (MMatrix(..))
+import           Data.Matrix.Dense.Generic.Mutable (MMatrix (..))
+import qualified Data.Matrix.Generic               as MG
 
 type instance MG.Mutable Matrix = MMatrix
 
@@ -120,7 +120,7 @@
                          !Int    -- physical row dimension
                          !Int    -- offset
                          !(v a)  -- flat matrix
-    deriving (Show)
+    deriving (Show, Read, Eq)
 
 
 instance G.Vector v a => MG.Matrix Matrix v a where
diff --git a/src/Data/Matrix/Dense/Generic/Mutable.hs b/src/Data/Matrix/Dense/Generic/Mutable.hs
--- a/src/Data/Matrix/Dense/Generic/Mutable.hs
+++ b/src/Data/Matrix/Dense/Generic/Mutable.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 module Data.Matrix.Dense.Generic.Mutable
    ( -- * Mutable Matrix
@@ -13,9 +13,9 @@
    , C.replicate
    ) where
 
-import Prelude hiding (read, replicate)
-import Control.Monad (liftM)
+import           Control.Monad               (liftM)
 import qualified Data.Vector.Generic.Mutable as GM
+import           Prelude                     hiding (read, replicate)
 
 import qualified Data.Matrix.Generic.Mutable as C
 
@@ -39,7 +39,7 @@
 
     replicate (r,c) x = MMatrix r c c 0 `liftM` GM.replicate (r*c) x
     {-# INLINE replicate #-}
-    
+
 takeRow :: GM.MVector v a => MMatrix v m a -> Int -> v m a
 takeRow (MMatrix _ c tda offset vec) i = GM.slice i' c vec
   where
diff --git a/src/Data/Matrix/Generic.hs b/src/Data/Matrix/Generic.hs
--- a/src/Data/Matrix/Generic.hs
+++ b/src/Data/Matrix/Generic.hs
@@ -1,7 +1,7 @@
+{-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE Rank2Types #-}
+{-# LANGUAGE Rank2Types            #-}
+{-# LANGUAGE TypeFamilies          #-}
 module Data.Matrix.Generic
     ( Mutable
     , Matrix(..)
@@ -25,10 +25,10 @@
     , create
     ) where
 
-import Control.Monad.ST (runST, ST)
-import Control.Monad.Primitive (PrimMonad, PrimState)
-import qualified Data.Vector.Generic as G
-import Text.Printf
+import           Control.Monad.Primitive     (PrimMonad, PrimState)
+import           Control.Monad.ST            (ST, runST)
+import qualified Data.Vector.Generic         as G
+import           Text.Printf
 
 import qualified Data.Matrix.Generic.Mutable as MM
 
diff --git a/src/Data/Matrix/Generic/Mutable.hs b/src/Data/Matrix/Generic/Mutable.hs
--- a/src/Data/Matrix/Generic/Mutable.hs
+++ b/src/Data/Matrix/Generic/Mutable.hs
@@ -1,5 +1,5 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeFamilies          #-}
 
 module Data.Matrix.Generic.Mutable
     ( MMatrix(..)
@@ -7,9 +7,9 @@
     , read
     ) where
 
-import Prelude hiding (read)
-import Control.Monad.Primitive (PrimMonad, PrimState)
+import           Control.Monad.Primitive     (PrimMonad, PrimState)
 import qualified Data.Vector.Generic.Mutable as GM
+import           Prelude                     hiding (read)
 
 class GM.MVector v a => MMatrix m v a where
     dim ::  m v s a -> (Int, Int)
@@ -29,23 +29,18 @@
 
 write :: (PrimMonad s, MMatrix m v a)
       => m v (PrimState s) a -> (Int, Int) -> a -> s ()
-write mat (i,j) | i >= r || j >= c = error "Index out of bounds"
-                | otherwise = unsafeWrite mat (i,j)
+write mat (i,j)
+    | i < 0 || i >= r || j < 0 || j >= c = error "write: Index out of bounds"
+    | otherwise = unsafeWrite mat (i,j)
   where
     (r,c) = dim mat
 {-# INLINE write #-}
 
 read :: (PrimMonad s, MMatrix m v a)
      => m v (PrimState s) a -> (Int, Int) -> s a
-read mat (i,j) | i >= r || j >= c = error "Index out of bounds"
-               | otherwise = unsafeRead mat (i,j)
+read mat (i,j)
+    | i <0 || i >= r || j < 0 || j >= c = error "read: Index out of bounds"
+    | otherwise = unsafeRead mat (i,j)
   where
     (r,c) = dim mat
 {-# INLINE read #-}
-
-{-
-replicate :: (PrimMonad s, MMatrix m v a)
-          => (Int, Int) -> a -> s (m v (PrimState s) a)
-replicate (r,c) x = do
-    mat <- new (r,c)
- -}   
diff --git a/src/Data/Matrix/Mutable.hs b/src/Data/Matrix/Mutable.hs
--- a/src/Data/Matrix/Mutable.hs
+++ b/src/Data/Matrix/Mutable.hs
@@ -3,8 +3,8 @@
     , module Data.Matrix.Dense.Generic.Mutable
     ) where
 
+import           Data.Matrix.Dense.Generic.Mutable hiding (MMatrix)
 import qualified Data.Matrix.Dense.Generic.Mutable as MG
-import Data.Matrix.Dense.Generic.Mutable hiding (MMatrix)
-import qualified Data.Vector.Mutable as VM
+import qualified Data.Vector.Mutable               as VM
 
 type MMatrix a = MG.MMatrix VM.MVector a
diff --git a/src/Data/Matrix/Sparse/Generic.hs b/src/Data/Matrix/Sparse/Generic.hs
--- a/src/Data/Matrix/Sparse/Generic.hs
+++ b/src/Data/Matrix/Sparse/Generic.hs
@@ -1,8 +1,8 @@
-{-# LANGUAGE BangPatterns #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE BangPatterns          #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeFamilies          #-}
 module Data.Matrix.Sparse.Generic
     ( Zero(..)
     , CSR(..)
@@ -38,17 +38,17 @@
     , MG.toLists
     ) where
 
-import Control.Applicative ((<$>))
-import Control.Monad (when, forM_, foldM)
-import Control.Monad.ST (runST)
-import qualified Data.Vector.Generic as G
-import qualified Data.Vector.Generic.Mutable as GM
-import qualified Data.Vector.Unboxed as U
-import Data.Bits (shiftR)
-import Text.Printf (printf)
+import           Control.Applicative               ((<$>))
+import           Control.Monad                     (foldM, forM_, when)
+import           Control.Monad.ST                  (runST)
+import           Data.Bits                         (shiftR)
+import qualified Data.Vector.Generic               as G
+import qualified Data.Vector.Generic.Mutable       as GM
+import qualified Data.Vector.Unboxed               as U
+import           Text.Printf                       (printf)
 
-import qualified Data.Matrix.Generic as MG
-import Data.Matrix.Dense.Generic.Mutable (MMatrix)
+import           Data.Matrix.Dense.Generic.Mutable (MMatrix)
+import qualified Data.Matrix.Generic               as MG
 
 class Eq a => Zero a where
     zero :: a
@@ -131,7 +131,7 @@
         col <- GM.new n
         row <- GM.new (r+1)
 
-        ((i,_),_) <- foldM (f v col row) ((-1,-1),0) al 
+        ((i,_),_) <- foldM (f v col row) ((-1,-1),0) al
 
         let stride = r - i
         forM_ [0..stride-1] $ \s -> GM.write row (r-s) n
@@ -147,11 +147,11 @@
                GM.write col acc j
                let stride = i - i'
                when (stride > 0) $ forM_ [0..stride-1] $ \s -> GM.write row (i-s) acc
-                                                                                                                                  
+
                return ((i,j), acc+1)
            else error $ printf "Input must be sorted by row and then by column: (%d,%d) >= (%d,%d)" i' j' i j
 {-# INLINE fromAscAL #-}
-    
+
 binarySearchByBounds :: U.Vector Int -> Int -> Int -> Int -> Maybe Int
 binarySearchByBounds vec x = loop
   where
diff --git a/src/Data/Matrix/Storable.hs b/src/Data/Matrix/Storable.hs
--- a/src/Data/Matrix/Storable.hs
+++ b/src/Data/Matrix/Storable.hs
@@ -3,8 +3,8 @@
     , module Data.Matrix.Dense.Generic
     ) where
 
+import           Data.Matrix.Dense.Generic hiding (Matrix)
 import qualified Data.Matrix.Dense.Generic as MG
-import Data.Matrix.Dense.Generic hiding (Matrix)
-import qualified Data.Vector.Storable as V
+import qualified Data.Vector.Storable      as V
 
 type Matrix a = MG.Matrix V.Vector a
diff --git a/src/Data/Matrix/Storable/Mutable.hs b/src/Data/Matrix/Storable/Mutable.hs
--- a/src/Data/Matrix/Storable/Mutable.hs
+++ b/src/Data/Matrix/Storable/Mutable.hs
@@ -3,8 +3,8 @@
     , module Data.Matrix.Dense.Generic.Mutable
     ) where
 
+import           Data.Matrix.Dense.Generic.Mutable hiding (MMatrix)
 import qualified Data.Matrix.Dense.Generic.Mutable as MG
-import Data.Matrix.Dense.Generic.Mutable hiding (MMatrix)
-import qualified Data.Vector.Storable.Mutable as VM
+import qualified Data.Vector.Storable.Mutable      as VM
 
 type MMatrix a = MG.MMatrix VM.MVector a
diff --git a/src/Data/Matrix/Symmetric.hs b/src/Data/Matrix/Symmetric.hs
--- a/src/Data/Matrix/Symmetric.hs
+++ b/src/Data/Matrix/Symmetric.hs
@@ -1,8 +1,8 @@
+{-# LANGUAGE BangPatterns          #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE TypeFamilies          #-}
 module Data.Matrix.Symmetric
     ( SymMatrix(..)
     , dim
@@ -25,13 +25,14 @@
     , zipWith
     ) where
 
-import Prelude hiding (zip, zipWith)
-import Control.Monad (liftM)
-import Data.Bits (shiftR)
-import qualified Data.Vector.Generic as G
+import           Control.Monad                 (liftM)
+import           Data.Bits                     (shiftR)
+import qualified Data.Vector.Generic           as G
+import           Prelude                       hiding (zip, zipWith)
 
-import Data.Matrix.Generic
-import Data.Matrix.Symmetric.Mutable (SymMMatrix(..), unsafeWrite, new)
+import           Data.Matrix.Generic
+import           Data.Matrix.Symmetric.Mutable (SymMMatrix (..), new,
+                                                unsafeWrite)
 
 type instance Mutable SymMatrix = SymMMatrix
 
diff --git a/src/Data/Matrix/Symmetric/Mutable.hs b/src/Data/Matrix/Symmetric/Mutable.hs
--- a/src/Data/Matrix/Symmetric/Mutable.hs
+++ b/src/Data/Matrix/Symmetric/Mutable.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 module Data.Matrix.Symmetric.Mutable
    ( -- * Mutable Matrix
@@ -12,10 +12,10 @@
    , C.replicate
    ) where
 
-import Prelude hiding (read, replicate)
-import Control.Monad (liftM)
-import Data.Bits (shiftR)
+import           Control.Monad               (liftM)
+import           Data.Bits                   (shiftR)
 import qualified Data.Vector.Generic.Mutable as GM
+import           Prelude                     hiding (read, replicate)
 
 import qualified Data.Matrix.Generic.Mutable as C
 
diff --git a/src/Data/Matrix/Unboxed.hs b/src/Data/Matrix/Unboxed.hs
--- a/src/Data/Matrix/Unboxed.hs
+++ b/src/Data/Matrix/Unboxed.hs
@@ -3,8 +3,8 @@
     , module Data.Matrix.Dense.Generic
     ) where
 
+import           Data.Matrix.Dense.Generic hiding (Matrix)
 import qualified Data.Matrix.Dense.Generic as MG
-import Data.Matrix.Dense.Generic hiding (Matrix)
-import qualified Data.Vector.Unboxed as V
+import qualified Data.Vector.Unboxed       as V
 
 type Matrix a = MG.Matrix V.Vector a
diff --git a/src/Data/Matrix/Unboxed/Mutable.hs b/src/Data/Matrix/Unboxed/Mutable.hs
--- a/src/Data/Matrix/Unboxed/Mutable.hs
+++ b/src/Data/Matrix/Unboxed/Mutable.hs
@@ -3,8 +3,8 @@
     , module Data.Matrix.Dense.Generic.Mutable
     ) where
 
+import           Data.Matrix.Dense.Generic.Mutable hiding (MMatrix)
 import qualified Data.Matrix.Dense.Generic.Mutable as MG
-import Data.Matrix.Dense.Generic.Mutable hiding (MMatrix)
-import qualified Data.Vector.Unboxed.Mutable as VM
+import qualified Data.Vector.Unboxed.Mutable       as VM
 
 type MMatrix a = MG.MMatrix VM.MVector a