Z-Data 2.0.0.2 → 2.0.1.0
raw patch · 5 files changed
+53/−34 lines, 5 filesdep ~primitivePVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependency ranges changed: primitive
API changes (from Hackage documentation)
- Z.Data.Array.UnliftedArray: instance Z.Data.Array.UnliftedArray.PrimUnlifted (Data.Primitive.ByteArray.MutableByteArray s)
- Z.Data.Array.UnliftedArray: instance Z.Data.Array.UnliftedArray.PrimUnlifted Data.Primitive.ByteArray.ByteArray
- Z.Data.JSON.Base: instance Z.Data.JSON.Base.JSON Data.Primitive.ByteArray.ByteArray
- Z.Data.Text.Base: instance GHC.Exts.IsList Z.Data.Text.Base.Text
- Z.Data.Vector.Base: instance Data.Primitive.Types.Prim a => GHC.Exts.IsList (Z.Data.Vector.Base.PrimVector a)
- Z.Data.Vector.Base: instance GHC.Exts.IsList (Z.Data.Vector.Base.Vector a)
+ Z.Data.Array: alignmentOfType# :: Prim a => Proxy a -> Int#
+ Z.Data.Array: sizeOfType# :: Prim a => Proxy a -> Int#
+ Z.Data.Array.Base: alignmentOfType# :: Prim a => Proxy a -> Int#
+ Z.Data.Array.Base: sizeOfType# :: Prim a => Proxy a -> Int#
+ Z.Data.Array.UnliftedArray: instance Z.Data.Array.UnliftedArray.PrimUnlifted (Data.Array.Byte.MutableByteArray s)
+ Z.Data.Array.UnliftedArray: instance Z.Data.Array.UnliftedArray.PrimUnlifted Data.Array.Byte.ByteArray
+ Z.Data.JSON.Base: instance Z.Data.JSON.Base.JSON Data.Array.Byte.ByteArray
+ Z.Data.PrimRef: alignmentOfType# :: Prim a => Proxy a -> Int#
+ Z.Data.PrimRef: sizeOfType# :: Prim a => Proxy a -> Int#
+ Z.Data.Text.Base: instance GHC.IsList.IsList Z.Data.Text.Base.Text
+ Z.Data.Vector.Base: instance Data.Primitive.Types.Prim a => GHC.IsList.IsList (Z.Data.Vector.Base.PrimVector a)
+ Z.Data.Vector.Base: instance GHC.IsList.IsList (Z.Data.Vector.Base.Vector a)
+ Z.Foreign: MutablePrimArray :: MutableByteArray# s -> MutablePrimArray s a
+ Z.Foreign: PrimArray :: ByteArray# -> PrimArray a
+ Z.Foreign: cloneMutablePrimArray :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> Int -> Int -> m (MutablePrimArray (PrimState m) a)
+ Z.Foreign: clonePrimArray :: Prim a => PrimArray a -> Int -> Int -> PrimArray a
+ Z.Foreign: copyMutablePrimArray :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> Int -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()
+ Z.Foreign: copyMutablePrimArrayToPtr :: (PrimMonad m, Prim a) => Ptr a -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()
+ Z.Foreign: copyPrimArray :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> Int -> PrimArray a -> Int -> Int -> m ()
+ Z.Foreign: copyPrimArrayToPtr :: (PrimMonad m, Prim a) => Ptr a -> PrimArray a -> Int -> Int -> m ()
+ Z.Foreign: copyPtrToMutablePrimArray :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> Int -> Ptr a -> Int -> m ()
+ Z.Foreign: data () => MutablePrimArray s a
+ Z.Foreign: data () => PrimArray a
+ Z.Foreign: emptyPrimArray :: PrimArray a
+ Z.Foreign: filterPrimArray :: Prim a => (a -> Bool) -> PrimArray a -> PrimArray a
+ Z.Foreign: filterPrimArrayA :: (Applicative f, Prim a) => (a -> f Bool) -> PrimArray a -> f (PrimArray a)
+ Z.Foreign: filterPrimArrayP :: (PrimMonad m, Prim a) => (a -> m Bool) -> PrimArray a -> m (PrimArray a)
+ Z.Foreign: foldlPrimArray :: Prim a => (b -> a -> b) -> b -> PrimArray a -> b
+ Z.Foreign: foldlPrimArray' :: Prim a => (b -> a -> b) -> b -> PrimArray a -> b
+ Z.Foreign: foldlPrimArrayM' :: (Prim a, Monad m) => (b -> a -> m b) -> b -> PrimArray a -> m b
+ Z.Foreign: foldrPrimArray :: Prim a => (a -> b -> b) -> b -> PrimArray a -> b
+ Z.Foreign: foldrPrimArray' :: Prim a => (a -> b -> b) -> b -> PrimArray a -> b
+ Z.Foreign: freezePrimArray :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> Int -> Int -> m (PrimArray a)
+ Z.Foreign: generatePrimArray :: Prim a => Int -> (Int -> a) -> PrimArray a
+ Z.Foreign: generatePrimArrayA :: (Applicative f, Prim a) => Int -> (Int -> f a) -> f (PrimArray a)
+ Z.Foreign: generatePrimArrayP :: (PrimMonad m, Prim a) => Int -> (Int -> m a) -> m (PrimArray a)
+ Z.Foreign: getSizeofMutablePrimArray :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> m Int
+ Z.Foreign: imapPrimArray :: (Prim a, Prim b) => (Int -> a -> b) -> PrimArray a -> PrimArray b
+ Z.Foreign: indexPrimArray :: Prim a => PrimArray a -> Int -> a
+ Z.Foreign: isMutablePrimArrayPinned :: MutablePrimArray s a -> Bool
+ Z.Foreign: isPrimArrayPinned :: PrimArray a -> Bool
+ Z.Foreign: itraversePrimArray :: (Applicative f, Prim a, Prim b) => (Int -> a -> f b) -> PrimArray a -> f (PrimArray b)
+ Z.Foreign: itraversePrimArrayP :: (Prim a, Prim b, PrimMonad m) => (Int -> a -> m b) -> PrimArray a -> m (PrimArray b)
+ Z.Foreign: itraversePrimArray_ :: (Applicative f, Prim a) => (Int -> a -> f b) -> PrimArray a -> f ()
+ Z.Foreign: mapMaybePrimArray :: (Prim a, Prim b) => (a -> Maybe b) -> PrimArray a -> PrimArray b
+ Z.Foreign: mapMaybePrimArrayA :: (Applicative f, Prim a, Prim b) => (a -> f (Maybe b)) -> PrimArray a -> f (PrimArray b)
+ Z.Foreign: mapMaybePrimArrayP :: (PrimMonad m, Prim a, Prim b) => (a -> m (Maybe b)) -> PrimArray a -> m (PrimArray b)
+ Z.Foreign: mapPrimArray :: (Prim a, Prim b) => (a -> b) -> PrimArray a -> PrimArray b
+ Z.Foreign: mutablePrimArrayContents :: MutablePrimArray s a -> Ptr a
+ Z.Foreign: newAlignedPinnedPrimArray :: (PrimMonad m, Prim a) => Int -> m (MutablePrimArray (PrimState m) a)
+ Z.Foreign: newPinnedPrimArray :: (PrimMonad m, Prim a) => Int -> m (MutablePrimArray (PrimState m) a)
+ Z.Foreign: newPrimArray :: (PrimMonad m, Prim a) => Int -> m (MutablePrimArray (PrimState m) a)
+ Z.Foreign: primArrayContents :: PrimArray a -> Ptr a
+ Z.Foreign: primArrayFromList :: Prim a => [a] -> PrimArray a
+ Z.Foreign: primArrayFromListN :: Prim a => Int -> [a] -> PrimArray a
+ Z.Foreign: primArrayToList :: Prim a => PrimArray a -> [a]
+ Z.Foreign: readPrimArray :: (Prim a, PrimMonad m) => MutablePrimArray (PrimState m) a -> Int -> m a
+ Z.Foreign: replicatePrimArray :: Prim a => Int -> a -> PrimArray a
+ Z.Foreign: replicatePrimArrayA :: (Applicative f, Prim a) => Int -> f a -> f (PrimArray a)
+ Z.Foreign: replicatePrimArrayP :: (PrimMonad m, Prim a) => Int -> m a -> m (PrimArray a)
+ Z.Foreign: resizeMutablePrimArray :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> Int -> m (MutablePrimArray (PrimState m) a)
+ Z.Foreign: runPrimArray :: (forall s. () => ST s (MutablePrimArray s a)) -> PrimArray a
+ Z.Foreign: sameMutablePrimArray :: MutablePrimArray s a -> MutablePrimArray s a -> Bool
+ Z.Foreign: setPrimArray :: (Prim a, PrimMonad m) => MutablePrimArray (PrimState m) a -> Int -> Int -> a -> m ()
+ Z.Foreign: shrinkMutablePrimArray :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> Int -> m ()
+ Z.Foreign: sizeofMutablePrimArray :: forall s a. Prim a => MutablePrimArray s a -> Int
+ Z.Foreign: sizeofPrimArray :: Prim a => PrimArray a -> Int
+ Z.Foreign: thawPrimArray :: (PrimMonad m, Prim a) => PrimArray a -> Int -> Int -> m (MutablePrimArray (PrimState m) a)
+ Z.Foreign: traversePrimArray :: (Applicative f, Prim a, Prim b) => (a -> f b) -> PrimArray a -> f (PrimArray b)
+ Z.Foreign: traversePrimArrayP :: (PrimMonad m, Prim a, Prim b) => (a -> m b) -> PrimArray a -> m (PrimArray b)
+ Z.Foreign: traversePrimArray_ :: (Applicative f, Prim a) => (a -> f b) -> PrimArray a -> f ()
+ Z.Foreign: unsafeFreezePrimArray :: PrimMonad m => MutablePrimArray (PrimState m) a -> m (PrimArray a)
+ Z.Foreign: unsafeThawPrimArray :: PrimMonad m => PrimArray a -> m (MutablePrimArray (PrimState m) a)
+ Z.Foreign: writePrimArray :: (Prim a, PrimMonad m) => MutablePrimArray (PrimState m) a -> Int -> a -> m ()
- Z.Data.Array: class Prim a
+ Z.Data.Array: class () => Prim a
- Z.Data.Array: data Array a
+ Z.Data.Array: data () => Array a
- Z.Data.Array: data ArrayException
+ Z.Data.Array: data () => ArrayException
- Z.Data.Array: data MutableArray s a
+ Z.Data.Array: data () => MutableArray s a
- Z.Data.Array: data MutablePrimArray s a
+ Z.Data.Array: data () => MutablePrimArray s a
- Z.Data.Array: data PrimArray a
+ Z.Data.Array: data () => PrimArray a
- Z.Data.Array: data SmallArray a
+ Z.Data.Array: data () => SmallArray a
- Z.Data.Array: data SmallMutableArray s a
+ Z.Data.Array: data () => SmallMutableArray s a
- Z.Data.Array.Base: class Prim a
+ Z.Data.Array.Base: class () => Prim a
- Z.Data.Array.Base: data Array a
+ Z.Data.Array.Base: data () => Array a
- Z.Data.Array.Base: data ArrayException
+ Z.Data.Array.Base: data () => ArrayException
- Z.Data.Array.Base: data MutableArray s a
+ Z.Data.Array.Base: data () => MutableArray s a
- Z.Data.Array.Base: data MutablePrimArray s a
+ Z.Data.Array.Base: data () => MutablePrimArray s a
- Z.Data.Array.Base: data PrimArray a
+ Z.Data.Array.Base: data () => PrimArray a
- Z.Data.Array.Base: data SmallArray a
+ Z.Data.Array.Base: data () => SmallArray a
- Z.Data.Array.Base: data SmallMutableArray s a
+ Z.Data.Array.Base: data () => SmallMutableArray s a
- Z.Data.PrimRef: class Prim a
+ Z.Data.PrimRef: class () => Prim a
- Z.Data.Text: data Collator
+ Z.Data.Text: data () => Collator
- Z.Data.Text: data CollatorOptions
+ Z.Data.Text: data () => CollatorOptions
- Z.Data.Text: data Lang
+ Z.Data.Text: data () => Lang
- Z.Data.Text: data VariableWeighting
+ Z.Data.Text: data () => VariableWeighting
- Z.Data.Text: newtype SortKey
+ Z.Data.Text: newtype () => SortKey
- Z.Data.Text.Base: data Collator
+ Z.Data.Text.Base: data () => Collator
- Z.Data.Text.Base: data CollatorOptions
+ Z.Data.Text.Base: data () => CollatorOptions
- Z.Data.Text.Base: data Lang
+ Z.Data.Text.Base: data () => Lang
- Z.Data.Text.Base: data VariableWeighting
+ Z.Data.Text.Base: data () => VariableWeighting
- Z.Data.Text.Base: newtype SortKey
+ Z.Data.Text.Base: newtype () => SortKey
- Z.Data.Vector: newtype Down a
+ Z.Data.Vector: newtype () => Down a
- Z.Data.Vector.Sort: newtype Down a
+ Z.Data.Vector.Sort: newtype () => Down a
- Z.Foreign.CPtr: data FunPtr a
+ Z.Foreign.CPtr: data () => FunPtr a
- Z.Foreign.CPtr: data Ptr a
+ Z.Foreign.CPtr: data () => Ptr a
Files
- README.md +15/−17
- Z-Data.cabal +2/−2
- Z/Data/Array/Base.hs +16/−5
- Z/Foreign.hs +7/−1
- Z/Foreign/CPtr.hs +13/−9
README.md view
@@ -20,10 +20,8 @@ ## Requirements -* A working haskell compiler system, GHC(>=8.6), cabal-install(>=2.4), here're some options:- * Mac users can get them via [homebew](//brew.sh/): `brew install ghc cabal-install`.- * Windows users can get them via [chocolatey](//chocolatey.org): `choco install ghc cabal`.- * Ubuntu users are recommended to use this [ppa](//launchpad.net/~hvr/+archive/ubuntu/ghc).+* A working haskell compiler system, GHC(>=9.2), cabal-install(>=3.8), here're some options:+ * Using [ghcup](https://www.haskell.org/ghcup/) to setup your haskell envrionment. * A working C/C++ compiler support C++11, here're some options: * Mac users can use the `clang` comes with the [XCode](https://developer.apple.com/xcode/) or [XCode Command Line Tools](https://developer.apple.com/downloads): * You can install XCode from app store, or XCode Command Line Tools with `sudo xcode-select --install`.@@ -39,44 +37,44 @@ > import qualified Z.Data.Array as A > > -- convert from list-> let v = V.pack [1..10] :: V.PrimVector Int +> let v = V.pack [1..10] :: V.PrimVector Int > -- vector combinators works on arrays as well-> let a = V.pack [1..10] :: A.Array Int +> let a = V.pack [1..10] :: A.Array Int > -- slicing vector(slice) is O(1)-> V.take 3 v +> V.take 3 v [1,2,3] -- slicing array is not O(1)-> V.drop 3 a +> V.drop 3 a fromListN 7 [4,5,6,7,8,9,10] > > V.intersperse 10 v [1,10,2,10,3,10,4,10,5,10,6,10,7,10,8,10,9,10,10] >-> V.mergeSort (V.intersperse 10 v) +> V.mergeSort (V.intersperse 10 v) [1,2,3,4,5,6,7,8,9,10,10,10,10,10,10,10,10,10,10] > -- Generic KMP search on vectors-> V.indices (V.singleton 10) (V.intersperse 10 v) True +> V.indices (V.singleton 10) (V.intersperse 10 v) True [1,3,5,7,9,11,13,15,17,18] > > -- quoter for writing numeric vector literals-> :set -XQuasiQuotes -> :t [V.vecWord|1,2,3,4,5,4,3,2,1|] +> :set -XQuasiQuotes+> :t [V.vecWord|1,2,3,4,5,4,3,2,1|] [V.vecWord|1,2,3,4,5,4,3,2,1|] :: V.PrimVector Word > > import qualified Z.Data.Builder as B > import qualified Z.Data.Text as T-> :set -XOverloadedStrings +> :set -XOverloadedStrings > > -- Builders can be used with OverloadedStrings > B.build $ "builders: " >> B.hex (3 :: Word16) >> B.comma >> B.double 1.2345678 [98,117,105,108,100,101,114,115,58,32,48,48,48,51,44,49,46,50,51,52,53,54,55,56]-> +> > B.buildText $ "builders: " >> B.hex (3 :: Word16) >> B.comma >> B.double 1.2345678 "builders: 0003,1.2345678" > > import qualified Z.Data.JSON as JSON > import GHC.Generics-> +> > JSON.parseValue "[1,2,3,4,5]" ([],Right (Array [Number 1.0,Number 2.0,Number 3.0,Number 4.0,Number 5.0])) >@@ -93,13 +91,13 @@ ```bash # get code-git clone --recursive git@github.com:ZHaskell/z-data.git +git clone --recursive git@github.com:ZHaskell/z-data.git cd z-data # build cabal build # test cabal test --test-show-details=direct-# install +# install cabal install # generate document cabal haddock
Z-Data.cabal view
@@ -1,6 +1,6 @@ cabal-version: 2.4 name: Z-Data-version: 2.0.0.2+version: 2.0.1.0 synopsis: Array, vector and text description: This package provides array, slice and text operations license: BSD-3-Clause@@ -185,7 +185,7 @@ , containers ^>=0.6 , deepseq ^>=1.4 , hashable >=1.3 && < 1.5- , primitive >=0.7.3 && <0.8+ , primitive >=0.7.3 && <1.0 , QuickCheck >=2.10 , random >=1.2.0 && <1.3 , scientific >=0.3.7 && <0.4
Z/Data/Array/Base.hs view
@@ -62,20 +62,27 @@ , sizeOf ) where -import Control.Exception (ArrayException (..), throw)+import Control.Exception (ArrayException (..), throw) import Control.Monad import Control.Monad.Primitive import Control.Monad.ST-import Data.Bits (unsafeShiftL)-import Data.Kind (Type)+import Data.Bits (unsafeShiftL)+import Data.Kind (Type) import Data.Primitive.Array import Data.Primitive.ByteArray+#if !MIN_VERSION_primitive(0, 9, 0) import Data.Primitive.PrimArray-import Data.Primitive.Ptr (copyPtrToMutablePrimArray)+#else+import Data.Primitive.PrimArray hiding+ (withMutablePrimArrayContents,+ withPrimArrayContents)+#endif+import Data.Primitive.Ptr (copyPtrToMutablePrimArray) import Data.Primitive.SmallArray import Data.Primitive.Types import GHC.Exts-import System.Random.Stateful ( UniformRange(uniformRM), StatefulGen )+import System.Random.Stateful (StatefulGen,+ UniformRange (uniformRM)) import Z.Data.Array.Cast import Z.Data.Array.UnliftedArray @@ -589,6 +596,8 @@ -------------------------------------------------------------------------------- +-- FIXME: directly use Data.Primitive.PrimArray.withPrimArrayContents+-- when primitive>=0.9.0 ? -- | Obtain the pointer to the content of an array, and the pointer should only be used during the IO action. -- -- This operation is only safe on /pinned/ primitive arrays (Arrays allocated by 'newPinnedPrimArray' or@@ -604,6 +613,8 @@ primitive_ (touch# ba#) return b +-- FIXME: directly use Data.Primitive.PrimArray.withMutablePrimArrayContents+-- when primitive>=0.9.0 ? -- | Obtain the pointer to the content of an mutable array, and the pointer should only be used during the IO action. -- -- This operation is only safe on /pinned/ primitive arrays (Arrays allocated by 'newPinnedPrimArray' or
Z/Foreign.hs view
@@ -109,9 +109,15 @@ fromShort, toShort) import qualified Data.ByteString.Unsafe as B import qualified Data.List as List-import Data.Primitive import Data.Primitive.ByteArray+import Data.Primitive.Types+#if !MIN_VERSION_primitive(0, 9, 0) import Data.Primitive.PrimArray+#else+import Data.Primitive.PrimArray hiding+ (withMutablePrimArrayContents,+ withPrimArrayContents)+#endif import Data.Primitive.Ptr import Data.Word import Foreign.C.Types
Z/Foreign/CPtr.hs view
@@ -21,15 +21,19 @@ , FunPtr ) where -import Control.Monad-import Control.Monad.Primitive-import Data.Primitive.PrimArray-import qualified Z.Data.Text as T-import GHC.Ptr-import GHC.Exts-import GHC.IO-import Z.Data.Array hiding (newPinnedPrimArray)-import Z.Foreign+import Control.Monad+import Control.Monad.Primitive+#if !MIN_VERSION_primitive(0, 9, 0)+import Data.Primitive.PrimArray+#else+import Data.Primitive.PrimArray hiding (withMutablePrimArrayContents)+#endif+import GHC.Exts+import GHC.IO+import GHC.Ptr+import Z.Data.Array hiding (newPinnedPrimArray)+import qualified Z.Data.Text as T+import Z.Foreign -- | Lightweight foreign pointers. newtype CPtr a = CPtr (PrimArray (Ptr a))