diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,9 @@
 # Change Log
 
+## [1.0.3.0] - 2018-06-24
+
+- Remove redundant KnownNat constraints
+
 ## [1.0.2.0] - 2018-05-15
 
 - `not-home` haddock annotations for Internal modules, for more helpful linking
diff --git a/src/Data/Vector/Generic/Mutable/Sized.hs b/src/Data/Vector/Generic/Mutable/Sized.hs
--- a/src/Data/Vector/Generic/Mutable/Sized.hs
+++ b/src/Data/Vector/Generic/Mutable/Sized.hs
@@ -3,6 +3,7 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE RankNTypes #-}
 
@@ -87,6 +88,8 @@
 import Data.Vector.Generic.Mutable.Sized.Internal
 import GHC.TypeLits
 import Data.Finite
+import Data.Finite.Internal
+import Data.Maybe
 import Data.Proxy
 import Control.Monad.Primitive
 import Prelude hiding ( length, null, replicate, init,
@@ -97,28 +100,28 @@
 -- ** Length information
 
 -- | /O(1)/ Yield the length of the mutable vector as an 'Int'.
-length :: forall v n s a. (KnownNat n)
+length :: forall v n s a. KnownNat n
        => MVector v n s a -> Int
 length _ = fromInteger (natVal (Proxy :: Proxy n))
 {-# inline length #-}
 
 -- | /O(1)/ Yield the length of the mutable vector as a 'Proxy'.
-length' :: forall v n s a. (KnownNat n)
+length' :: forall v n s a. ()
         => MVector v n s a -> Proxy n
 length' _ = Proxy
 {-# inline length' #-}
 
 -- | /O(1)/ Check whether the mutable vector is empty
-null :: forall v n s a. (KnownNat n)
+null :: forall v n s a. KnownNat n
        => MVector v n s a -> Bool
-null = (== 0) . length
+null _ = isJust $ Proxy @n `sameNat` Proxy @0
 {-# inline null #-}
 
 -- ** Extracting subvectors
 
 -- | /O(1)/ Yield a slice of the mutable vector without copying it with an
 -- inferred length argument.
-slice :: forall v i n k s a p. (KnownNat i, KnownNat n, KnownNat k, VGM.MVector v a)
+slice :: forall v i n k s a p. (KnownNat i, KnownNat n, VGM.MVector v a)
       => p i -- ^ starting index
       -> MVector v (i+n+k) s a
       -> MVector v n s a
@@ -130,7 +133,7 @@
 -- | /O(1)/ Yield a slice of the mutable vector without copying it with an
 -- explicit length argument.
 slice' :: forall v i n k s a p
-        . (KnownNat i, KnownNat n, KnownNat k, VGM.MVector v a)
+        . (KnownNat i, KnownNat n, VGM.MVector v a)
        => p i -- ^ starting index
        -> p n -- ^ length
        -> MVector v (i+n+k) s a
@@ -140,14 +143,14 @@
 
 -- | /O(1)/ Yield all but the last element of a non-empty mutable vector
 -- without copying.
-init :: forall v n s a. (VGM.MVector v a)
+init :: forall v n s a. VGM.MVector v a
      => MVector v (n+1) s a -> MVector v n s a
 init (MVector v) = MVector (VGM.unsafeInit v)
 {-# inline init #-}
 
 -- | /O(1)/ Yield all but the first element of a non-empty mutable vector
 -- without copying.
-tail :: forall v n s a. (VGM.MVector v a)
+tail :: forall v n s a. VGM.MVector v a
      => MVector v (1+n) s a -> MVector v n s a
 tail (MVector v) = MVector (VGM.unsafeTail v)
 {-# inline tail #-}
@@ -155,7 +158,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is inferred from the
 -- type.
-take :: forall v n k s a. (KnownNat n, KnownNat k, VGM.MVector v a)
+take :: forall v n k s a. (KnownNat n, VGM.MVector v a)
      => MVector v (n+k) s a -> MVector v n s a
 take (MVector v) = MVector (VGM.unsafeTake i v)
   where i = fromInteger (natVal (Proxy :: Proxy n))
@@ -164,7 +167,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is given explicitly
 -- as a 'Proxy' argument.
-take' :: forall v n k s a p. (KnownNat n, KnownNat k, VGM.MVector v a)
+take' :: forall v n k s a p. (KnownNat n, VGM.MVector v a)
       => p n -> MVector v (n+k) s a -> MVector v n s a
 take' _ = take
 {-# inline take' #-}
@@ -172,7 +175,7 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- inferred from the type.
-drop :: forall v n k s a. (KnownNat n, KnownNat k, VGM.MVector v a)
+drop :: forall v n k s a. (KnownNat n, VGM.MVector v a)
      => MVector v (n+k) s a -> MVector v k s a
 drop (MVector v) = MVector (VGM.unsafeDrop i v)
   where i = fromInteger (natVal (Proxy :: Proxy n))
@@ -181,14 +184,14 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- givel explicitly as a 'Proxy' argument.
-drop' :: forall v n k s a p. (KnownNat n, KnownNat k, VGM.MVector v a)
+drop' :: forall v n k s a p. (KnownNat n, VGM.MVector v a)
       => p n -> MVector v (n+k) s a -> MVector v k s a
 drop' _ = drop
 {-# inline drop' #-}
 
 -- | /O(1)/ Yield the first n elements paired with the remainder without copying.
 -- The lengths of the resultant vector are inferred from the type.
-splitAt :: forall v n m s a. (KnownNat n, KnownNat m, VGM.MVector v a)
+splitAt :: forall v n m s a. (KnownNat n, VGM.MVector v a)
         => MVector v (n+m) s a -> (MVector v n s a, MVector v m s a)
 splitAt (MVector v) = (MVector a, MVector b)
   where i = fromInteger (natVal (Proxy :: Proxy n))
@@ -198,7 +201,7 @@
 -- | /O(1)/ Yield the first n elements paired with the remainder without
 -- copying.  The length of the first resultant vector is passed explicitly as a
 -- 'Proxy' argument.
-splitAt' :: forall v n m s a p. (KnownNat n, KnownNat m, VGM.MVector v a)
+splitAt' :: forall v n m s a p. (KnownNat n, VGM.MVector v a)
          => p n -> MVector v (n+m) s a -> (MVector v n s a, MVector v m s a)
 splitAt' _ = splitAt
 {-# inline splitAt' #-}
@@ -208,7 +211,7 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- inferred from the type.
-overlaps :: forall v n k s a. (KnownNat n, KnownNat k, VGM.MVector v a)
+overlaps :: forall v n k s a. VGM.MVector v a
          => MVector v n s a
          -> MVector v k s a
          -> Bool
@@ -295,92 +298,92 @@
 -- * Accessing individual elements
 
 -- | /O(1)/ Yield the element at a given type-safe position using 'Finite'.
-read :: forall v n m a. (KnownNat n, PrimMonad m, VGM.MVector v a)
+read :: forall v n m a. (PrimMonad m, VGM.MVector v a)
       => MVector v n (PrimState m) a -> Finite n -> m a
-read (MVector v) i = v `VGM.unsafeRead` fromIntegral i
+read (MVector v) (Finite i) = v `VGM.unsafeRead` fromIntegral i
 {-# inline read #-}
 
 -- | /O(1)/ Yield the element at a given type-safe position using 'Proxy'.
-read' :: forall v n k a m p. (KnownNat n, KnownNat k, PrimMonad m, VGM.MVector v a)
+read' :: forall v n k a m p. (KnownNat k, PrimMonad m, VGM.MVector v a)
        => MVector v (n+k+1) (PrimState m) a -> p k -> m a
 read' (MVector v) p = v `VGM.unsafeRead` fromInteger (natVal p)
 {-# inline read' #-}
 
 -- | /O(1)/ Yield the element at a given 'Int' position without bounds
 -- checking.
-unsafeRead :: forall v n a m. (KnownNat n, PrimMonad m, VGM.MVector v a)
+unsafeRead :: forall v n a m. (PrimMonad m, VGM.MVector v a)
            => MVector v n (PrimState m) a -> Int -> m a
 unsafeRead (MVector v) i = v `VGM.unsafeRead` i
 {-# inline unsafeRead #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position using 'Finite'.
-write :: forall v n m a. (KnownNat n, PrimMonad m, VGM.MVector v a)
+write :: forall v n m a. (PrimMonad m, VGM.MVector v a)
       => MVector v n (PrimState m) a -> Finite n -> a -> m ()
-write (MVector v) i = VGM.unsafeWrite v (fromIntegral i)
+write (MVector v) (Finite i) = VGM.unsafeWrite v (fromIntegral i)
 {-# inline write #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position using 'Proxy'.
-write' :: forall v n k a m p. (KnownNat n, KnownNat k, PrimMonad m, VGM.MVector v a)
+write' :: forall v n k a m p. (KnownNat k, PrimMonad m, VGM.MVector v a)
        => MVector v (n+k+1) (PrimState m) a -> p k -> a -> m ()
 write' (MVector v) p = VGM.unsafeWrite v (fromInteger (natVal p))
 {-# inline write' #-}
 
 -- | /O(1)/ Replace the element at a given 'Int' position without bounds
 -- checking.
-unsafeWrite :: forall v n m a. (KnownNat n, PrimMonad m, VGM.MVector v a)
+unsafeWrite :: forall v n m a. (PrimMonad m, VGM.MVector v a)
       => MVector v n (PrimState m) a -> Int -> a -> m ()
 unsafeWrite (MVector v) = VGM.unsafeWrite v
 {-# inline unsafeWrite #-}
 
 -- | /O(1)/ Modify the element at a given type-safe position using 'Finite'.
-modify :: forall v n m a. (KnownNat n, PrimMonad m, VGM.MVector v a)
+modify :: forall v n m a. (PrimMonad m, VGM.MVector v a)
        => MVector v n (PrimState m) a -> (a -> a) -> Finite n -> m ()
-modify (MVector v) f i = VGM.unsafeModify v f (fromIntegral i)
+modify (MVector v) f (Finite i) = VGM.unsafeModify v f (fromIntegral i)
 {-# inline modify #-}
 
 -- | /O(1)/ Modify the element at a given type-safe position using 'Proxy'.
-modify' :: forall v n k a m p. (KnownNat n, KnownNat k, PrimMonad m, VGM.MVector v a)
+modify' :: forall v n k a m p. (KnownNat k, PrimMonad m, VGM.MVector v a)
         => MVector v (n+k+1) (PrimState m) a -> (a -> a) -> p k -> m ()
 modify' (MVector v) f p = VGM.unsafeModify v f (fromInteger (natVal p))
 {-# inline modify' #-}
 
 -- | /O(1)/ Modify the element at a given 'Int' position without bounds
 -- checking.
-unsafeModify :: forall v n m a. (KnownNat n, PrimMonad m, VGM.MVector v a)
+unsafeModify :: forall v n m a. (PrimMonad m, VGM.MVector v a)
        => MVector v n (PrimState m) a -> (a -> a) -> Int -> m ()
 unsafeModify (MVector v) = VGM.unsafeModify v
 {-# inline unsafeModify #-}
 
 -- | /O(1)/ Swap the elements at a given type-safe position using 'Finite's.
-swap :: forall v n m a. (KnownNat n, PrimMonad m, VGM.MVector v a)
+swap :: forall v n m a. (PrimMonad m, VGM.MVector v a)
      => MVector v n (PrimState m) a -> Finite n -> Finite n -> m ()
-swap (MVector v) i j = VGM.unsafeSwap v (fromIntegral i) (fromIntegral j)
+swap (MVector v) (Finite i) (Finite j) = VGM.unsafeSwap v (fromIntegral i) (fromIntegral j)
 {-# inline swap #-}
 
 -- | /O(1)/ Swap the elements at a given 'Int' position without bounds
 -- checking.
-unsafeSwap :: forall v n m a. (KnownNat n, PrimMonad m, VGM.MVector v a)
+unsafeSwap :: forall v n m a. (PrimMonad m, VGM.MVector v a)
            => MVector v n (PrimState m) a -> Int -> Int -> m ()
 unsafeSwap (MVector v) = VGM.unsafeSwap v
 {-# inline unsafeSwap #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position and return
 -- the old element, using 'Finite'.
-exchange :: forall v n m a. (KnownNat n, PrimMonad m, VGM.MVector v a)
+exchange :: forall v n m a. (PrimMonad m, VGM.MVector v a)
          => MVector v n (PrimState m) a -> Finite n -> a -> m a
-exchange (MVector v) i = VGM.unsafeExchange v (fromIntegral i)
+exchange (MVector v) (Finite i) = VGM.unsafeExchange v (fromIntegral i)
 {-# inline exchange #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position and return
 -- the old element, using 'Finite'.
-exchange' :: forall v n k a m p. (KnownNat n, KnownNat k, PrimMonad m, VGM.MVector v a)
+exchange' :: forall v n k a m p. (KnownNat k, PrimMonad m, VGM.MVector v a)
           => MVector v (n+k+1) (PrimState m) a -> p k -> a -> m a
 exchange' (MVector v) p = VGM.unsafeExchange v (fromInteger (natVal p))
 {-# inline exchange' #-}
 
 -- | /O(1)/ Replace the element at a given 'Int' position and return
 -- the old element. No bounds checks are performed.
-unsafeExchange :: forall v n m a. (KnownNat n, PrimMonad m, VGM.MVector v a)
+unsafeExchange :: forall v n m a. (PrimMonad m, VGM.MVector v a)
          => MVector v n (PrimState m) a -> Int -> a -> m a
 unsafeExchange (MVector v) = VGM.unsafeExchange v
 {-# inline unsafeExchange #-}
@@ -390,7 +393,7 @@
 
 -- | Compute the next (lexicographically) permutation of a given vector
 -- in-place.  Returns 'False' when the input is the last permutation.
-nextPermutation :: forall v n e m. (KnownNat n, Ord e, PrimMonad m, VGM.MVector v e)
+nextPermutation :: forall v n e m. (Ord e, PrimMonad m, VGM.MVector v e)
                 => MVector v n (PrimState m) e -> m Bool
 nextPermutation (MVector v) = VGM.nextPermutation v
 {-# inline nextPermutation #-}
diff --git a/src/Data/Vector/Generic/Sized.hs b/src/Data/Vector/Generic/Sized.hs
--- a/src/Data/Vector/Generic/Sized.hs
+++ b/src/Data/Vector/Generic/Sized.hs
@@ -370,26 +370,26 @@
   Nothing -> error "impossible: Vector has negative length"
 
 -- | /O(1)/ Safe indexing using a 'Finite'.
-index :: forall v n a. (KnownNat n, VG.Vector v a)
+index :: forall v n a. VG.Vector v a
       => Vector v n a -> Finite n -> a
-index (Vector v) i = v `VG.unsafeIndex` fromIntegral i
+index (Vector v) (Finite i) = v `VG.unsafeIndex` fromIntegral i
 {-# inline index #-}
 
 -- | /O(1)/ Safe indexing using a 'Proxy'.
-index' :: forall v n m a p. (KnownNat n, KnownNat m, VG.Vector v a)
+index' :: forall v n m a p. (KnownNat n, VG.Vector v a)
        => Vector v (n+m+1) a -> p n -> a
 index' (Vector v) p = v `VG.unsafeIndex` i
   where i = fromIntegral (natVal p)
 {-# inline index' #-}
 
 -- | /O(1)/ Indexing using an Int without bounds checking.
-unsafeIndex :: forall v n a. (KnownNat n, VG.Vector v a)
+unsafeIndex :: forall v n a. VG.Vector v a
       => Vector v n a -> Int -> a
 unsafeIndex (Vector v) i = v `VG.unsafeIndex` i
 {-# inline unsafeIndex #-}
 
 -- | /O(1)/ Yield the first element of a non-empty vector.
-head :: forall v n a. (VG.Vector v a)
+head :: forall v n a. VG.Vector v a
      => Vector v (1+n) a -> a
 head (Vector v) = VG.unsafeHead v
 {-# inline head #-}
@@ -401,33 +401,33 @@
 {-# inline last #-}
 
 -- | Lens to access (/O(1)/) and update (/O(n)/) an arbitrary element by its index.
-ix :: forall v n a f. (KnownNat n, VG.Vector v a, Functor f)
+ix :: forall v n a f. (VG.Vector v a, Functor f)
    => Finite n -> (a -> f a) -> Vector v n a -> f (Vector v n a)
-ix n f vector = (\x -> vector // [(fromInteger $ getFinite n, x)]) <$> f (index vector n)
+ix n f vector = (\x -> vector // [(n, x)]) <$> f (index vector n)
 {-# inline ix #-}
 
 -- | Lens to access (/O(1)/) and update (/O(n)/) the first element of a non-empty vector.
-_head :: forall v n a f. (KnownNat n, VG.Vector v a, Functor f)
+_head :: forall v n a f. (VG.Vector v a, Functor f)
       => (a -> f a) -> Vector v (1+n) a -> f (Vector v (1+n) a)
 _head f vector = (\x -> cons x $ tail vector) <$> f (head vector)
 {-# inline _head #-}
 
 -- | Lens to access (/O(1)/) and update (/O(n)/) the last element of a non-empty vector.
-_last :: forall v n a f. (KnownNat n, VG.Vector v a, Functor f)
+_last :: forall v n a f. (VG.Vector v a, Functor f)
        => (a -> f a) -> Vector v (n+1) a -> f (Vector v (n+1) a)
 _last f vector = (\x -> snoc (init vector) x) <$> f (last vector)
 {-# inline _last #-}
 
 -- | /O(1)/ Safe indexing in a monad. See the documentation for 'VG.indexM' for
 -- an explanation of why this is useful.
-indexM :: forall v n a m. (KnownNat n, VG.Vector v a, Monad m)
+indexM :: forall v n a m. (VG.Vector v a, Monad m)
       => Vector v n a -> Finite n -> m a
-indexM (Vector v) i = v `VG.indexM` fromIntegral i
+indexM (Vector v) (Finite i) = v `VG.indexM` fromIntegral i
 {-# inline indexM #-}
 
 -- | /O(1)/ Safe indexing in a monad using a 'Proxy'. See the documentation for
 -- 'VG.indexM' for an explanation of why this is useful.
-indexM' :: forall v n k a m p. (KnownNat n, KnownNat k, VG.Vector v a, Monad m)
+indexM' :: forall v n k a m p. (KnownNat n, VG.Vector v a, Monad m)
       => Vector v (n+k) a -> p n -> m a
 indexM' (Vector v) p = v `VG.indexM` i
   where i = fromIntegral (natVal p)
@@ -435,28 +435,28 @@
 
 -- | /O(1)/ Indexing using an Int without bounds checking. See the
 -- documentation for 'VG.indexM' for an explanation of why this is useful.
-unsafeIndexM :: forall v n a m. (KnownNat n, VG.Vector v a, Monad m)
+unsafeIndexM :: forall v n a m. (VG.Vector v a, Monad m)
       => Vector v n a -> Int -> m a
 unsafeIndexM (Vector v) i = v `VG.unsafeIndexM` i
 {-# inline unsafeIndexM #-}
 
 -- | /O(1)/ Yield the first element of a non-empty vector in a monad. See the
 -- documentation for 'VG.indexM' for an explanation of why this is useful.
-headM :: forall v n a m. (KnownNat n, VG.Vector v a, Monad m)
+headM :: forall v n a m. (VG.Vector v a, Monad m)
       => Vector v (1+n) a -> m a
 headM (Vector v) = VG.unsafeHeadM v
 {-# inline headM #-}
 
 -- | /O(1)/ Yield the last element of a non-empty vector in a monad. See the
 -- documentation for 'VG.indexM' for an explanation of why this is useful.
-lastM :: forall v n a m. (KnownNat n, VG.Vector v a, Monad m)
+lastM :: forall v n a m. (VG.Vector v a, Monad m)
       => Vector v (n+1) a -> m a
 lastM (Vector v) = VG.unsafeLastM v
 {-# inline lastM #-}
 
 -- | /O(1)/ Yield a slice of the vector without copying it with an inferred
 -- length argument.
-slice :: forall v i n m a p. (KnownNat i, KnownNat n, KnownNat m, VG.Vector v a)
+slice :: forall v i n m a p. (KnownNat i, KnownNat n, VG.Vector v a)
       => p i -- ^ starting index
       -> Vector v (i+n+m) a
       -> Vector v n a
@@ -468,7 +468,7 @@
 -- | /O(1)/ Yield a slice of the vector without copying it with an explicit
 -- length argument.
 slice' :: forall v i n m a p
-        . (KnownNat i, KnownNat n, KnownNat m, VG.Vector v a)
+        . (KnownNat i, KnownNat n, VG.Vector v a)
        => p i -- ^ starting index
        -> p n -- ^ length
        -> Vector v (i+n+m) a
@@ -493,7 +493,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is inferred from the
 -- type.
-take :: forall v n m a. (KnownNat n, KnownNat m, VG.Vector v a)
+take :: forall v n m a. (KnownNat n, VG.Vector v a)
      => Vector v (n+m) a -> Vector v n a
 take (Vector v) = Vector (VG.unsafeTake i v)
   where i = fromIntegral (natVal (Proxy :: Proxy n))
@@ -502,7 +502,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is given explicitly
 -- as a 'Proxy' argument.
-take' :: forall v n m a p. (KnownNat n, KnownNat m, VG.Vector v a)
+take' :: forall v n m a p. (KnownNat n, VG.Vector v a)
       => p n -> Vector v (n+m) a -> Vector v n a
 take' _ = take
 {-# inline take' #-}
@@ -510,7 +510,7 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- inferred from the type.
-drop :: forall v n m a. (KnownNat n, KnownNat m, VG.Vector v a)
+drop :: forall v n m a. (KnownNat n, VG.Vector v a)
      => Vector v (n+m) a -> Vector v m a
 drop (Vector v) = Vector (VG.unsafeDrop i v)
   where i = fromIntegral (natVal (Proxy :: Proxy n))
@@ -519,14 +519,14 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- givel explicitly as a 'Proxy' argument.
-drop' :: forall v n m a p. (KnownNat n, KnownNat m, VG.Vector v a)
+drop' :: forall v n m a p. (KnownNat n, VG.Vector v a)
       => p n -> Vector v (n+m) a -> Vector v m a
 drop' _ = drop
 {-# inline drop' #-}
 
 -- | /O(1)/ Yield the first n elements paired with the remainder without copying.
 -- The lengths of the resultant vector are inferred from the type.
-splitAt :: forall v n m a. (KnownNat n, KnownNat m, VG.Vector v a)
+splitAt :: forall v n m a. (KnownNat n, VG.Vector v a)
         => Vector v (n+m) a -> (Vector v n a, Vector v m a)
 splitAt (Vector v) = (Vector a, Vector b)
   where i = fromIntegral (natVal (Proxy :: Proxy n))
@@ -536,7 +536,7 @@
 -- | /O(1)/ Yield the first n elements paired with the remainder without
 -- copying.  The length of the first resultant vector is passed explicitly as a
 -- 'Proxy' argument.
-splitAt' :: forall v n m a p. (KnownNat n, KnownNat m, VG.Vector v a)
+splitAt' :: forall v n m a p. (KnownNat n, VG.Vector v a)
          => p n -> Vector v (n+m) a -> (Vector v n a, Vector v m a)
 splitAt' _ = splitAt
 {-# inline splitAt' #-}
@@ -757,7 +757,7 @@
 --
 -- > <5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>
 --
-(//) :: (VG.Vector v a)
+(//) :: VG.Vector v a
      => Vector v m a    -- ^ initial vector (of length @m@)
      -> [(Finite m, a)] -- ^ list of index/value pairs (of length @n@)
      -> Vector v m a
@@ -1286,7 +1286,7 @@
 {-# inline foldl #-}
 
 -- | /O(n)/ Left fold on non-empty vectors
-foldl1 :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (1+n) a -> a
+foldl1 :: VG.Vector v a => (a -> a -> a) -> Vector v (1+n) a -> a
 foldl1 f = VG.foldl1 f . fromSized
 {-# inline foldl1 #-}
 
@@ -1296,7 +1296,7 @@
 {-# inline foldl' #-}
 
 -- | /O(n)/ Left fold on non-empty vectors with strict accumulator
-foldl1' :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (1+n) a -> a
+foldl1' :: VG.Vector v a => (a -> a -> a) -> Vector v (1+n) a -> a
 foldl1' f = VG.foldl1' f . fromSized
 {-# inline foldl1' #-}
 
@@ -1306,7 +1306,7 @@
 {-# inline foldr #-}
 
 -- | /O(n)/ Right fold on non-empty vectors
-foldr1 :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n+1) a -> a
+foldr1 :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> a
 foldr1 f = VG.foldr1 f . fromSized
 {-# inline foldr1 #-}
 
@@ -1316,7 +1316,7 @@
 {-# inline foldr' #-}
 
 -- | /O(n)/ Right fold on non-empty vectors with strict accumulator
-foldr1' :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n+1) a -> a
+foldr1' :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> a
 foldr1' f = VG.foldr1' f . fromSized
 {-# inline foldr1' #-}
 
@@ -1375,49 +1375,49 @@
 {-# inline product #-}
 
 -- | /O(n)/ Yield the maximum element of the non-empty vector.
-maximum :: (VG.Vector v a, Ord a, KnownNat n) => Vector v (n+1) a -> a
+maximum :: (VG.Vector v a, Ord a) => Vector v (n+1) a -> a
 maximum = VG.maximum . fromSized
 {-# inline maximum #-}
 
 -- | /O(n)/ Yield the maximum element of the non-empty vector according to the
 -- given comparison function.
-maximumBy :: (VG.Vector v a, KnownNat n)
+maximumBy :: VG.Vector v a
           => (a -> a -> Ordering) -> Vector v (n+1) a -> a
 maximumBy cmpr = VG.maximumBy cmpr . fromSized
 {-# inline maximumBy #-}
 
 -- | /O(n)/ Yield the minimum element of the non-empty vector.
-minimum :: (VG.Vector v a, Ord a, KnownNat n) => Vector v (n+1) a -> a
+minimum :: (VG.Vector v a, Ord a) => Vector v (n+1) a -> a
 minimum = VG.minimum . fromSized
 {-# inline minimum #-}
 
 -- | /O(n)/ Yield the minimum element of the non-empty vector according to the
 -- given comparison function.
-minimumBy :: (VG.Vector v a, KnownNat n)
+minimumBy :: VG.Vector v a
           => (a -> a -> Ordering) -> Vector v (n+1) a -> a
 minimumBy cmpr = VG.minimumBy cmpr . fromSized
 {-# inline minimumBy #-}
 
 -- | /O(n)/ Yield the index of the maximum element of the non-empty vector.
-maxIndex :: (VG.Vector v a, Ord a, KnownNat n) => Vector v (n+1) a -> Finite (n+1)
+maxIndex :: (VG.Vector v a, Ord a) => Vector v (n+1) a -> Finite (n+1)
 maxIndex = Finite . fromIntegral . VG.maxIndex . fromSized
 {-# inline maxIndex #-}
 
 -- | /O(n)/ Yield the index of the maximum element of the non-empty vector
 -- according to the given comparison function.
-maxIndexBy :: (VG.Vector v a, KnownNat n)
+maxIndexBy :: VG.Vector v a
            => (a -> a -> Ordering) -> Vector v (n+1) a -> Finite (n + 1)
 maxIndexBy cmpr = Finite . fromIntegral . VG.maxIndexBy cmpr . fromSized
 {-# inline maxIndexBy #-}
 
 -- | /O(n)/ Yield the index of the minimum element of the non-empty vector.
-minIndex :: (VG.Vector v a, Ord a, KnownNat n) => Vector v (n+1) a -> Finite (n+1)
+minIndex :: (VG.Vector v a, Ord a) => Vector v (n+1) a -> Finite (n+1)
 minIndex = Finite . fromIntegral . VG.minIndex . fromSized
 {-# inline minIndex #-}
 
 -- | /O(n)/ Yield the index of the minimum element of the non-empty vector
 -- according to the given comparison function.
-minIndexBy :: (VG.Vector v a, KnownNat n)
+minIndexBy :: VG.Vector v a
            => (a -> a -> Ordering) -> Vector v (n+1) a -> Finite (n + 1)
 minIndexBy cmpr = Finite . fromIntegral . VG.minIndexBy cmpr . fromSized
 {-# inline minIndexBy #-}
@@ -1435,7 +1435,7 @@
 {-# inline ifoldM #-}
 
 -- | /O(n)/ Monadic fold over non-empty vectors
-fold1M :: (Monad m, VG.Vector v a, KnownNat n)
+fold1M :: (Monad m, VG.Vector v a)
        => (a -> a -> m a) -> Vector v (1+n) a -> m a
 fold1M m = VG.fold1M m . fromSized
 {-# inline fold1M #-}
@@ -1453,7 +1453,7 @@
 {-# inline ifoldM' #-}
 
 -- | /O(n)/ Monadic fold over non-empty vectors with strict accumulator
-fold1M' :: (Monad m, VG.Vector v a, KnownNat n)
+fold1M' :: (Monad m, VG.Vector v a)
         => (a -> a -> m a) -> Vector v (n+1) a -> m a
 fold1M' m = VG.fold1M' m . fromSized
 {-# inline fold1M' #-}
@@ -1472,7 +1472,7 @@
 {-# inline ifoldM_ #-}
 
 -- | /O(n)/ Monadic fold over non-empty vectors that discards the result
-fold1M_ :: (Monad m, VG.Vector v a, KnownNat n)
+fold1M_ :: (Monad m, VG.Vector v a)
         => (a -> a -> m a) -> Vector v (n+1) a -> m ()
 fold1M_ m = VG.fold1M_ m . fromSized
 {-# inline fold1M_ #-}
@@ -1492,7 +1492,7 @@
 
 -- | /O(n)/ Monad fold over non-empty vectors with strict accumulator
 -- that discards the result
-fold1M'_ :: (Monad m, VG.Vector v a, KnownNat n)
+fold1M'_ :: (Monad m, VG.Vector v a)
          => (a -> a -> m a) -> Vector v (n+1) a -> m ()
 fold1M'_ m = VG.fold1M'_ m . fromSized
 {-# inline fold1M'_ #-}
@@ -1552,12 +1552,12 @@
 {-# inline scanl' #-}
 
 -- | /O(n)/ Scan over a non-empty vector
-scanl1 :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
+scanl1 :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
 scanl1 f = withVectorUnsafe (VG.scanl1 f )
 {-# inline scanl1 #-}
 
 -- | /O(n)/ Scan over a non-empty vector with a strict accumulator
-scanl1' :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
+scanl1' :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
 scanl1' f = withVectorUnsafe (VG.scanl1' f )
 {-# inline scanl1' #-}
 
@@ -1592,13 +1592,13 @@
 {-# inline scanr' #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector
-scanr1 :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
+scanr1 :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
 scanr1 f = withVectorUnsafe (VG.scanr1 f )
 {-# inline scanr1 #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
 -- accumulator
-scanr1' :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
+scanr1' :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
 scanr1' f = withVectorUnsafe (VG.scanr1' f )
 {-# inline scanr1' #-}
 
@@ -1706,7 +1706,8 @@
 -- a 'Data.Vector.Generic.Sized.Vector' with the correct size parameter
 -- @n@.
 withSized :: forall v a r. VG.Vector v a
-          => v a -> (forall n. KnownNat n => Vector v n a -> r) -> r
+          => v a
+          -> (forall n. KnownNat n => Vector v n a -> r) -> r
 withSized v f = case someNatVal (fromIntegral (VG.length v)) of
   Just (SomeNat (Proxy :: Proxy n)) -> f (Vector v :: Vector v n a)
   Nothing -> error "impossible: Vector has negative length"
@@ -1717,8 +1718,7 @@
 
 -- | Apply a function on unsized vectors to a sized vector. The function must
 -- preserve the size of the vector, this is not checked.
-withVectorUnsafe :: forall a b v w (n :: Nat). (VG.Vector v a, VG.Vector w b)
-                 => (v a -> w b) -> Vector v n a -> Vector w n b
+withVectorUnsafe :: (v a -> w b) -> Vector v n a -> Vector w n b
 withVectorUnsafe f (Vector v) = Vector (f v)
 {-# inline withVectorUnsafe #-}
 
diff --git a/src/Data/Vector/Mutable/Sized.hs b/src/Data/Vector/Mutable/Sized.hs
--- a/src/Data/Vector/Mutable/Sized.hs
+++ b/src/Data/Vector/Mutable/Sized.hs
@@ -99,13 +99,13 @@
 -- ** Length information
 
 -- | /O(1)/ Yield the length of the mutable vector as an 'Int'.
-length :: forall n s a. (KnownNat n)
+length :: forall n s a. KnownNat n
        => MVector n s a -> Int
 length = VGM.length
 {-# inline length #-}
 
 -- | /O(1)/ Yield the length of the mutable vector as a 'Proxy'.
-length' :: forall n s a. (KnownNat n)
+length' :: forall n s a. ()
         => MVector n s a -> Proxy n
 length' = VGM.length'
 {-# inline length' #-}
@@ -120,7 +120,7 @@
 
 -- | /O(1)/ Yield a slice of the mutable vector without copying it with an
 -- inferred length argument.
-slice :: forall i n k s a p. (KnownNat i, KnownNat n, KnownNat k)
+slice :: forall i n k s a p. (KnownNat i, KnownNat n)
       => p i -- ^ starting index
       -> MVector (i+n+k) s a
       -> MVector n s a
@@ -130,7 +130,7 @@
 -- | /O(1)/ Yield a slice of the mutable vector without copying it with an
 -- explicit length argument.
 slice' :: forall i n k s a p
-        . (KnownNat i, KnownNat n, KnownNat k)
+        . (KnownNat i, KnownNat n)
        => p i -- ^ starting index
        -> p n -- ^ length
        -> MVector (i+n+k) s a
@@ -155,7 +155,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is inferred from the
 -- type.
-take :: forall n k s a. (KnownNat n, KnownNat k)
+take :: forall n k s a. KnownNat n
      => MVector (n+k) s a -> MVector n s a
 take = VGM.take
 {-# inline take #-}
@@ -163,7 +163,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is given explicitly
 -- as a 'Proxy' argument.
-take' :: forall n k s a p. (KnownNat n, KnownNat k)
+take' :: forall n k s a p. KnownNat n
       => p n -> MVector (n+k) s a -> MVector n s a
 take' = VGM.take'
 {-# inline take' #-}
@@ -171,7 +171,7 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- inferred from the type.
-drop :: forall n k s a. (KnownNat n, KnownNat k)
+drop :: forall n k s a. KnownNat n
      => MVector (n+k) s a -> MVector k s a
 drop = VGM.drop
 {-# inline drop #-}
@@ -179,14 +179,14 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- givel explicitly as a 'Proxy' argument.
-drop' :: forall n k s a p. (KnownNat n, KnownNat k)
+drop' :: forall n k s a p. KnownNat n
       => p n -> MVector (n+k) s a -> MVector k s a
 drop' = VGM.drop'
 {-# inline drop' #-}
 
 -- | /O(1)/ Yield the first n elements paired with the remainder without copying.
 -- The lengths of the resultant vector are inferred from the type.
-splitAt :: forall n m s a. (KnownNat n, KnownNat m)
+splitAt :: forall n m s a. KnownNat n
         => MVector (n+m) s a -> (MVector n s a, MVector m s a)
 splitAt = VGM.splitAt
 {-# inline splitAt #-}
@@ -194,7 +194,7 @@
 -- | /O(1)/ Yield the first n elements paired with the remainder without
 -- copying.  The length of the first resultant vector is passed explicitly as a
 -- 'Proxy' argument.
-splitAt' :: forall n m s a p. (KnownNat n, KnownNat m)
+splitAt' :: forall n m s a p. KnownNat n
          => p n -> MVector (n+m) s a -> (MVector n s a, MVector m s a)
 splitAt' = VGM.splitAt'
 {-# inline splitAt' #-}
@@ -204,7 +204,7 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- inferred from the type.
-overlaps :: forall n k s a. (KnownNat n, KnownNat k)
+overlaps :: forall n k s a. ()
          => MVector n s a
          -> MVector k s a
          -> Bool
@@ -290,92 +290,92 @@
 -- * Accessing individual elements
 
 -- | /O(1)/ Yield the element at a given type-safe position using 'Finite'.
-read :: forall n m a. (KnownNat n, PrimMonad m)
+read :: forall n m a. PrimMonad m
       => MVector n (PrimState m) a -> Finite n -> m a
 read = VGM.read
 {-# inline read #-}
 
 -- | /O(1)/ Yield the element at a given type-safe position using 'Proxy'.
-read' :: forall n k a m p. (KnownNat n, KnownNat k, PrimMonad m)
+read' :: forall n k a m p. (KnownNat k, PrimMonad m)
        => MVector (n+k+1) (PrimState m) a -> p k -> m a
 read' = VGM.read'
 {-# inline read' #-}
 
 -- | /O(1)/ Yield the element at a given 'Int' position without bounds
 -- checking.
-unsafeRead :: forall n a m. (KnownNat n, PrimMonad m)
+unsafeRead :: forall n a m. PrimMonad m
            => MVector n (PrimState m) a -> Int -> m a
 unsafeRead = VGM.unsafeRead
 {-# inline unsafeRead #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position using 'Finite'.
-write :: forall n m a. (KnownNat n, PrimMonad m)
+write :: forall n m a. PrimMonad m
       => MVector n (PrimState m) a -> Finite n -> a -> m ()
 write = VGM.write
 {-# inline write #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position using 'Proxy'.
-write' :: forall n k a m p. (KnownNat n, KnownNat k, PrimMonad m)
+write' :: forall n k a m p. (KnownNat k, PrimMonad m)
        => MVector (n+k+1) (PrimState m) a -> p k -> a -> m ()
 write' = VGM.write'
 {-# inline write' #-}
 
 -- | /O(1)/ Replace the element at a given 'Int' position without bounds
 -- checking.
-unsafeWrite :: forall n m a. (KnownNat n, PrimMonad m)
+unsafeWrite :: forall n m a. PrimMonad m
       => MVector n (PrimState m) a -> Int -> a -> m ()
 unsafeWrite = VGM.unsafeWrite
 {-# inline unsafeWrite #-}
 
 -- | /O(1)/ Modify the element at a given type-safe position using 'Finite'.
-modify :: forall n m a. (KnownNat n, PrimMonad m)
+modify :: forall n m a. PrimMonad m
        => MVector n (PrimState m) a -> (a -> a) -> Finite n -> m ()
 modify = VGM.modify
 {-# inline modify #-}
 
 -- | /O(1)/ Modify the element at a given type-safe position using 'Proxy'.
-modify' :: forall n k a m p. (KnownNat n, KnownNat k, PrimMonad m)
+modify' :: forall n k a m p. (KnownNat k, PrimMonad m)
         => MVector (n+k+1) (PrimState m) a -> (a -> a) -> p k -> m ()
 modify' = VGM.modify'
 {-# inline modify' #-}
 
 -- | /O(1)/ Modify the element at a given 'Int' position without bounds
 -- checking.
-unsafeModify :: forall n m a. (KnownNat n, PrimMonad m)
+unsafeModify :: forall n m a. PrimMonad m
        => MVector n (PrimState m) a -> (a -> a) -> Int -> m ()
 unsafeModify = VGM.unsafeModify
 {-# inline unsafeModify #-}
 
 -- | /O(1)/ Swap the elements at a given type-safe position using 'Finite's.
-swap :: forall n m a. (KnownNat n, PrimMonad m)
+swap :: forall n m a. PrimMonad m
      => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()
 swap = VGM.swap
 {-# inline swap #-}
 
 -- | /O(1)/ Swap the elements at a given 'Int' position without bounds
 -- checking.
-unsafeSwap :: forall n m a. (KnownNat n, PrimMonad m)
+unsafeSwap :: forall n m a. PrimMonad m
            => MVector n (PrimState m) a -> Int -> Int -> m ()
 unsafeSwap = VGM.unsafeSwap
 {-# inline unsafeSwap #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position and return
 -- the old element, using 'Finite'.
-exchange :: forall n m a. (KnownNat n, PrimMonad m)
+exchange :: forall n m a. PrimMonad m
          => MVector n (PrimState m) a -> Finite n -> a -> m a
 exchange = VGM.exchange
 {-# inline exchange #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position and return
 -- the old element, using 'Finite'.
-exchange' :: forall n k a m p. (KnownNat n, KnownNat k, PrimMonad m)
+exchange' :: forall n k a m p. (KnownNat k, PrimMonad m)
           => MVector (n+k+1) (PrimState m) a -> p k -> a -> m a
 exchange' = VGM.exchange'
 {-# inline exchange' #-}
 
 -- | /O(1)/ Replace the element at a given 'Int' position and return
 -- the old element. No bounds checks are performed.
-unsafeExchange :: forall n m a. (KnownNat n, PrimMonad m)
+unsafeExchange :: forall n m a. PrimMonad m
          => MVector n (PrimState m) a -> Int -> a -> m a
 unsafeExchange = VGM.unsafeExchange
 {-# inline unsafeExchange #-}
@@ -385,7 +385,7 @@
 
 -- | Compute the next (lexicographically) permutation of a given vector
 -- in-place.  Returns 'False' when the input is the last permutation.
-nextPermutation :: forall n e m. (KnownNat n, Ord e, PrimMonad m)
+nextPermutation :: forall n e m. (Ord e, PrimMonad m)
                 => MVector n (PrimState m) e -> m Bool
 nextPermutation = VGM.nextPermutation
 {-# inline nextPermutation #-}
diff --git a/src/Data/Vector/Sized.hs b/src/Data/Vector/Sized.hs
--- a/src/Data/Vector/Sized.hs
+++ b/src/Data/Vector/Sized.hs
@@ -292,19 +292,19 @@
 knownLength' = V.knownLength'
 
 -- | /O(1)/ Safe indexing using a 'Finite'.
-index :: forall n a. KnownNat n
+index :: forall n a. ()
       => Vector n a -> Finite n -> a
 index = V.index
 {-# inline index #-}
 
 -- | /O(1)/ Safe indexing using a 'Proxy'.
-index' :: forall n m a p. (KnownNat n, KnownNat m)
+index' :: forall n m a p. KnownNat n
        => Vector (n+m+1) a -> p n -> a
 index' = V.index'
 {-# inline index' #-}
 
 -- | /O(1)/ Indexing using an Int without bounds checking.
-unsafeIndex :: forall n a. KnownNat n
+unsafeIndex :: forall n a. ()
       => Vector n a -> Int -> a
 unsafeIndex = V.unsafeIndex
 {-# inline unsafeIndex #-}
@@ -320,61 +320,61 @@
 {-# inline last #-}
 
 -- | Lens to access (/O(1)/) and update (/O(n)/) an arbitrary element by its index.
-ix :: forall n a f. (KnownNat n, Functor f)
+ix :: forall n a f. Functor f
    => Finite n -> (a -> f a) -> Vector n a -> f (Vector n a)
 ix = V.ix
 {-# inline ix #-}
 
 -- | Lens to access (/O(1)/) and update (/O(n)/) the first element of a non-empty vector.
-_head :: forall n a f. (KnownNat n, Functor f)
+_head :: forall n a f. Functor f
    => (a -> f a) -> Vector (1+n) a -> f (Vector (1+n) a)
 _head = V._head
 {-# inline _head #-}
 
 -- | Lens to access (/O(1)/) and update (/O(n)/) the last element of a non-empty vector.
-_last :: forall n a f. (KnownNat n, Functor f)
+_last :: forall n a f. Functor f
       => (a -> f a) -> Vector (n+1) a -> f (Vector (n+1) a)
 _last = V._last
 {-# inline _last #-}
 
 -- | /O(1)/ Safe indexing in a monad. See the documentation for 'VG.indexM' for
 -- an explanation of why this is useful.
-indexM :: forall n a m. (KnownNat n, Monad m)
+indexM :: forall n a m. Monad m
       => Vector n a -> Finite n -> m a
 indexM = V.indexM
 {-# inline indexM #-}
 
 -- | /O(1)/ Safe indexing in a monad using a 'Proxy'. See the documentation for
 -- 'VG.indexM' for an explanation of why this is useful.
-indexM' :: forall n k a m p. (KnownNat n, KnownNat k, Monad m)
+indexM' :: forall n k a m p. (KnownNat n, Monad m)
       => Vector (n+k) a -> p n -> m a
 indexM' = V.indexM'
 {-# inline indexM' #-}
 
 -- | /O(1)/ Indexing using an Int without bounds checking. See the
 -- documentation for 'VG.indexM' for an explanation of why this is useful.
-unsafeIndexM :: forall n a m. (KnownNat n, Monad m)
+unsafeIndexM :: forall n a m. Monad m
       => Vector n a -> Int -> m a
 unsafeIndexM = V.unsafeIndexM
 {-# inline unsafeIndexM #-}
 
 -- | /O(1)/ Yield the first element of a non-empty vector in a monad. See the
 -- documentation for 'VG.indexM' for an explanation of why this is useful.
-headM :: forall n a m. (KnownNat n, Monad m)
+headM :: forall n a m. Monad m
       => Vector (1+n) a -> m a
 headM = V.headM
 {-# inline headM #-}
 
 -- | /O(1)/ Yield the last element of a non-empty vector in a monad. See the
 -- documentation for 'VG.indexM' for an explanation of why this is useful.
-lastM :: forall n a m. (KnownNat n, Monad m)
+lastM :: forall n a m. Monad m
       => Vector (n+1) a -> m a
 lastM = V.lastM
 {-# inline lastM #-}
 
 -- | /O(1)/ Yield a slice of the vector without copying it with an inferred
 -- length argument.
-slice :: forall i n m a p. (KnownNat i, KnownNat n, KnownNat m)
+slice :: forall i n m a p. (KnownNat i, KnownNat n)
       => p i -- ^ starting index
       -> Vector (i+n+m) a
       -> Vector n a
@@ -383,7 +383,7 @@
 
 -- | /O(1)/ Yield a slice of the vector without copying it with an explicit
 -- length argument.
-slice' :: forall i n m a p. (KnownNat i, KnownNat n, KnownNat m)
+slice' :: forall i n m a p. (KnownNat i, KnownNat n)
        => p i -- ^ starting index
        -> p n -- ^ length
        -> Vector (i+n+m) a
@@ -406,7 +406,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is inferred from the
 -- type.
-take :: forall n m a. (KnownNat n, KnownNat m)
+take :: forall n m a. KnownNat n
      => Vector (n+m) a -> Vector n a
 take = V.take
 {-# inline take #-}
@@ -414,7 +414,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is given explicitly
 -- as a 'Proxy' argument.
-take' :: forall n m a p. (KnownNat n, KnownNat m)
+take' :: forall n m a p. KnownNat n
       => p n -> Vector (n+m) a -> Vector n a
 take' = V.take'
 {-# inline take' #-}
@@ -422,7 +422,7 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- inferred from the type.
-drop :: forall n m a. (KnownNat n, KnownNat m)
+drop :: forall n m a. KnownNat n
      => Vector (n+m) a -> Vector m a
 drop = V.drop
 {-# inline drop #-}
@@ -430,14 +430,14 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- givel explicitly as a 'Proxy' argument.
-drop' :: forall n m a p. (KnownNat n, KnownNat m)
+drop' :: forall n m a p. KnownNat n
       => p n -> Vector (n+m) a -> Vector m a
 drop' = V.drop'
 {-# inline drop' #-}
 
 -- | /O(1)/ Yield the first n elements paired with the remainder without copying.
 -- The lengths of the resultant vector are inferred from the type.
-splitAt :: forall n m a. (KnownNat n, KnownNat m)
+splitAt :: forall n m a. KnownNat n
         => Vector (n+m) a -> (Vector n a, Vector m a)
 splitAt = V.splitAt
 {-# inline splitAt #-}
@@ -445,7 +445,7 @@
 -- | /O(1)/ Yield the first n elements paired with the remainder without
 -- copying.  The length of the first resultant vector is passed explicitly as a
 -- 'Proxy' argument.
-splitAt' :: forall n m a p. (KnownNat n, KnownNat m)
+splitAt' :: forall n m a p. KnownNat n
          => p n -> Vector (n+m) a -> (Vector n a, Vector m a)
 splitAt' = V.splitAt'
 {-# inline splitAt' #-}
@@ -1115,7 +1115,7 @@
 {-# inline foldl #-}
 
 -- | /O(n)/ Left fold on non-empty vectors
-foldl1 :: KnownNat n => (a -> a -> a) -> Vector (1+n) a -> a
+foldl1 :: (a -> a -> a) -> Vector (1+n) a -> a
 foldl1 = V.foldl1
 {-# inline foldl1 #-}
 
@@ -1125,7 +1125,7 @@
 {-# inline foldl' #-}
 
 -- | /O(n)/ Left fold on non-empty vectors with strict accumulator
-foldl1' :: KnownNat n => (a -> a -> a) -> Vector (1+n) a -> a
+foldl1' :: (a -> a -> a) -> Vector (1+n) a -> a
 foldl1' = V.foldl1'
 {-# inline foldl1' #-}
 
@@ -1135,7 +1135,7 @@
 {-# inline foldr #-}
 
 -- | /O(n)/ Right fold on non-empty vectors
-foldr1 :: KnownNat n => (a -> a -> a) -> Vector (n+1) a -> a
+foldr1 :: (a -> a -> a) -> Vector (n+1) a -> a
 foldr1 = V.foldr1
 {-# inline foldr1 #-}
 
@@ -1145,7 +1145,7 @@
 {-# inline foldr' #-}
 
 -- | /O(n)/ Right fold on non-empty vectors with strict accumulator
-foldr1' :: KnownNat n => (a -> a -> a) -> Vector (n+1) a -> a
+foldr1' :: (a -> a -> a) -> Vector (n+1) a -> a
 foldr1' = V.foldr1'
 {-# inline foldr1' #-}
 
@@ -1204,50 +1204,46 @@
 {-# inline product #-}
 
 -- | /O(n)/ Yield the maximum element of the non-empty vector.
-maximum :: (Ord a, KnownNat n) => Vector (n+1) a -> a
+maximum :: Ord a => Vector (n+1) a -> a
 maximum = V.maximum
 {-# inline maximum #-}
 
 -- | /O(n)/ Yield the maximum element of the non-empty vector according to the
 -- given comparison function.
-maximumBy :: KnownNat n
-          => (a -> a -> Ordering) -> Vector (n+1) a -> a
+maximumBy :: (a -> a -> Ordering) -> Vector (n+1) a -> a
 maximumBy = V.maximumBy
 {-# inline maximumBy #-}
 
 -- | /O(n)/ Yield the minimum element of the non-empty vector.
-minimum :: (Ord a, KnownNat n) => Vector (n+1) a -> a
+minimum :: Ord a => Vector (n+1) a -> a
 minimum = V.minimum
 {-# inline minimum #-}
 
 -- | /O(n)/ Yield the minimum element of the non-empty vector according to the
 -- given comparison function.
-minimumBy :: KnownNat n
-          => (a -> a -> Ordering) -> Vector (n+1) a -> a
+minimumBy :: (a -> a -> Ordering) -> Vector (n+1) a -> a
 minimumBy = V.minimumBy
 {-# inline minimumBy #-}
 
 -- | /O(n)/ Yield the index of the maximum element of the non-empty vector.
-maxIndex :: (Ord a, KnownNat n) => Vector (n+1) a -> Finite (n + 1)
+maxIndex :: Ord a => Vector (n+1) a -> Finite (n + 1)
 maxIndex = V.maxIndex
 {-# inline maxIndex #-}
 
 -- | /O(n)/ Yield the index of the maximum element of the non-empty vector
 -- according to the given comparison function.
-maxIndexBy :: KnownNat n
-           => (a -> a -> Ordering) -> Vector (n+1) a -> Finite (n + 1)
+maxIndexBy :: (a -> a -> Ordering) -> Vector (n+1) a -> Finite (n + 1)
 maxIndexBy = V.maxIndexBy
 {-# inline maxIndexBy #-}
 
 -- | /O(n)/ Yield the index of the minimum element of the non-empty vector.
-minIndex :: (Ord a, KnownNat n) => Vector (n+1) a -> Finite (n + 1)
+minIndex :: Ord a => Vector (n+1) a -> Finite (n + 1)
 minIndex = V.minIndex
 {-# inline minIndex #-}
 
 -- | /O(n)/ Yield the index of the minimum element of the non-empty vector
 -- according to the given comparison function.
-minIndexBy :: KnownNat n
-           => (a -> a -> Ordering) -> Vector (n+1) a -> Finite (n + 1)
+minIndexBy :: (a -> a -> Ordering) -> Vector (n+1) a -> Finite (n + 1)
 minIndexBy = V.minIndexBy
 {-# inline minIndexBy #-}
 
@@ -1264,8 +1260,7 @@
 {-# inline ifoldM #-}
 
 -- | /O(n)/ Monadic fold over non-empty vectors
-fold1M :: (Monad m, KnownNat n)
-       => (a -> a -> m a) -> Vector (1+n) a -> m a
+fold1M :: Monad m => (a -> a -> m a) -> Vector (1+n) a -> m a
 fold1M = V.fold1M
 {-# inline fold1M #-}
 
@@ -1276,53 +1271,45 @@
 
 -- | /O(n)/ Monadic fold with strict accumulator (action applied to each
 -- element and its index)
-ifoldM' :: Monad m
-        => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a
+ifoldM' :: Monad m => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a
 ifoldM' = V.ifoldM'
 {-# inline ifoldM' #-}
 
 -- | /O(n)/ Monadic fold over non-empty vectors with strict accumulator
-fold1M' :: (Monad m, KnownNat n)
-        => (a -> a -> m a) -> Vector (n+1) a -> m a
+fold1M' :: Monad m => (a -> a -> m a) -> Vector (n+1) a -> m a
 fold1M' = V.fold1M'
 {-# inline fold1M' #-}
 
 -- | /O(n)/ Monadic fold that discards the result
-foldM_ :: Monad m
-       => (a -> b -> m a) -> a -> Vector n b -> m ()
+foldM_ :: Monad m => (a -> b -> m a) -> a -> Vector n b -> m ()
 foldM_ = V.foldM_
 {-# inline foldM_ #-}
 
 -- | /O(n)/ Monadic fold that discards the result (action applied to
 -- each element and its index)
-ifoldM_ :: Monad m
-        => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()
+ifoldM_ :: Monad m => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()
 ifoldM_ = V.ifoldM_
 {-# inline ifoldM_ #-}
 
 -- | /O(n)/ Monadic fold over non-empty vectors that discards the result
-fold1M_ :: (Monad m, KnownNat n)
-        => (a -> a -> m a) -> Vector (n+1) a -> m ()
+fold1M_ :: Monad m => (a -> a -> m a) -> Vector (n+1) a -> m ()
 fold1M_ = V.fold1M_
 {-# inline fold1M_ #-}
 
 -- | /O(n)/ Monadic fold with strict accumulator that discards the result
-foldM'_ :: Monad m
-        => (a -> b -> m a) -> a -> Vector n b -> m ()
+foldM'_ :: Monad m => (a -> b -> m a) -> a -> Vector n b -> m ()
 foldM'_ = V.foldM'_
 {-# inline foldM'_ #-}
 
 -- | /O(n)/ Monadic fold with strict accumulator that discards the result
 -- (action applied to each element and its index)
-ifoldM'_ :: Monad m
-         => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()
+ifoldM'_ :: Monad m => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()
 ifoldM'_ = V.ifoldM'_
 {-# inline ifoldM'_ #-}
 
 -- | /O(n)/ Monad fold over non-empty vectors with strict accumulator
 -- that discards the result
-fold1M'_ :: (Monad m, KnownNat n)
-         => (a -> a -> m a) -> Vector (n+1) a -> m ()
+fold1M'_ :: Monad m => (a -> a -> m a) -> Vector (n+1) a -> m ()
 fold1M'_ = V.fold1M'_
 {-# inline fold1M'_ #-}
 
@@ -1380,12 +1367,12 @@
 {-# inline scanl' #-}
 
 -- | /O(n)/ Scan over a non-empty vector
-scanl1 :: KnownNat n => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanl1 :: (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
 scanl1 = V.scanl1
 {-# inline scanl1 #-}
 
 -- | /O(n)/ Scan over a non-empty vector with a strict accumulator
-scanl1' :: KnownNat n => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanl1' :: (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
 scanl1' = V.scanl1'
 {-# inline scanl1' #-}
 
@@ -1420,13 +1407,13 @@
 {-# inline scanr' #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector
-scanr1 :: KnownNat n => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanr1 :: (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
 scanr1 = V.scanr1
 {-# inline scanr1 #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
 -- accumulator
-scanr1' :: KnownNat n => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanr1' :: (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
 scanr1' = V.scanr1'
 {-# inline scanr1' #-}
 
diff --git a/src/Data/Vector/Storable/Mutable/Sized.hs b/src/Data/Vector/Storable/Mutable/Sized.hs
--- a/src/Data/Vector/Storable/Mutable/Sized.hs
+++ b/src/Data/Vector/Storable/Mutable/Sized.hs
@@ -106,7 +106,7 @@
 {-# inline length #-}
 
 -- | /O(1)/ Yield the length of the mutable vector as a 'Proxy'.
-length' :: forall n s a. (KnownNat n)
+length' :: forall n s a. ()
         => MVector n s a -> Proxy n
 length' = VGM.length'
 {-# inline length' #-}
@@ -121,7 +121,7 @@
 
 -- | /O(1)/ Yield a slice of the mutable vector without copying it with an
 -- inferred length argument.
-slice :: forall i n k s a p. (KnownNat i, KnownNat n, KnownNat k, Storable a)
+slice :: forall i n k s a p. (KnownNat i, KnownNat n, Storable a)
       => p i -- ^ starting index
       -> MVector (i+n+k) s a
       -> MVector n s a
@@ -131,7 +131,7 @@
 -- | /O(1)/ Yield a slice of the mutable vector without copying it with an
 -- explicit length argument.
 slice' :: forall i n k s a p
-        . (KnownNat i, KnownNat n, KnownNat k, Storable a)
+        . (KnownNat i, KnownNat n, Storable a)
        => p i -- ^ starting index
        -> p n -- ^ length
        -> MVector (i+n+k) s a
@@ -156,7 +156,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is inferred from the
 -- type.
-take :: forall n k s a. (KnownNat n, KnownNat k, Storable a)
+take :: forall n k s a. (KnownNat n, Storable a)
      => MVector (n+k) s a -> MVector n s a
 take = VGM.take
 {-# inline take #-}
@@ -164,7 +164,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is given explicitly
 -- as a 'Proxy' argument.
-take' :: forall n k s a p. (KnownNat n, KnownNat k, Storable a)
+take' :: forall n k s a p. (KnownNat n, Storable a)
       => p n -> MVector (n+k) s a -> MVector n s a
 take' = VGM.take'
 {-# inline take' #-}
@@ -172,7 +172,7 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- inferred from the type.
-drop :: forall n k s a. (KnownNat n, KnownNat k, Storable a)
+drop :: forall n k s a. (KnownNat n, Storable a)
      => MVector (n+k) s a -> MVector k s a
 drop = VGM.drop
 {-# inline drop #-}
@@ -180,14 +180,14 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- givel explicitly as a 'Proxy' argument.
-drop' :: forall n k s a p. (KnownNat n, KnownNat k, Storable a)
+drop' :: forall n k s a p. (KnownNat n, Storable a)
       => p n -> MVector (n+k) s a -> MVector k s a
 drop' = VGM.drop'
 {-# inline drop' #-}
 
 -- | /O(1)/ Yield the first n elements paired with the remainder without copying.
 -- The lengths of the resultant vector are inferred from the type.
-splitAt :: forall n m s a. (KnownNat n, KnownNat m, Storable a)
+splitAt :: forall n m s a. (KnownNat n, Storable a)
         => MVector (n+m) s a -> (MVector n s a, MVector m s a)
 splitAt = VGM.splitAt
 {-# inline splitAt #-}
@@ -195,7 +195,7 @@
 -- | /O(1)/ Yield the first n elements paired with the remainder without
 -- copying.  The length of the first resultant vector is passed explicitly as a
 -- 'Proxy' argument.
-splitAt' :: forall n m s a p. (KnownNat n, KnownNat m, Storable a)
+splitAt' :: forall n m s a p. (KnownNat n, Storable a)
          => p n -> MVector (n+m) s a -> (MVector n s a, MVector m s a)
 splitAt' = VGM.splitAt'
 {-# inline splitAt' #-}
@@ -205,7 +205,7 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- inferred from the type.
-overlaps :: forall n k s a. (KnownNat n, KnownNat k, Storable a)
+overlaps :: forall n k s a. Storable a
          => MVector n s a
          -> MVector k s a
          -> Bool
@@ -291,92 +291,92 @@
 -- * Accessing individual elements
 
 -- | /O(1)/ Yield the element at a given type-safe position using 'Finite'.
-read :: forall n m a. (KnownNat n, PrimMonad m, Storable a)
+read :: forall n m a. (PrimMonad m, Storable a)
       => MVector n (PrimState m) a -> Finite n -> m a
 read = VGM.read
 {-# inline read #-}
 
 -- | /O(1)/ Yield the element at a given type-safe position using 'Proxy'.
-read' :: forall n k a m p. (KnownNat n, KnownNat k, PrimMonad m, Storable a)
+read' :: forall n k a m p. (KnownNat k, PrimMonad m, Storable a)
        => MVector (n+k+1) (PrimState m) a -> p k -> m a
 read' = VGM.read'
 {-# inline read' #-}
 
 -- | /O(1)/ Yield the element at a given 'Int' position without bounds
 -- checking.
-unsafeRead :: forall n a m. (KnownNat n, PrimMonad m, Storable a)
+unsafeRead :: forall n a m. (PrimMonad m, Storable a)
            => MVector n (PrimState m) a -> Int -> m a
 unsafeRead = VGM.unsafeRead
 {-# inline unsafeRead #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position using 'Finite'.
-write :: forall n m a. (KnownNat n, PrimMonad m, Storable a)
+write :: forall n m a. (PrimMonad m, Storable a)
       => MVector n (PrimState m) a -> Finite n -> a -> m ()
 write = VGM.write
 {-# inline write #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position using 'Proxy'.
-write' :: forall n k a m p. (KnownNat n, KnownNat k, PrimMonad m, Storable a)
+write' :: forall n k a m p. (KnownNat k, PrimMonad m, Storable a)
        => MVector (n+k+1) (PrimState m) a -> p k -> a -> m ()
 write' = VGM.write'
 {-# inline write' #-}
 
 -- | /O(1)/ Replace the element at a given 'Int' position without bounds
 -- checking.
-unsafeWrite :: forall n m a. (KnownNat n, PrimMonad m, Storable a)
+unsafeWrite :: forall n m a. (PrimMonad m, Storable a)
       => MVector n (PrimState m) a -> Int -> a -> m ()
 unsafeWrite = VGM.unsafeWrite
 {-# inline unsafeWrite #-}
 
 -- | /O(1)/ Modify the element at a given type-safe position using 'Finite'.
-modify :: forall n m a. (KnownNat n, PrimMonad m, Storable a)
+modify :: forall n m a. (PrimMonad m, Storable a)
        => MVector n (PrimState m) a -> (a -> a) -> Finite n -> m ()
 modify = VGM.modify
 {-# inline modify #-}
 
 -- | /O(1)/ Modify the element at a given type-safe position using 'Proxy'.
-modify' :: forall n k a m p. (KnownNat n, KnownNat k, PrimMonad m, Storable a)
+modify' :: forall n k a m p. (KnownNat k, PrimMonad m, Storable a)
         => MVector (n+k+1) (PrimState m) a -> (a -> a) -> p k -> m ()
 modify' = VGM.modify'
 {-# inline modify' #-}
 
 -- | /O(1)/ Modify the element at a given 'Int' position without bounds
 -- checking.
-unsafeModify :: forall n m a. (KnownNat n, PrimMonad m, Storable a)
+unsafeModify :: forall n m a. (PrimMonad m, Storable a)
        => MVector n (PrimState m) a -> (a -> a) -> Int -> m ()
 unsafeModify = VGM.unsafeModify
 {-# inline unsafeModify #-}
 
 -- | /O(1)/ Swap the elements at a given type-safe position using 'Finite's.
-swap :: forall n m a. (KnownNat n, PrimMonad m, Storable a)
+swap :: forall n m a. (PrimMonad m, Storable a)
      => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()
 swap = VGM.swap
 {-# inline swap #-}
 
 -- | /O(1)/ Swap the elements at a given 'Int' position without bounds
 -- checking.
-unsafeSwap :: forall n m a. (KnownNat n, PrimMonad m, Storable a)
+unsafeSwap :: forall n m a. (PrimMonad m, Storable a)
            => MVector n (PrimState m) a -> Int -> Int -> m ()
 unsafeSwap = VGM.unsafeSwap
 {-# inline unsafeSwap #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position and return
 -- the old element, using 'Finite'.
-exchange :: forall n m a. (KnownNat n, PrimMonad m, Storable a)
+exchange :: forall n m a. (PrimMonad m, Storable a)
          => MVector n (PrimState m) a -> Finite n -> a -> m a
 exchange = VGM.exchange
 {-# inline exchange #-}
 
 -- | /O(1)/ Replace the element at a given type-safe position and return
 -- the old element, using 'Finite'.
-exchange' :: forall n k a m p. (KnownNat n, KnownNat k, PrimMonad m, Storable a)
+exchange' :: forall n k a m p. (KnownNat k, PrimMonad m, Storable a)
           => MVector (n+k+1) (PrimState m) a -> p k -> a -> m a
 exchange' = VGM.exchange'
 {-# inline exchange' #-}
 
 -- | /O(1)/ Replace the element at a given 'Int' position and return
 -- the old element. No bounds checks are performed.
-unsafeExchange :: forall n m a. (KnownNat n, PrimMonad m, Storable a)
+unsafeExchange :: forall n m a. (PrimMonad m, Storable a)
          => MVector n (PrimState m) a -> Int -> a -> m a
 unsafeExchange = VGM.unsafeExchange
 {-# inline unsafeExchange #-}
@@ -386,7 +386,7 @@
 
 -- | Compute the next (lexicographically) permutation of a given vector
 -- in-place.  Returns 'False' when the input is the last permutation.
-nextPermutation :: forall n e m. (KnownNat n, Ord e, PrimMonad m, Storable e)
+nextPermutation :: forall n e m. (Ord e, PrimMonad m, Storable e)
                 => MVector n (PrimState m) e -> m Bool
 nextPermutation = VGM.nextPermutation
 {-# inline nextPermutation #-}
diff --git a/src/Data/Vector/Storable/Sized.hs b/src/Data/Vector/Storable/Sized.hs
--- a/src/Data/Vector/Storable/Sized.hs
+++ b/src/Data/Vector/Storable/Sized.hs
@@ -293,19 +293,19 @@
 knownLength' = V.knownLength'
 
 -- | /O(1)/ Safe indexing using a 'Finite'.
-index :: forall n a. (KnownNat n, Storable a)
+index :: forall n a. Storable a
       => Vector n a -> Finite n -> a
 index = V.index
 {-# inline index #-}
 
 -- | /O(1)/ Safe indexing using a 'Proxy'.
-index' :: forall n m a p. (KnownNat n, KnownNat m, Storable a)
+index' :: forall n m a p. (KnownNat n, Storable a)
        => Vector (n+m+1) a -> p n -> a
 index' = V.index'
 {-# inline index' #-}
 
 -- | /O(1)/ Indexing using an Int without bounds checking.
-unsafeIndex :: forall n a. (KnownNat n, Storable a)
+unsafeIndex :: forall n a. Storable a
       => Vector n a -> Int -> a
 unsafeIndex = V.unsafeIndex
 {-# inline unsafeIndex #-}
@@ -323,19 +323,19 @@
 {-# inline last #-}
 
 -- | Lens to access (/O(1)/) and update (/O(n)/) an arbitrary element by its index.
-ix :: forall n a f. (KnownNat n, Storable a, Functor f)
+ix :: forall n a f. (Storable a, Functor f)
    => Finite n -> (a -> f a) -> Vector n a -> f (Vector n a)
 ix = V.ix
 {-# inline ix #-}
 
 -- | Lens to access (/O(1)/) and update (/O(n)/) the first element of a non-empty vector.
-_head :: forall n a f. (KnownNat n, Storable a, Functor f)
+_head :: forall n a f. (Storable a, Functor f)
       => (a -> f a) -> Vector (1+n) a -> f (Vector (1+n) a)
 _head = V._head
 {-# inline _head #-}
 
 -- | Lens to access (/O(1)/) and update (/O(n)/) the last element of a non-empty vector.
-_last :: forall n a f. (KnownNat n, Storable a, Functor f)
+_last :: forall n a f. (Storable a, Functor f)
        => (a -> f a) -> Vector (n+1) a -> f (Vector (n+1) a)
 _last = V._last
 {-# inline _last #-}
@@ -343,42 +343,42 @@
 
 -- | /O(1)/ Safe indexing in a monad. See the documentation for 'VG.indexM' for
 -- an explanation of why this is useful.
-indexM :: forall n a m. (KnownNat n, Storable a, Monad m)
+indexM :: forall n a m. (Storable a, Monad m)
       => Vector n a -> Finite n -> m a
 indexM = V.indexM
 {-# inline indexM #-}
 
 -- | /O(1)/ Safe indexing in a monad using a 'Proxy'. See the documentation for
 -- 'VG.indexM' for an explanation of why this is useful.
-indexM' :: forall n k a m p. (KnownNat n, KnownNat k, Storable a, Monad m)
+indexM' :: forall n k a m p. (KnownNat n, Storable a, Monad m)
       => Vector (n+k) a -> p n -> m a
 indexM' = V.indexM'
 {-# inline indexM' #-}
 
 -- | /O(1)/ Indexing using an Int without bounds checking. See the
 -- documentation for 'VG.indexM' for an explanation of why this is useful.
-unsafeIndexM :: forall n a m. (KnownNat n, Storable a, Monad m)
+unsafeIndexM :: forall n a m. (Storable a, Monad m)
       => Vector n a -> Int -> m a
 unsafeIndexM = V.unsafeIndexM
 {-# inline unsafeIndexM #-}
 
 -- | /O(1)/ Yield the first element of a non-empty vector in a monad. See the
 -- documentation for 'VG.indexM' for an explanation of why this is useful.
-headM :: forall n a m. (KnownNat n, Storable a, Monad m)
+headM :: forall n a m. (Storable a, Monad m)
       => Vector (1+n) a -> m a
 headM = V.headM
 {-# inline headM #-}
 
 -- | /O(1)/ Yield the last element of a non-empty vector in a monad. See the
 -- documentation for 'VG.indexM' for an explanation of why this is useful.
-lastM :: forall n a m. (KnownNat n, Storable a, Monad m)
+lastM :: forall n a m. (Storable a, Monad m)
       => Vector (n+1) a -> m a
 lastM = V.lastM
 {-# inline lastM #-}
 
 -- | /O(1)/ Yield a slice of the vector without copying it with an inferred
 -- length argument.
-slice :: forall i n m a p. (KnownNat i, KnownNat n, KnownNat m, Storable a)
+slice :: forall i n m a p. (KnownNat i, KnownNat n, Storable a)
       => p i -- ^ starting index
       -> Vector (i+n+m) a
       -> Vector n a
@@ -387,7 +387,7 @@
 
 -- | /O(1)/ Yield a slice of the vector without copying it with an explicit
 -- length argument.
-slice' :: forall i n m a p. (KnownNat i, KnownNat n, KnownNat m, Storable a)
+slice' :: forall i n m a p. (KnownNat i, KnownNat n, Storable a)
        => p i -- ^ starting index
        -> p n -- ^ length
        -> Vector (i+n+m) a
@@ -412,7 +412,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is inferred from the
 -- type.
-take :: forall n m a. (KnownNat n, KnownNat m, Storable a)
+take :: forall n m a. (KnownNat n, Storable a)
      => Vector (n+m) a -> Vector n a
 take = V.take
 {-# inline take #-}
@@ -420,7 +420,7 @@
 -- | /O(1)/ Yield the first n elements. The resultant vector always contains
 -- this many elements. The length of the resultant vector is given explicitly
 -- as a 'Proxy' argument.
-take' :: forall n m a p. (KnownNat n, KnownNat m, Storable a)
+take' :: forall n m a p. (KnownNat n, Storable a)
       => p n -> Vector (n+m) a -> Vector n a
 take' = V.take'
 {-# inline take' #-}
@@ -428,7 +428,7 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- inferred from the type.
-drop :: forall n m a. (KnownNat n, KnownNat m, Storable a)
+drop :: forall n m a. (KnownNat n, Storable a)
      => Vector (n+m) a -> Vector m a
 drop = V.drop
 {-# inline drop #-}
@@ -436,14 +436,14 @@
 -- | /O(1)/ Yield all but the the first n elements. The given vector must
 -- contain at least this many elements The length of the resultant vector is
 -- givel explicitly as a 'Proxy' argument.
-drop' :: forall n m a p. (KnownNat n, KnownNat m, Storable a)
+drop' :: forall n m a p. (KnownNat n, Storable a)
       => p n -> Vector (n+m) a -> Vector m a
 drop' = V.drop'
 {-# inline drop' #-}
 
 -- | /O(1)/ Yield the first n elements paired with the remainder without copying.
 -- The lengths of the resultant vector are inferred from the type.
-splitAt :: forall n m a. (KnownNat n, KnownNat m, Storable a)
+splitAt :: forall n m a. (KnownNat n, Storable a)
         => Vector (n+m) a -> (Vector n a, Vector m a)
 splitAt = V.splitAt
 {-# inline splitAt #-}
@@ -451,7 +451,7 @@
 -- | /O(1)/ Yield the first n elements paired with the remainder without
 -- copying.  The length of the first resultant vector is passed explicitly as a
 -- 'Proxy' argument.
-splitAt' :: forall n m a p. (KnownNat n, KnownNat m, Storable a)
+splitAt' :: forall n m a p. (KnownNat n, Storable a)
          => p n -> Vector (n+m) a -> (Vector n a, Vector m a)
 splitAt' = V.splitAt'
 {-# inline splitAt' #-}
@@ -1171,7 +1171,7 @@
 {-# inline foldl #-}
 
 -- | /O(n)/ Left fold on non-empty vectors
-foldl1 :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (1+n) a -> a
+foldl1 :: Storable a => (a -> a -> a) -> Vector (1+n) a -> a
 foldl1 = V.foldl1
 {-# inline foldl1 #-}
 
@@ -1181,7 +1181,7 @@
 {-# inline foldl' #-}
 
 -- | /O(n)/ Left fold on non-empty vectors with strict accumulator
-foldl1' :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (1+n) a -> a
+foldl1' :: Storable a => (a -> a -> a) -> Vector (1+n) a -> a
 foldl1' = V.foldl1'
 {-# inline foldl1' #-}
 
@@ -1191,7 +1191,7 @@
 {-# inline foldr #-}
 
 -- | /O(n)/ Right fold on non-empty vectors
-foldr1 :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n+1) a -> a
+foldr1 :: Storable a => (a -> a -> a) -> Vector (n+1) a -> a
 foldr1 = V.foldr1
 {-# inline foldr1 #-}
 
@@ -1201,7 +1201,7 @@
 {-# inline foldr' #-}
 
 -- | /O(n)/ Right fold on non-empty vectors with strict accumulator
-foldr1' :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n+1) a -> a
+foldr1' :: Storable a => (a -> a -> a) -> Vector (n+1) a -> a
 foldr1' = V.foldr1'
 {-# inline foldr1' #-}
 
@@ -1260,49 +1260,49 @@
 {-# inline product #-}
 
 -- | /O(n)/ Yield the maximum element of the non-empty vector.
-maximum :: (Storable a, Ord a, KnownNat n) => Vector (n+1) a -> a
+maximum :: (Storable a, Ord a) => Vector (n+1) a -> a
 maximum = V.maximum
 {-# inline maximum #-}
 
 -- | /O(n)/ Yield the maximum element of the non-empty vector according to the
 -- given comparison function.
-maximumBy :: (Storable a, KnownNat n)
+maximumBy :: Storable a
           => (a -> a -> Ordering) -> Vector (n+1) a -> a
 maximumBy = V.maximumBy
 {-# inline maximumBy #-}
 
 -- | /O(n)/ Yield the minimum element of the non-empty vector.
-minimum :: (Storable a, Ord a, KnownNat n) => Vector (n+1) a -> a
+minimum :: (Storable a, Ord a) => Vector (n+1) a -> a
 minimum = V.minimum
 {-# inline minimum #-}
 
 -- | /O(n)/ Yield the minimum element of the non-empty vector according to the
 -- given comparison function.
-minimumBy :: (Storable a, KnownNat n)
+minimumBy :: Storable a
           => (a -> a -> Ordering) -> Vector (n+1) a -> a
 minimumBy = V.minimumBy
 {-# inline minimumBy #-}
 
 -- | /O(n)/ Yield the index of the maximum element of the non-empty vector.
-maxIndex :: (Storable a, Ord a, KnownNat n) => Vector (n+1) a -> Finite (n + 1)
+maxIndex :: (Storable a, Ord a) => Vector (n+1) a -> Finite (n + 1)
 maxIndex = V.maxIndex
 {-# inline maxIndex #-}
 
 -- | /O(n)/ Yield the index of the maximum element of the non-empty vector
 -- according to the given comparison function.
-maxIndexBy :: (Storable a, KnownNat n)
+maxIndexBy :: Storable a
            => (a -> a -> Ordering) -> Vector (n+1) a -> Finite (n + 1)
 maxIndexBy = V.maxIndexBy
 {-# inline maxIndexBy #-}
 
 -- | /O(n)/ Yield the index of the minimum element of the non-empty vector.
-minIndex :: (Storable a, Ord a, KnownNat n) => Vector (n+1) a -> Finite (n + 1)
+minIndex :: (Storable a, Ord a) => Vector (n+1) a -> Finite (n + 1)
 minIndex = V.minIndex
 {-# inline minIndex #-}
 
 -- | /O(n)/ Yield the index of the minimum element of the non-empty vector
 -- according to the given comparison function.
-minIndexBy :: (Storable a, KnownNat n)
+minIndexBy :: Storable a
            => (a -> a -> Ordering) -> Vector (n+1) a -> Finite (n + 1)
 minIndexBy = V.minIndexBy
 {-# inline minIndexBy #-}
@@ -1320,7 +1320,7 @@
 {-# inline ifoldM #-}
 
 -- | /O(n)/ Monadic fold over non-empty vectors
-fold1M :: (Monad m, Storable a, KnownNat n)
+fold1M :: (Monad m, Storable a)
        => (a -> a -> m a) -> Vector (1+n) a -> m a
 fold1M = V.fold1M
 {-# inline fold1M #-}
@@ -1338,7 +1338,7 @@
 {-# inline ifoldM' #-}
 
 -- | /O(n)/ Monadic fold over non-empty vectors with strict accumulator
-fold1M' :: (Monad m, Storable a, KnownNat n)
+fold1M' :: (Monad m, Storable a)
         => (a -> a -> m a) -> Vector (n+1) a -> m a
 fold1M' = V.fold1M'
 {-# inline fold1M' #-}
@@ -1357,7 +1357,7 @@
 {-# inline ifoldM_ #-}
 
 -- | /O(n)/ Monadic fold over non-empty vectors that discards the result
-fold1M_ :: (Monad m, Storable a, KnownNat n)
+fold1M_ :: (Monad m, Storable a)
         => (a -> a -> m a) -> Vector (n+1) a -> m ()
 fold1M_ = V.fold1M_
 {-# inline fold1M_ #-}
@@ -1377,7 +1377,7 @@
 
 -- | /O(n)/ Monad fold over non-empty vectors with strict accumulator
 -- that discards the result
-fold1M'_ :: (Monad m, Storable a, KnownNat n)
+fold1M'_ :: (Monad m, Storable a)
          => (a -> a -> m a) -> Vector (n+1) a -> m ()
 fold1M'_ = V.fold1M'_
 {-# inline fold1M'_ #-}
@@ -1437,12 +1437,12 @@
 {-# inline scanl' #-}
 
 -- | /O(n)/ Scan over a non-empty vector
-scanl1 :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanl1 :: Storable a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
 scanl1 = V.scanl1
 {-# inline scanl1 #-}
 
 -- | /O(n)/ Scan over a non-empty vector with a strict accumulator
-scanl1' :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanl1' :: Storable a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
 scanl1' = V.scanl1'
 {-# inline scanl1' #-}
 
@@ -1477,13 +1477,13 @@
 {-# inline scanr' #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector
-scanr1 :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanr1 :: Storable a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
 scanr1 = V.scanr1
 {-# inline scanr1 #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
 -- accumulator
-scanr1' :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanr1' :: Storable a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
 scanr1' = V.scanr1'
 {-# inline scanr1' #-}
 
@@ -1592,7 +1592,7 @@
 
 -- | Apply a function on unsized vectors to a sized vector. The function must
 -- preserve the size of the vector, this is not checked.
-withVectorUnsafe :: forall a b (n :: Nat). (Storable a, Storable b)
+withVectorUnsafe :: forall a b (n :: Nat). ()
                  => (VS.Vector a -> VS.Vector b) -> Vector n a -> Vector n b
 withVectorUnsafe = V.withVectorUnsafe
 {-# inline withVectorUnsafe #-}
diff --git a/vector-sized.cabal b/vector-sized.cabal
--- a/vector-sized.cabal
+++ b/vector-sized.cabal
@@ -1,5 +1,5 @@
 name:                vector-sized
-version:             1.0.2.0
+version:             1.0.3.0
 synopsis:            Size tagged vectors
 description:         Please see README.md
 homepage:            http://github.com/expipiplus1/vector-sized#readme