vext 0.1.4.0 → 0.1.5.0
raw patch · 3 files changed
+295/−2 lines, 3 files
Files
- src-imp/Int8.hs +173/−0
- src/Vector/Int8.hs +110/−0
- vext.cabal +12/−2
+ src-imp/Int8.hs view
@@ -0,0 +1,173 @@+{-# language MagicHash #-}+{-# language RankNTypes #-}+{-# language TypeApplications #-}+{-# language TypeFamilies #-}+{-# language TypeInType #-}+{-# language StandaloneKindSignatures #-}+{-# language UnboxedTuples #-}++module Int8+ ( R+ , A#+ , M#+ , empty#+ , index#+ , write#+ , read#+ , unsafeFreeze#+ , initialized#+ , set#+ , unsafeShrinkFreeze#+ , 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#(..))+import EmptyPrimArray (emptyPrimArray#)++import qualified GHC.Exts as Exts++type A# = PrimArray# @'Int8Rep+type M# = MutablePrimArray# @'Int8Rep+type R = 'Int8Rep++unsafeFromI8 :: forall (a :: TYPE 'Int8Rep). Int8# -> a+unsafeFromI8 x = unsafeCoerce# x++unsafeToI8 :: forall (a :: TYPE 'Int8Rep). a -> Int8#+unsafeToI8 x = unsafeCoerce# x++index# :: forall (a :: TYPE R). A# a -> Int# -> a+index# (PrimArray# a) i = unsafeFromI8 (indexInt8Array# a i)++write# :: forall (s :: Type) (a :: TYPE R).+ M# s a -> Int# -> a -> State# s -> State# s+write# (MutablePrimArray# m) ix a s = writeInt8Array# m ix (unsafeToI8 a) s++read# :: forall (s :: Type) (a :: TYPE R).+ M# s a -> Int# -> State# s -> (# State# s, a #)+read# (MutablePrimArray# m) ix s = case readInt8Array# m ix s of+ (# s', r #) -> case unsafeFromI8 r of+ r' -> (# s', r' #)++unsafeFreeze# :: forall (s :: Type) (a :: TYPE R).+ M# s a+ -> State# s+ -> (# State# s, A# a #)+unsafeFreeze# (MutablePrimArray# m) s0 = case unsafeFreezeByteArray# m s0 of+ (# s1, v #) -> (# s1, PrimArray# v #)++empty# :: forall (a :: TYPE R). (# #) -> A# a+empty# = emptyPrimArray#++initialized# :: forall (s :: Type) (a :: TYPE R).+ Int#+ -> a+ -> State# s+ -> (# State# s, M# s a #)+initialized# n a s0 = case newByteArray# n s0 of+ (# s1, m #) -> case Exts.setByteArray# m 0# n (Exts.int8ToInt# (unsafeToI8 a)) s1 of+ s2 -> (# s2, MutablePrimArray# m #)++set# :: forall (s :: Type) (a :: TYPE R).+ M# s a+ -> Int#+ -> Int#+ -> a+ -> State# s+ -> State# s+set# (MutablePrimArray# m) off0 len0 a s0 = Exts.setByteArray# m off0 len0 (Exts.int8ToInt# (unsafeToI8 a)) s0++-- shrink and freeze, all at once+unsafeShrinkFreeze# ::+ M# s a+ -> Int#+ -> State# s+ -> (# State# s, A# a #)+unsafeShrinkFreeze# (MutablePrimArray# m) i s0Alpha = case getSizeofMutableByteArray# m s0Alpha of+ (# s0, sz #) -> case sz ==# i of+ 1# -> case Exts.unsafeFreezeByteArray# m s0 of+ (# s1, v #) -> (# s1, PrimArray# v #)+ _ -> case Exts.shrinkMutableByteArray# m i s0 of+ s1 -> case Exts.unsafeFreezeByteArray# m s1 of+ (# s2, v #) -> (# s2, PrimArray# v #)++thaw# :: forall (s :: Type) (a :: TYPE R).+ A# a+ -> Int#+ -> Int#+ -> State# s+ -> (# State# s, M# s a #)+thaw# (PrimArray# v) off len s0 = case Exts.newByteArray# len s0 of+ (# s1, m #) -> case Exts.copyByteArray# v off m 0# len s1 of+ s2 -> (# s2, MutablePrimArray# m #)++freeze# :: forall (s :: Type) (a :: TYPE R).+ M# s a+ -> Int#+ -> Int#+ -> State# s+ -> (# State# s, A# a #)+freeze# (MutablePrimArray# v) off len s0 = case Exts.newByteArray# len s0 of+ (# s1, m #) -> case Exts.copyMutableByteArray# v off m 0# len s1 of+ s2 -> case Exts.unsafeFreezeByteArray# m s2 of+ (# s3, x #) -> (# s3, PrimArray# x #)++copy# :: forall (s :: Type) (a :: TYPE R).+ M# s a+ -> Int#+ -> A# a+ -> Int#+ -> Int#+ -> State# s+ -> State# s+copy# (MutablePrimArray# m) doff (PrimArray# v) soff len s0 =+ Exts.copyByteArray# v soff m doff 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# (ltInt8# (unsafeToI8 x) (unsafeToI8 y))++gt :: forall (a :: TYPE R). a -> a -> Bool+{-# inline gt #-}+gt x y = isTrue# (gtInt8# (unsafeToI8 x) (unsafeToI8 y))++eq :: forall (a :: TYPE R). a -> a -> Bool+{-# inline eq #-}+eq x y = isTrue# (eqInt8# (unsafeToI8 x) (unsafeToI8 y))++lt# :: forall (a :: TYPE R). a -> a -> Int#+{-# inline lt# #-}+lt# x y = ltInt8# (unsafeToI8 x) (unsafeToI8 y)++gt# :: forall (a :: TYPE R). a -> a -> Int#+{-# inline gt# #-}+gt# x y = gtInt8# (unsafeToI8 x) (unsafeToI8 y)++eq# :: forall (a :: TYPE R). a -> a -> Int#+{-# inline eq# #-}+eq# x y = eqInt8# (unsafeToI8 x) (unsafeToI8 y)++size :: Int+{-# inline size #-}+size = 1+
+ src/Vector/Int8.hs view
@@ -0,0 +1,110 @@+{-# language DataKinds #-}+{-# language MagicHash #-}+{-# language NumericUnderscores #-}+{-# language BangPatterns #-}+{-# language TypeApplications #-}+{-# language TypeOperators #-}++module Vector.Int8+ ( -- Types+ Vector(..)+ , Vector#+ , MutableVector(..)+ , MutableVector#+ , Bounded(..)+ , Vector_(..)+ -- * Primitives+ , write#+ , write+ , read#+ , index#+ , index+ , unlift+ , substitute+ , initialized+ , unsafeCoerceLength+ , expose+ , expose#+ -- * Ranges+ , set+ , setSlice+ -- * Freeze+ , unsafeShrinkFreeze+ , unsafeFreeze+ , freeze+ , freezeSlice+ -- * Copy+ , thaw+ -- * Composite+ , any+ , all+ , map+ , ifoldl'+ , ifoldlSlice'+ , replicate+ , construct1+ , construct3+ , construct4+ , construct5+ , construct6+ , construct7+ , append+ , clone+ , cloneSlice+ -- * Index+ , index0+ , index1+ , index2+ , index3+ , index4+ , index5+ , index6+ , index7+ , index8+ -- * Ordered+ , unique+ , equals+ , elem+ , findIndexEq+ , maximum+ , maximumSlice+ , maximumSliceInitial+ , bubbleSort+ , bubbleSortSlice+ , bubbleSortSliceInPlace+ , mapEq+ -- * Hide Length+ , vector_+ -- * Show+ , show+ -- * Interop with primitive+ , cloneFromByteArray+ ) where++import Prelude hiding (replicate,map,maximum,Bounded,all,any,elem,show)++import Arithmetic.Types (Nat#)+import Data.Primitive (ByteArray)+import GHC.Exts (Int8#)+import GHC.Int (Int8(I8#))++import Vector.Std.Int8+import Vector.Ord.Int8+import Vector.Eq.Int8++import qualified Vector.Prim.Int8++-- | 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 Int8#+cloneFromByteArray = Vector.Prim.Int8.unsafeCloneFromByteArray++show :: Nat# n -> Vector n Int8# -> String+show n v = liftShows (\i s -> shows (I8# i) s) n v ""+
vext.cabal view
@@ -1,6 +1,6 @@ cabal-version: 3.4 name: vext-version: 0.1.4.0+version: 0.1.5.0 synopsis: Array library monomorphized with backpack bug-reports: https://github.com/andrewthad/vex-unified/issues license: BSD-3-Clause@@ -169,6 +169,7 @@ EmptyPrimArray exposed-modules: Int+ Int8 Int16 Int32 Int64@@ -216,22 +217,25 @@ , Vector.Std.Word32 , Vector.Std.Word64 , Vector.Std.Word128+ , Vector.Std.Int8 , Vector.Std.Int16 , Vector.Std.Int32 , Vector.Std.Int , Vector.Eq.Int , Vector.Ord.Int+ , Vector.Ord.Int8 , Vector.Ord.Int16 , 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.Int8+ , Vector.Eq.Int16 , Vector.Eq.Int32 , Vector.Masked.Word128 , Vector.Masked.Word16@@ -256,6 +260,7 @@ , Vector.Zip.Word16.Lifted.Lifted , Vector.Zip.Lifted.Word16.Lifted , Vector.Zip.Bit.Bit.Bit+ , Vector.Prim.Int8 , Vector.Prim.Int32 , Vector.Prim.Int64 , Vector.Prim.Word8@@ -280,6 +285,7 @@ vext:indef (Vector as Vector.Std.Word32) requires (Element as Word32, Rep as Word32), vext:indef (Vector as Vector.Std.Word64) requires (Element as Word64, Rep as Word64), vext:indef (Vector as Vector.Std.Word128) requires (Element as Word128, Rep as Word128),+ vext:indef (Vector as Vector.Std.Int8) requires (Element as Int8, Rep as Int8), vext:indef (Vector as Vector.Std.Int32) requires (Element as Int32, Rep as Int32), vext:indef (Vector as Vector.Std.Int16) requires (Element as Int16, Rep as Int16), vext:indef (Vector as Vector.Std.Int) requires (Element as Int, Rep as Int),@@ -325,6 +331,7 @@ vext:type-eq-indef (TypeEqVector as Vector.Std.Unlifted.Eq.ShortText) requires (Element as Unlifted, Rep as Unlifted, Type as ShortText), vext:ord-indef (OrdVector as Vector.Ord.Int) requires (Element as Int, Rep as Int),+ vext:ord-indef (OrdVector as Vector.Ord.Int8) requires (Element as Int8, Rep as Int8), 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),@@ -335,10 +342,12 @@ vext:rep-eq-indef (EqVector as Vector.Eq.Int) requires (Element as Int, Rep as Int), vext:rep-eq-indef (EqVector as Vector.Eq.Int32) requires (Element as Int32, Rep as Int32), vext:rep-eq-indef (EqVector as Vector.Eq.Int16) requires (Element as Int16, Rep as Int16),+ vext:rep-eq-indef (EqVector as Vector.Eq.Int8) requires (Element as Int8, Rep as Int8), 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.Int8) requires (Element as Int8, Rep as Int8), 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),@@ -449,6 +458,7 @@ Vector.Word128 Vector.Word128.Masked Vector.Int+ Vector.Int8 Vector.Int16 Vector.Int32 Vector.Int64