vext 0.1.3.0 → 0.1.4.0

raw patch · 17 files changed

+507/−10 lines, 17 filesdep ~primitivePVP ok

version bump matches the API change (PVP)

Dependency ranges changed: primitive

API changes (from Hackage documentation)

Files

• src-imp/Int32.hs +6/−0
• src-imp/Int64.hs +7/−0
• src-imp/Word16.hs +5/−0
• src-imp/Word32.hs +44/−0
• src-imp/Word64.hs +44/−0
• src-imp/Word8.hs +6/−0
• src-indef/Vector.hs +12/−0
• src-prim-indef/Element.hsig +94/−0
• src-prim-indef/PrimVector.hs +50/−0
• src-prim-indef/Rep.hsig +8/−0
• src/Vector/Int32.hs +28/−1
• src/Vector/Int64.hs +26/−2
• src/Vector/Word16.hs +28/−3
• src/Vector/Word32.hs +46/−1
• src/Vector/Word64.hs +40/−1
• src/Vector/Word8.hs +25/−1
• vext.cabal +38/−1

@@ -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# #-}

@@ -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+

@@ -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

@@ -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

@@ -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)

@@ -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

@@ -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)

@@ -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 #)+

@@ -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

@@ -0,0 +1,8 @@+{-# language KindSignatures #-}++signature Rep where++import GHC.Exts (RuntimeRep)++data R :: RuntimeRep+

@@ -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 ""

@@ -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 ""

@@ -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 ""

@@ -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 ""

@@ -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 ""

@@ -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 ""

@@ -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: