diff --git a/src-imp/Int32.hs b/src-imp/Int32.hs
--- a/src-imp/Int32.hs
+++ b/src-imp/Int32.hs
@@ -30,6 +30,8 @@
   , eq#
   , max
   , freeze#
+    -- Metadata
+  , size
   ) where
 
 import Prelude hiding (max)
@@ -50,6 +52,10 @@
 
 unsafeToI32 :: forall (a :: TYPE 'Int32Rep). a -> Int32#
 unsafeToI32 x = unsafeCoerce# x
+
+size :: Int
+{-# inline size #-}
+size = 4
 
 index# :: forall (a :: TYPE R). A# a -> Int# -> a
 {-# inline index# #-}
diff --git a/src-imp/Int64.hs b/src-imp/Int64.hs
--- a/src-imp/Int64.hs
+++ b/src-imp/Int64.hs
@@ -30,6 +30,8 @@
   , gt#
   , eq#
   , max
+    -- Metadata
+  , size
   ) where
 
 import Prelude hiding (max)
@@ -178,3 +180,8 @@
   -> State# s
 copy# (MutablePrimArray# m) doff (PrimArray# v) soff len s0 =
   Exts.copyByteArray# v (8# *# soff) m (8# *# doff) (8# *# len) s0
+
+size :: Int
+{-# inline size #-}
+size = 8
+
diff --git a/src-imp/Word16.hs b/src-imp/Word16.hs
--- a/src-imp/Word16.hs
+++ b/src-imp/Word16.hs
@@ -30,6 +30,8 @@
   , gt#
   , eq#
   , max
+    -- Metadata
+  , size
   ) where
 
 import Prelude hiding (max)
@@ -179,3 +181,6 @@
 {-# inline eq# #-}
 eq# x y = eqWord16# (unsafeToW16 x) (unsafeToW16 y)
 
+size :: Int
+{-# inline size #-}
+size = 2
diff --git a/src-imp/Word32.hs b/src-imp/Word32.hs
--- a/src-imp/Word32.hs
+++ b/src-imp/Word32.hs
@@ -22,8 +22,20 @@
   , thaw#
   , freeze#
   , copy#
+    -- Comparison
+  , lt
+  , gt
+  , eq
+  , lt#
+  , gt#
+  , eq#
+  , max
+    -- Metadata
+  , size
   ) where
 
+import Prelude hiding (max)
+
 import GHC.Exts
 import Data.Kind (Type)
 import Data.Unlifted (PrimArray#(..),MutablePrimArray#(..))
@@ -140,3 +152,35 @@
   -> State# s
 copy# (MutablePrimArray# m) doff (PrimArray# v) soff len s0 =
   Exts.copyByteArray# v (4# *# soff) m (4# *# doff) (4# *# len) s0
+
+max :: forall (a :: TYPE R). a -> a -> a
+{-# inline max #-}
+max x y = if gt x y then x else y
+
+lt :: forall (a :: TYPE R). a -> a -> Bool
+{-# inline lt #-}
+lt x y = isTrue# (ltWord32# (unsafeToW32 x) (unsafeToW32 y))
+
+gt :: forall (a :: TYPE R). a -> a -> Bool
+{-# inline gt #-}
+gt x y = isTrue# (gtWord32# (unsafeToW32 x) (unsafeToW32 y))
+
+eq :: forall (a :: TYPE R). a -> a -> Bool
+{-# inline eq #-}
+eq x y = isTrue# (eqWord32# (unsafeToW32 x) (unsafeToW32 y))
+
+lt# :: forall (a :: TYPE R). a -> a -> Int#
+{-# inline lt# #-}
+lt# x y = ltWord32# (unsafeToW32 x) (unsafeToW32 y)
+
+gt# :: forall (a :: TYPE R). a -> a -> Int#
+{-# inline gt# #-}
+gt# x y = gtWord32# (unsafeToW32 x) (unsafeToW32 y)
+
+eq# :: forall (a :: TYPE R). a -> a -> Int#
+{-# inline eq# #-}
+eq# x y = eqWord32# (unsafeToW32 x) (unsafeToW32 y)
+
+size :: Int
+{-# inline size #-}
+size = 4
diff --git a/src-imp/Word64.hs b/src-imp/Word64.hs
--- a/src-imp/Word64.hs
+++ b/src-imp/Word64.hs
@@ -22,8 +22,20 @@
   , thaw#
   , freeze#
   , copy#
+    -- Comparison
+  , lt
+  , gt
+  , eq
+  , lt#
+  , gt#
+  , eq#
+  , max
+    -- Metadata
+  , size
   ) where
 
+import Prelude hiding (max)
+
 import GHC.Exts
 import Data.Kind (Type)
 import Data.Unlifted (PrimArray#(..),MutablePrimArray#(..))
@@ -140,3 +152,35 @@
   -> State# s
 copy# (MutablePrimArray# m) doff (PrimArray# v) soff len s0 =
   Exts.copyByteArray# v (8# *# soff) m (8# *# doff) (8# *# len) s0
+
+size :: Int
+{-# inline size #-}
+size = 8
+
+max :: forall (a :: TYPE R). a -> a -> a
+{-# inline max #-}
+max x y = if gt x y then x else y
+
+lt :: forall (a :: TYPE R). a -> a -> Bool
+{-# inline lt #-}
+lt x y = isTrue# (ltWord64# (unsafeToW64 x) (unsafeToW64 y))
+
+gt :: forall (a :: TYPE R). a -> a -> Bool
+{-# inline gt #-}
+gt x y = isTrue# (gtWord64# (unsafeToW64 x) (unsafeToW64 y))
+
+eq :: forall (a :: TYPE R). a -> a -> Bool
+{-# inline eq #-}
+eq x y = isTrue# (eqWord64# (unsafeToW64 x) (unsafeToW64 y))
+
+lt# :: forall (a :: TYPE R). a -> a -> Int#
+{-# inline lt# #-}
+lt# x y = ltWord64# (unsafeToW64 x) (unsafeToW64 y)
+
+gt# :: forall (a :: TYPE R). a -> a -> Int#
+{-# inline gt# #-}
+gt# x y = gtWord64# (unsafeToW64 x) (unsafeToW64 y)
+
+eq# :: forall (a :: TYPE R). a -> a -> Int#
+{-# inline eq# #-}
+eq# x y = eqWord64# (unsafeToW64 x) (unsafeToW64 y)
diff --git a/src-imp/Word8.hs b/src-imp/Word8.hs
--- a/src-imp/Word8.hs
+++ b/src-imp/Word8.hs
@@ -29,6 +29,8 @@
   , gt#
   , eq#
   , max
+    -- Metadata
+  , size
   ) where
 
 import Prelude hiding (max)
@@ -164,3 +166,7 @@
 eq# :: forall (a :: TYPE R). a -> a -> Int#
 {-# inline eq# #-}
 eq# x y = eqWord8# (unsafeToW8 x) (unsafeToW8 y)
+
+size :: Int
+{-# inline size #-}
+size = 1
diff --git a/src-indef/Vector.hs b/src-indef/Vector.hs
--- a/src-indef/Vector.hs
+++ b/src-indef/Vector.hs
@@ -70,6 +70,7 @@
   , ifoldr
   , ifoldl'
   , ifoldlSlice'
+  , liftShows
   , replicate
   , construct1
   , construct2
@@ -182,6 +183,17 @@
   -> b
 {-# inline foldr #-}
 foldr f b0 n v = Fin.descend# n b0 (\fin b -> f (index v fin) b)
+
+liftShows :: forall (n :: GHC.Nat) (a :: TYPE R).
+     (a -> String -> String)
+  -> Nat# n
+  -> Vector n a
+  -> String
+  -> String
+liftShows f n v s0 = case foldr (\e acc -> ',' : f e acc) (']' : s0) n v of
+  s@(']' : _) -> '[' : s
+  ',' : s -> '[' : s
+  _ -> errorWithoutStackTrace "vext.Vector.liftShow: impossible"
 
 ifoldr :: forall (n :: GHC.Nat) (a :: TYPE R) (b :: Type).
      (Fin# n -> a -> b -> b)
diff --git a/src-prim-indef/Element.hsig b/src-prim-indef/Element.hsig
new file mode 100644
--- /dev/null
+++ b/src-prim-indef/Element.hsig
@@ -0,0 +1,94 @@
+{-# language DataKinds #-}
+{-# language KindSignatures #-}
+{-# language MagicHash #-}
+{-# language RankNTypes #-}
+{-# language UnboxedTuples #-}
+{-# language TypeFamilies #-}
+{-# language StandaloneKindSignatures #-}
+
+signature Element where
+
+import Data.Unlifted (PrimArray#(..),MutablePrimArray#(..))
+import Data.Kind (Type)
+import GHC.Exts (TYPE,RuntimeRep(BoxedRep),Levity(Unlifted),State#,Int#)
+import Rep (R)
+
+type A# :: TYPE R -> TYPE ('BoxedRep 'Unlifted)
+type A# = PrimArray#
+
+type M# :: Type -> TYPE R -> TYPE ('BoxedRep 'Unlifted)
+type M# = MutablePrimArray#
+
+size :: Int
+
+unsafeFreeze# :: forall (s :: Type) (a :: TYPE R).
+     M# s a
+  -> State# s
+  -> (# State# s, A# a #)
+
+freeze# :: forall (s :: Type) (a :: TYPE R).
+     M# s a
+  -> Int# -- offset
+  -> Int# -- length
+  -> State# s
+  -> (# State# s, A# a #)
+
+-- This is a shrink-and-freeze operation
+unsafeShrinkFreeze# :: forall (s :: Type) (a :: TYPE R).
+     M# s a
+  -> Int#
+  -> State# s
+  -> (# State# s, A# a #)
+
+-- Length of zero. Does not require an element. Reallocates
+-- every time.
+empty# :: forall (a :: TYPE R). (# #) -> A# a
+
+initialized# :: forall (s :: Type) (a :: TYPE R).
+     Int#
+  -> a
+  -> State# s
+  -> (# State# s, M# s a #)
+
+index# :: forall (a :: TYPE R).
+     A# a
+  -> Int#
+  -> a
+
+write# :: forall (s :: Type) (a :: TYPE R).
+     M# s a
+  -> Int#
+  -> a
+  -> State# s
+  -> State# s
+
+read# :: forall (s :: Type) (a :: TYPE R).
+     M# s a
+  -> Int#
+  -> State# s
+  -> (# State# s, a #)
+
+set# :: forall (s :: Type) (a :: TYPE R).
+     M# s a
+  -> Int#
+  -> Int#
+  -> a
+  -> State# s
+  -> State# s
+
+copy# :: forall (s :: Type) (a :: TYPE R).
+     M# s a
+  -> Int#
+  -> A# a
+  -> Int#
+  -> Int#
+  -> State# s
+  -> State# s
+
+thaw# :: forall (s :: Type) (a :: TYPE R).
+     A# a
+  -> Int#
+  -> Int#
+  -> State# s
+  -> (# State# s, M# s a #)
+
diff --git a/src-prim-indef/PrimVector.hs b/src-prim-indef/PrimVector.hs
new file mode 100644
--- /dev/null
+++ b/src-prim-indef/PrimVector.hs
@@ -0,0 +1,50 @@
+{-# language BangPatterns #-}
+{-# language MagicHash #-}
+{-# language RankNTypes #-}
+{-# language ScopedTypeVariables #-}
+{-# language KindSignatures #-}
+
+module PrimVector
+  ( unsafeCloneFromByteArray
+  ) where
+
+import Arithmetic.Types (Nat#)
+import Control.Monad.ST (runST)
+import Data.Primitive (ByteArray(ByteArray))
+import Data.Unlifted (PrimArray#(PrimArray#))
+import GHC.Exts (TYPE)
+import GHC.Int (Int(I#))
+import GHC.TypeNats (Nat)
+import Rep (R)
+import Vector (Vector)
+
+import qualified Arithmetic.Nat as Nat
+import qualified Data.Primitive as PM
+import qualified Vector as V
+import qualified Element as E
+
+-- | Crashes the program if the range is out of bounds. That is,
+-- behavior is always well defined.
+--
+-- Interprets the bytes in a native-endian fashion.
+--
+-- This is unsafe because it interprets bytes as an arbitrary
+-- type.
+unsafeCloneFromByteArray :: forall (n :: Nat) (a :: TYPE R).
+     Int    -- ^ Offset into byte array, units are elements, not bytes
+  -> Nat# n -- ^ Length of the vector, units are elements, not bytes
+  -> ByteArray
+  -> Vector n a
+unsafeCloneFromByteArray !ix !n !b
+  | ix < 0 = errorWithoutStackTrace "PrimVector.cloneFromByteArray: negative offset"
+  | ixScaled + nScaled > sz = errorWithoutStackTrace "PrimVector.cloneFromByteArray: slice goes past the end"
+  | otherwise =
+      let !(ByteArray result) = runST $ do
+            dst <- PM.newByteArray nScaled
+            PM.copyByteArray dst 0 b ixScaled nScaled
+            PM.unsafeFreezeByteArray dst
+       in V.Vector (V.unsafeConstruct# (PrimArray# result))
+  where
+  sz = PM.sizeofByteArray b
+  ixScaled = ix * E.size
+  nScaled = I# (Nat.demote# n) * E.size
diff --git a/src-prim-indef/Rep.hsig b/src-prim-indef/Rep.hsig
new file mode 100644
--- /dev/null
+++ b/src-prim-indef/Rep.hsig
@@ -0,0 +1,8 @@
+{-# language KindSignatures #-}
+
+signature Rep where
+
+import GHC.Exts (RuntimeRep)
+
+data R :: RuntimeRep
+
diff --git a/src/Vector/Int32.hs b/src/Vector/Int32.hs
--- a/src/Vector/Int32.hs
+++ b/src/Vector/Int32.hs
@@ -40,8 +40,13 @@
   , ifoldl'
   , ifoldlSlice'
   , replicate
+  , construct1
+  , construct2
   , construct3
   , construct4
+  , construct5
+  , construct6
+  , construct7
   , append
   , clone
   , cloneSlice
@@ -64,9 +69,13 @@
     -- * Custom
   , cumulativeSum1
   , toFins
+    -- * Show
+  , show
+    -- * Interop with primitive
+  , cloneFromByteArray
   ) where
 
-import Prelude hiding (replicate,map,maximum,Bounded,all)
+import Prelude hiding (replicate,map,maximum,Bounded,all,show)
 
 import Vector.Std.Int32
 import Vector.Ord.Int32
@@ -77,10 +86,14 @@
 import GHC.Int (Int(I#),Int32(I32#),Int64(I64#))
 import GHC.TypeNats (type (+))
 import Arithmetic.Types (Nat#,Fin32#)
+import Data.Primitive (ByteArray(ByteArray))
+import Data.Unlifted (PrimArray#(PrimArray#))
 
 import qualified GHC.Exts as Exts
 import qualified Arithmetic.Fin as Fin
 import qualified Arithmetic.Nat as Nat
+import qualified Data.Primitive as PM
+import qualified Vector.Prim.Int32
 
 -- | Crashes if the sum of all the elements exceeds the maximum
 cumulativeSum1 ::
@@ -111,3 +124,17 @@
 toFins m n !v = if all (\v# -> let w = I32# v# in w >= 0 && fromIntegral @Int32 @Int w < I# (Nat.demote# m)) n v
   then Just (unsafeCoerceVector v)
   else Nothing
+
+-- | Crashes the program if the range is out of bounds. That is,
+-- behavior is always well defined.
+--
+-- Interprets the bytes in a native-endian fashion.
+cloneFromByteArray ::
+     Int    -- ^ Offset into byte array, units are elements, not bytes
+  -> Nat# n -- ^ Length of the vector, units are elements, not bytes
+  -> ByteArray
+  -> Vector n Int32#
+cloneFromByteArray = Vector.Prim.Int32.unsafeCloneFromByteArray
+
+show :: Nat# n -> Vector n Int32# -> String
+show n v = liftShows (\i s -> shows (I32# i) s) n v ""
diff --git a/src/Vector/Int64.hs b/src/Vector/Int64.hs
--- a/src/Vector/Int64.hs
+++ b/src/Vector/Int64.hs
@@ -47,7 +47,6 @@
   , append
   , clone
   , cloneSlice
-  , cloneSlice
     -- * Index
   , index0
   , index1
@@ -63,9 +62,34 @@
   , bubbleSortSlice
   , bubbleSortSliceInPlace
   , mapEq
+    -- * Show
+  , show
+    -- * Interop with primitive
+  , cloneFromByteArray
   ) where
 
-import Prelude hiding (replicate,map,maximum,Bounded,all,foldr)
+import Prelude hiding (replicate,map,maximum,Bounded,all,foldr,show)
 
+import Arithmetic.Types (Nat#)
+import Data.Primitive (ByteArray)
+import GHC.Exts (Int64#)
+import GHC.Int (Int64(I64#))
+
 import Vector.Std.Int64
 import Vector.Ord.Int64
+
+import qualified Vector.Prim.Int64
+
+-- | Crashes the program if the range is out of bounds. That is,
+-- behavior is always well defined.
+--
+-- Interprets the bytes in a native-endian fashion.
+cloneFromByteArray ::
+     Int    -- ^ Offset into byte array, units are elements, not bytes
+  -> Nat# n -- ^ Length of the vector, units are elements, not bytes
+  -> ByteArray
+  -> Vector n Int64#
+cloneFromByteArray = Vector.Prim.Int64.unsafeCloneFromByteArray
+
+show :: Nat# n -> Vector n Int64# -> String
+show n v = liftShows (\i s -> shows (I64# i) s) n v ""
diff --git a/src/Vector/Word16.hs b/src/Vector/Word16.hs
--- a/src/Vector/Word16.hs
+++ b/src/Vector/Word16.hs
@@ -75,10 +75,35 @@
   , mapEq
     -- * Hide Length
   , vector_
+    -- * Show
+  , show
+    -- * Interop with primitive
+  , cloneFromByteArray
   ) where
 
-import Prelude hiding (replicate,map,maximum,Bounded,all,any,elem)
+import Prelude hiding (replicate,map,maximum,Bounded,all,any,elem,show)
 
-import Vector.Std.Word16
-import Vector.Ord.Word16
+import Arithmetic.Types (Nat#)
+import Data.Primitive (ByteArray)
+import GHC.Exts (Word16#)
+import GHC.Word (Word16(W16#))
+
 import Vector.Eq.Word16
+import Vector.Ord.Word16
+import Vector.Std.Word16
+
+import qualified Vector.Prim.Word16
+
+-- | Crashes the program if the range is out of bounds. That is,
+-- behavior is always well defined.
+--
+-- Interprets the bytes in a native-endian fashion.
+cloneFromByteArray ::
+     Int    -- ^ Offset into byte array, units are elements, not bytes
+  -> Nat# n -- ^ Length of the vector, units are elements, not bytes
+  -> ByteArray
+  -> Vector n Word16#
+cloneFromByteArray = Vector.Prim.Word16.unsafeCloneFromByteArray
+
+show :: Nat# n -> Vector n Word16# -> String
+show n v = liftShows (\i s -> shows (W16# i) s) n v ""
diff --git a/src/Vector/Word32.hs b/src/Vector/Word32.hs
--- a/src/Vector/Word32.hs
+++ b/src/Vector/Word32.hs
@@ -36,12 +36,18 @@
     -- * Copy
   , thaw
     -- * Composite
+  , any
+  , all
   , map
   , ifoldl'
   , ifoldlSlice'
   , replicate
+  , construct1
   , construct3
   , construct4
+  , construct5
+  , construct6
+  , construct7
   , append
   , clone
   , cloneSlice
@@ -50,8 +56,47 @@
   , index1
   , index2
   , index3
+    -- * Ordered
+  , unique
+  , equals
+  , elem
+  , findIndexEq
+  , maximum
+  , maximumSlice
+  , maximumSliceInitial
+  , bubbleSort
+  , bubbleSortSlice
+  , bubbleSortSliceInPlace
+  , mapEq
+    -- * Show
+  , show
+    -- * Interop with primitive
+  , cloneFromByteArray
   ) where
 
-import Prelude hiding (replicate,map,maximum,Bounded,all)
+import Prelude hiding (replicate,map,maximum,Bounded,all,any,elem,show)
 
+import Arithmetic.Types (Nat#)
+import Data.Primitive (ByteArray)
+import GHC.Exts (Word32#)
+import GHC.Word (Word32(W32#))
+
 import Vector.Std.Word32
+import Vector.Eq.Word32
+import Vector.Ord.Word32
+
+import qualified Vector.Prim.Word32
+
+-- | Crashes the program if the range is out of bounds. That is,
+-- behavior is always well defined.
+--
+-- Interprets the bytes in a native-endian fashion.
+cloneFromByteArray ::
+     Int    -- ^ Offset into byte array, units are elements, not bytes
+  -> Nat# n -- ^ Length of the vector, units are elements, not bytes
+  -> ByteArray
+  -> Vector n Word32#
+cloneFromByteArray = Vector.Prim.Word32.unsafeCloneFromByteArray
+
+show :: Nat# n -> Vector n Word32# -> String
+show n v = liftShows (\i s -> shows (W32# i) s) n v ""
diff --git a/src/Vector/Word64.hs b/src/Vector/Word64.hs
--- a/src/Vector/Word64.hs
+++ b/src/Vector/Word64.hs
@@ -50,8 +50,47 @@
   , index1
   , index2
   , index3
+    -- * Ordered
+  , unique
+  , equals
+  , elem
+  , findIndexEq
+  , maximum
+  , maximumSlice
+  , maximumSliceInitial
+  , bubbleSort
+  , bubbleSortSlice
+  , bubbleSortSliceInPlace
+  , mapEq
+    -- * Show
+  , show
+    -- * Interop with primitive
+  , cloneFromByteArray
   ) where
 
-import Prelude hiding (replicate,map,maximum,Bounded,all)
+import Prelude hiding (replicate,map,maximum,Bounded,all,elem,show)
 
+import Arithmetic.Types (Nat#)
+import Data.Primitive (ByteArray)
+import GHC.Exts (Word64#)
+import GHC.Word (Word64(W64#))
+
 import Vector.Std.Word64
+import Vector.Eq.Word64
+import Vector.Ord.Word64
+
+import qualified Vector.Prim.Word64
+
+-- | Crashes the program if the range is out of bounds. That is,
+-- behavior is always well defined.
+--
+-- Interprets the bytes in a native-endian fashion.
+cloneFromByteArray ::
+     Int    -- ^ Offset into byte array, units are elements, not bytes
+  -> Nat# n -- ^ Length of the vector, units are elements, not bytes
+  -> ByteArray
+  -> Vector n Word64#
+cloneFromByteArray = Vector.Prim.Word64.unsafeCloneFromByteArray
+
+show :: Nat# n -> Vector n Word64# -> String
+show n v = liftShows (\i s -> shows (W64# i) s) n v ""
diff --git a/src/Vector/Word8.hs b/src/Vector/Word8.hs
--- a/src/Vector/Word8.hs
+++ b/src/Vector/Word8.hs
@@ -75,11 +75,35 @@
   , mapEq
     -- * Hide Length
   , vector_
+    -- * Show
+  , show
+    -- * Interop with primitive
+  , cloneFromByteArray
   ) where
 
-import Prelude hiding (replicate,map,maximum,Bounded,all,any,elem)
+import Prelude hiding (replicate,map,maximum,Bounded,all,any,elem,show)
 
+import Arithmetic.Types (Nat#)
+import Data.Primitive (ByteArray)
+import GHC.Exts (Word8#)
+import GHC.Word (Word8(W8#))
+
 import Vector.Std.Word8
 import Vector.Ord.Word8
 import Vector.Eq.Word8
 
+import qualified Vector.Prim.Word8
+
+-- | Crashes the program if the range is out of bounds. That is,
+-- behavior is always well defined.
+--
+-- Interprets the bytes in a native-endian fashion.
+cloneFromByteArray ::
+     Int    -- ^ Offset into byte array, units are elements, not bytes
+  -> Nat# n -- ^ Length of the vector, units are elements, not bytes
+  -> ByteArray
+  -> Vector n Word8#
+cloneFromByteArray = Vector.Prim.Word8.unsafeCloneFromByteArray
+
+show :: Nat# n -> Vector n Word8# -> String
+show n v = liftShows (\i s -> shows (W8# i) s) n v ""
diff --git a/vext.cabal b/vext.cabal
--- a/vext.cabal
+++ b/vext.cabal
@@ -1,6 +1,6 @@
 cabal-version: 3.4
 name: vext
-version: 0.1.3.0
+version: 0.1.4.0
 synopsis: Array library monomorphized with backpack
 bug-reports: https://github.com/andrewthad/vex-unified/issues
 license: BSD-3-Clause
@@ -26,6 +26,22 @@
   default-language: Haskell2010
   ghc-options: -O2 -Wall
 
+library prim-indef
+  exposed-modules:
+    PrimVector
+  build-depends:
+    , base >=4.12.0.0 && <5
+    , natural-arithmetic
+    , unlifted
+    , primitive >=0.9
+    , vext:indef
+  signatures:
+    Element
+    Rep
+  hs-source-dirs: src-prim-indef
+  default-language: Haskell2010
+  ghc-options: -O2 -Wall
+
 library map-indef
   exposed-modules:
     MapVector
@@ -209,9 +225,13 @@
     , Vector.Ord.Int32
     , Vector.Ord.Word8
     , Vector.Ord.Word16
+    , Vector.Ord.Word32
+    , Vector.Ord.Word64
     , Vector.Eq.Int16
     , Vector.Eq.Word8
     , Vector.Eq.Word16
+    , Vector.Eq.Word32
+    , Vector.Eq.Word64
     , Vector.Eq.Int32
     , Vector.Masked.Word128
     , Vector.Masked.Word16
@@ -236,6 +256,12 @@
     , Vector.Zip.Word16.Lifted.Lifted
     , Vector.Zip.Lifted.Word16.Lifted
     , Vector.Zip.Bit.Bit.Bit
+    , Vector.Prim.Int32
+    , Vector.Prim.Int64
+    , Vector.Prim.Word8
+    , Vector.Prim.Word16
+    , Vector.Prim.Word32
+    , Vector.Prim.Word64
   build-depends:
     , vext:imp
     , vext:indef
@@ -245,6 +271,7 @@
     , vext:rep-eq-indef
     , vext:type-eq-indef
     , vext:mask-indef
+    , vext:prim-indef
     , primitive >=0.7
   mixins:
     vext:indef (Vector as Vector.Std.Word) requires (Element as Word, Rep as Word),
@@ -301,6 +328,8 @@
     vext:ord-indef (OrdVector as Vector.Ord.Int16) requires (Element as Int16, Rep as Int16),
     vext:ord-indef (OrdVector as Vector.Ord.Word8) requires (Element as Word8, Rep as Word8),
     vext:ord-indef (OrdVector as Vector.Ord.Word16) requires (Element as Word16, Rep as Word16),
+    vext:ord-indef (OrdVector as Vector.Ord.Word32) requires (Element as Word32, Rep as Word32),
+    vext:ord-indef (OrdVector as Vector.Ord.Word64) requires (Element as Word64, Rep as Word64),
     vext:ord-indef (OrdVector as Vector.Ord.Int32) requires (Element as Int32, Rep as Int32),
     vext:ord-indef (OrdVector as Vector.Ord.Int64) requires (Element as Int64, Rep as Int64),
     vext:rep-eq-indef (EqVector as Vector.Eq.Int) requires (Element as Int, Rep as Int),
@@ -308,6 +337,14 @@
     vext:rep-eq-indef (EqVector as Vector.Eq.Int16) requires (Element as Int16, Rep as Int16),
     vext:rep-eq-indef (EqVector as Vector.Eq.Word8) requires (Element as Word8, Rep as Word8),
     vext:rep-eq-indef (EqVector as Vector.Eq.Word16) requires (Element as Word16, Rep as Word16),
+    vext:rep-eq-indef (EqVector as Vector.Eq.Word32) requires (Element as Word32, Rep as Word32),
+    vext:rep-eq-indef (EqVector as Vector.Eq.Word64) requires (Element as Word64, Rep as Word64),
+    vext:prim-indef (PrimVector as Vector.Prim.Int32) requires (Element as Int32, Rep as Int32),
+    vext:prim-indef (PrimVector as Vector.Prim.Int64) requires (Element as Int64, Rep as Int64),
+    vext:prim-indef (PrimVector as Vector.Prim.Word8) requires (Element as Word8, Rep as Word8),
+    vext:prim-indef (PrimVector as Vector.Prim.Word16) requires (Element as Word16, Rep as Word16),
+    vext:prim-indef (PrimVector as Vector.Prim.Word32) requires (Element as Word32, Rep as Word32),
+    vext:prim-indef (PrimVector as Vector.Prim.Word64) requires (Element as Word64, Rep as Word64),
 
 library pair-indef
   exposed-modules: