diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,8 @@
 # Change Log
 
+## [0.5.0.0] - 2017-01-04
+- Use `Finite` from `finite-typelits` for indexing.
+
 ## [0.4.1.0] - 2016-11-24
 - Add `withSized` and `withSizedList`
 
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
@@ -58,6 +58,7 @@
   , replicate'
   , generate
   , generate'
+  , generate_
   , iterateN
   , iterateN'
     -- ** Monadic initialization
@@ -65,6 +66,7 @@
   , replicateM'
   , generateM
   , generateM'
+  , generateM_
     -- ** Unfolding
   , unfoldrN
   , unfoldrN'
@@ -227,6 +229,8 @@
 import qualified Data.Vector as Boxed
 import GHC.Generics (Generic)
 import GHC.TypeLits
+import Data.Finite
+import Data.Finite.Internal
 import Data.Proxy
 import Control.DeepSeq (NFData)
 import Foreign.Storable
@@ -292,10 +296,10 @@
 length' _ = Proxy
 {-# inline length' #-}
 
--- | /O(1)/ Indexing using an Int.
+-- | /O(1)/ Safe indexing using a 'Finite'.
 index :: forall v n a. (KnownNat n, VG.Vector v a)
-      => Vector v n a -> Int -> a
-index (Vector v) i = v VG.! i
+      => Vector v n a -> Finite n -> a
+index (Vector v) i = v `VG.unsafeIndex` fromIntegral i
 {-# inline index #-}
 
 -- | /O(1)/ Safe indexing using a 'Proxy'.
@@ -323,11 +327,11 @@
 last (Vector v) = VG.unsafeLast v
 {-# inline last #-}
 
--- | /O(1)/ Indexing in a monad. See the documentation for 'VG.indexM' for an
--- explanation of why this is useful.
+-- | /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)
-      => Vector v n a -> Int -> m a
-indexM (Vector v) i = v `VG.indexM` i
+      => Vector v n a -> Finite n -> m a
+indexM (Vector v) i = v `VG.indexM` fromIntegral i
 {-# inline indexM #-}
 
 -- | /O(1)/ Safe indexing in a monad using a 'Proxy'. See the documentation for
@@ -495,6 +499,17 @@
 generate' _ = generate
 {-# inline generate' #-}
 
+-- | /O(n)/ construct a vector of the given length by applying the function to
+-- each index where the length is inferred from the type.
+--
+-- The function can expect a @'Finite' n@, meaning that its input will
+-- always be between @0@ and @n - 1@.
+generate_ :: forall v n a. (KnownNat n, VG.Vector v a)
+          => (Finite n -> a) -> Vector v n a
+generate_ f = Vector (VG.generate i (f . Finite . fromIntegral))
+  where i = fromInteger (natVal (Proxy :: Proxy n))
+{-# inline generate_ #-}
+
 -- | /O(n)/ Apply function n times to value. Zeroth element is original value.
 -- The length is inferred from the type.
 iterateN :: forall v n a. (KnownNat n, VG.Vector v a)
@@ -543,6 +558,17 @@
            => Proxy n -> (Int -> m a) -> m (Vector v n a)
 generateM' _ = generateM
 {-# inline generateM' #-}
+
+-- | /O(n)/ Construct a vector of length @n@ by applying the monadic action to
+-- each index where n is inferred from the type.
+--
+-- The function can expect a @'Finite' n@, meaning that its input will
+-- always be between @0@ and @n - 1@.
+generateM_ :: forall v n m a. (KnownNat n, VG.Vector v a, Monad m)
+           => (Finite n -> m a) -> m (Vector v n a)
+generateM_ f = Vector <$> VG.generateM i (f . Finite . fromIntegral)
+  where i = fromInteger (natVal (Proxy :: Proxy n))
+{-# inline generateM_ #-}
 
 --
 -- ** Unfolding
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
@@ -55,6 +55,7 @@
   , replicate'
   , generate
   , generate'
+  , generate_
   , iterateN
   , iterateN'
     -- ** Monadic initialization
@@ -62,6 +63,7 @@
   , replicateM'
   , generateM
   , generateM'
+  , generateM_
     -- ** Unfolding
   , unfoldrN
   , unfoldrN'
@@ -221,6 +223,7 @@
 import qualified Data.Vector.Generic.Sized as V
 import qualified Data.Vector as VU
 import GHC.TypeLits
+import Data.Finite
 import Data.Proxy
 import Prelude hiding ( length, null,
                         replicate, (++), concat,
@@ -253,9 +256,9 @@
 length' = V.length'
 {-# inline length' #-}
 
--- | /O(1)/ Indexing using an Int.
+-- | /O(1)/ Safe indexing using a 'Finite'.
 index :: forall n a. KnownNat n
-      => Vector n a -> Int -> a
+      => Vector n a -> Finite n -> a
 index = V.index
 {-# inline index #-}
 
@@ -281,10 +284,10 @@
 last = V.last
 {-# inline last #-}
 
--- | /O(1)/ Indexing in a monad. See the documentation for 'VG.indexM' for an
--- explanation of why this is useful.
+-- | /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)
-      => Vector n a -> Int -> m a
+      => Vector n a -> Finite n -> m a
 indexM = V.indexM
 {-# inline indexM #-}
 
@@ -440,6 +443,16 @@
 generate' = V.generate'
 {-# inline generate' #-}
 
+-- | /O(n)/ construct a vector of the given length by applying the function to
+-- each index where the length is inferred from the type.
+--
+-- The function can expect a @'Finite' n@, meaning that its input will
+-- always be between @0@ and @n - 1@.
+generate_ :: forall n a. KnownNat n
+          => (Finite n -> a) -> Vector n a
+generate_ = V.generate_
+{-# inline generate_ #-}
+
 -- | /O(n)/ Apply function n times to value. Zeroth element is original value.
 -- The length is inferred from the type.
 iterateN :: forall n a. KnownNat n
@@ -478,6 +491,16 @@
           => (Int -> m a) -> m (Vector n a)
 generateM = V.generateM
 {-# inline generateM #-}
+
+-- | /O(n)/ Construct a vector of length @n@ by applying the monadic action to
+-- each index where n is inferred from the type.
+--
+-- The function can expect a @'Finite' n@, meaning that its input will
+-- always be between @0@ and @n - 1@.
+generateM_ :: forall n m a. (KnownNat n, Monad m)
+           => (Finite n -> m a) -> m (Vector n a)
+generateM_ = V.generateM_
+{-# inline generateM_ #-}
 
 -- | /O(n)/ Construct a vector of length @n@ by applying the monadic action to
 -- each index where n is given explicitly as a 'Proxy' argument.
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
@@ -55,6 +55,7 @@
   , replicate'
   , generate
   , generate'
+  , generate_
   , iterateN
   , iterateN'
     -- ** Monadic initialization
@@ -62,6 +63,7 @@
   , replicateM'
   , generateM
   , generateM'
+  , generateM_
     -- ** Unfolding
   , unfoldrN
   , unfoldrN'
@@ -221,6 +223,7 @@
 import qualified Data.Vector.Generic.Sized as V
 import qualified Data.Vector.Storable as VS
 import GHC.TypeLits
+import Data.Finite
 import Data.Proxy
 import Foreign.Storable
 import Prelude hiding ( length, null,
@@ -254,9 +257,9 @@
 length' = V.length'
 {-# inline length' #-}
 
--- | /O(1)/ Indexing using an Int.
+-- | /O(1)/ Safe indexing using a 'Finite'.
 index :: forall n a. (KnownNat n, Storable a)
-      => Vector n a -> Int -> a
+      => Vector n a -> Finite n -> a
 index = V.index
 {-# inline index #-}
 
@@ -284,10 +287,10 @@
 last = V.last
 {-# inline last #-}
 
--- | /O(1)/ Indexing in a monad. See the documentation for 'VG.indexM' for an
--- explanation of why this is useful.
+-- | /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)
-      => Vector n a -> Int -> m a
+      => Vector n a -> Finite n -> m a
 indexM = V.indexM
 {-# inline indexM #-}
 
@@ -447,6 +450,16 @@
 generate' = V.generate'
 {-# inline generate' #-}
 
+-- | /O(n)/ construct a vector of the given length by applying the function to
+-- each index where the length is inferred from the type.
+--
+-- The function can expect a @'Finite' n@, meaning that its input will
+-- always be between @0@ and @n - 1@.
+generate_ :: forall n a. (KnownNat n, Storable a)
+          => (Finite n -> a) -> Vector n a
+generate_ = V.generate_
+{-# inline generate_ #-}
+
 -- | /O(n)/ Apply function n times to value. Zeroth element is original value.
 -- The length is inferred from the type.
 iterateN :: forall n a. (KnownNat n, Storable a)
@@ -492,6 +505,16 @@
            => Proxy n -> (Int -> m a) -> m (Vector n a)
 generateM' = V.generateM'
 {-# inline generateM' #-}
+
+-- | /O(n)/ Construct a vector of length @n@ by applying the monadic action to
+-- each index where n is inferred from the type.
+--
+-- The function can expect a @'Finite' n@, meaning that its input will
+-- always be between @0@ and @n - 1@.
+generateM_ :: forall n m a. (KnownNat n, Storable a, Monad m)
+           => (Finite n -> m a) -> m (Vector n a)
+generateM_ = V.generateM_
+{-# inline generateM_ #-}
 
 --
 -- ** Unfolding
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:             0.4.1.0
+version:             0.5.0.0
 synopsis:            Size tagged vectors
 description:         Please see README.md
 homepage:            http://github.com/expipiplus1/vector-sized#readme
@@ -22,6 +22,7 @@
   build-depends:       base >= 4.9 && < 5
                      , vector >= 0.11 && < 0.12
                      , deepseq >= 1.1 && < 1.5
+                     , finite-typelits >= 0.1 && < 0.2
   default-language:    Haskell2010
 
 source-repository head