diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,18 +1,8 @@ -# Revision history for stdio - -## 0.1.1.0 -- 2019-02-19 +# Revision history for Z-Data -* Add LEON, a little endian first serialization/deserialization module. -* Use pkg-config to find libuv by default, which can be turned off via cabal flag no-pkg-config -* Export `Result` constructor in `Std.Data.Parser` module. +## 0.1.2.0 -- 2020-09-19 -## 0.2.0.0 --2019-05-15 +* Rename 'read/write/indexWord8ArrayAs' to 'read/write/indexWord8ArrayAs#'. +* Add 'read/write/indexWord8ArrayAs', 'read/write/indexPrimWord8ArrayAs'. +* Fix JSON encoding code in generic instance(constructor with single payload case). -* Add UDP module. -* Add JSON module. -* Add `ToText` class to `TextBuilder` module. -* Improve numeric builders by using FFI code. -* Change `readParser` 's type in `Std.IO.Buffered` module to directly return parsing result. -* Add `FlatMap/FlatSet/FlatIntMap/FlatIntSet` module. -* Fix a bug of `Parser` 's `Alternative` instance. -* Fix a bug of `PrimVector` 's `QuasiQuoter`. diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ -Copyright (c) 2017-2019, Haskell Stdio Team +Copyright (c) 2017-2020, Haskell Z Team All rights reserved. diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -14,7 +14,64 @@ * Parsing and building monad * JSON encoding and decoding -## dev guide +## Example usage + +```haskell +> import qualified Z.Data.Vector as V +> import qualified Z.Data.Array as A +> +> -- convert from list +> 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 +> -- slicing vector(slice) is O(1) +> V.take 3 v +[1,2,3] +-- slicing array is not O(1) +> 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) +[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 +[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|] +[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 +> +> -- Builders can be used with OverloadedStrings +> B.buildBytes $ "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] +> +> T.validate . B.buildBytes $ "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])) +> +> -- JSON module support deriving through Generic +> set -XDeriveAnyClass -XDeriveGeneric +> data Foo = Foo {foo :: Double} deriving (JSON.FromValue, JSON.ToValue, JSON.EncodeJSON, Generic) +> JSON.toValue (Foo 0.01) +Object [("foo",Number 1.0e-2)] +> JSON.encodeText (Foo 0.01) +"{\"foo\":1.0e-2}" +``` + +## Dev guide + GHC(>=8.10.2) + cabal-install(>=3.4) diff --git a/Z-Data.cabal b/Z-Data.cabal --- a/Z-Data.cabal +++ b/Z-Data.cabal @@ -1,6 +1,6 @@ name: Z-Data -version: 0.1.1.0 -synopsis: array, vector and text +version: 0.1.2.0 +synopsis: Array, vector and text description: This package provides array, slice and text operations license: BSD3 license-file: LICENSE diff --git a/Z/Data/Array/UnalignedAccess.hs b/Z/Data/Array/UnalignedAccess.hs --- a/Z/Data/Array/UnalignedAccess.hs +++ b/Z/Data/Array/UnalignedAccess.hs @@ -23,6 +23,9 @@ import GHC.Types import GHC.Word import GHC.Float (stgFloatToWord32, stgWord32ToFloat, stgWord64ToDouble, stgDoubleToWord64) +import Control.Monad.Primitive +import Data.Primitive.ByteArray +import Data.Primitive.PrimArray -- toggle these defs to test different implements #define USE_BSWAP @@ -36,31 +39,61 @@ -- class UnalignedAccess a where unalignedSize :: UnalignedSize a - writeWord8ArrayAs :: MutableByteArray# s -> Int# -> a -> State# s -> State# s - readWord8ArrayAs :: MutableByteArray# s -> Int# -> State# s -> (# State# s, a #) - indexWord8ArrayAs :: ByteArray# -> Int# -> a + writeWord8ArrayAs# :: MutableByteArray# s -> Int# -> a -> State# s -> State# s + readWord8ArrayAs# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, a #) + indexWord8ArrayAs# :: ByteArray# -> Int# -> a +-- | Lifted version of 'writeWord8ArrayAs#' +writeWord8ArrayAs :: (PrimMonad m, UnalignedAccess a) => MutableByteArray (PrimState m) -> Int -> a -> m () +{-# INLINE writeWord8ArrayAs #-} +writeWord8ArrayAs (MutableByteArray mba#) (I# i#) x = primitive_ (writeWord8ArrayAs# mba# i# x) + +-- | Lifted version of 'readWord8ArrayAs#' +readWord8ArrayAs :: (PrimMonad m, UnalignedAccess a) => MutableByteArray (PrimState m) -> Int -> m a +{-# INLINE readWord8ArrayAs #-} +readWord8ArrayAs (MutableByteArray mba#) (I# i#) = primitive (readWord8ArrayAs# mba# i#) + +-- | Lifted version of 'indexWord8ArrayAs#' +indexWord8ArrayAs :: UnalignedAccess a => ByteArray -> Int -> a +{-# INLINE indexWord8ArrayAs #-} +indexWord8ArrayAs (ByteArray ba#) (I# i#) = indexWord8ArrayAs# ba# i# + +-- | Lifted version of 'writeWord8ArrayAs#' +writePrimWord8ArrayAs :: (PrimMonad m, UnalignedAccess a) => MutablePrimArray (PrimState m) Word8 -> Int -> a -> m () +{-# INLINE writePrimWord8ArrayAs #-} +writePrimWord8ArrayAs (MutablePrimArray mba#) (I# i#) x = primitive_ (writeWord8ArrayAs# mba# i# x) + +-- | Lifted version of 'readWord8ArrayAs#' +readPrimWord8ArrayAs :: (PrimMonad m, UnalignedAccess a) => MutablePrimArray (PrimState m) Word8 -> Int -> m a +{-# INLINE readPrimWord8ArrayAs #-} +readPrimWord8ArrayAs (MutablePrimArray mba#) (I# i#) = primitive (readWord8ArrayAs# mba# i#) + +-- | Lifted version of 'indexWord8ArrayAs#' +indexPrimWord8ArrayAs :: UnalignedAccess a => PrimArray Word8 -> Int -> a +{-# INLINE indexPrimWord8ArrayAs #-} +indexPrimWord8ArrayAs (PrimArray ba#) (I# i#) = indexWord8ArrayAs# ba# i# + instance UnalignedAccess Word8 where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 1 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (W8# x#) = writeWord8Array# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (W8# x#) = writeWord8Array# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8Array# mba# i# s0 in (# s1, W8# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = W8# (indexWord8Array# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = W8# (indexWord8Array# ba# i#) instance UnalignedAccess Int8 where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 1 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (I8# x#) = writeInt8Array# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (I8# x#) = writeInt8Array# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readInt8Array# mba# i# s0 in (# s1, I8# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = I8# (indexInt8Array# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = I8# (indexInt8Array# ba# i#) -- | little endianess wrapper -- @@ -71,42 +104,42 @@ newtype BE a = BE { getBE :: a } deriving (Show, Eq) #define USE_HOST_IMPL(END) \ - {-# INLINE writeWord8ArrayAs #-}; \ - writeWord8ArrayAs mba# i# (END x) = writeWord8ArrayAs mba# i# x; \ - {-# INLINE readWord8ArrayAs #-}; \ - readWord8ArrayAs mba# i# s0 = \ - let !(# s1, x #) = readWord8ArrayAs mba# i# s0 in (# s1, END x #); \ - {-# INLINE indexWord8ArrayAs #-}; \ - indexWord8ArrayAs ba# i# = END (indexWord8ArrayAs ba# i#); + {-# INLINE writeWord8ArrayAs# #-}; \ + writeWord8ArrayAs# mba# i# (END x) = writeWord8ArrayAs# mba# i# x; \ + {-# INLINE readWord8ArrayAs# #-}; \ + readWord8ArrayAs# mba# i# s0 = \ + let !(# s1, x #) = readWord8ArrayAs# mba# i# s0 in (# s1, END x #); \ + {-# INLINE indexWord8ArrayAs# #-}; \ + indexWord8ArrayAs# ba# i# = END (indexWord8ArrayAs# ba# i#); -------------------------------------------------------------------------------- instance UnalignedAccess Word16 where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 2 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (W16# x#) = writeWord8ArrayAsWord16# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (W16# x#) = writeWord8ArrayAsWord16# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsWord16# mba# i# s0 in (# s1, W16# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = W16# (indexWord8ArrayAsWord16# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = W16# (indexWord8ArrayAsWord16# ba# i#) instance UnalignedAccess (LE Word16) where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 2 #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (W16# x#)) s0# = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (W16# x#)) s0# = let s1# = writeWord8Array# mba# i# x# s0# in writeWord8Array# mba# (i# +# 1#) (uncheckedShiftRL# x# 8#) s1# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, w1# #) = readWord8Array# mba# i# s0 !(# s2, w2# #) = readWord8Array# mba# (i# +# 1#) s1 in (# s2, LE (W16# (uncheckedShiftL# w2# 8# `or#` w1#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = let w1# = indexWord8Array# ba# i# w2# = indexWord8Array# ba# (i# +# 1#) in LE (W16# (uncheckedShiftL# w2# 8# `or#` w1#)) @@ -123,26 +156,26 @@ -- on X86 we use bswap -- TODO: find out if arch64 support this #if (defined(i386_HOST_ARCH) || defined(x86_64_HOST_ARCH)) && defined(USE_BSWAP) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (W16# x#)) = writeWord8ArrayAsWord16# mba# i# (byteSwap16# x#) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (W16# x#)) = writeWord8ArrayAsWord16# mba# i# (byteSwap16# x#) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsWord16# mba# i# s0 in (# s1, BE (W16# (byteSwap16# x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = BE (W16# (byteSwap16# (indexWord8ArrayAsWord16# ba# i#))) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = BE (W16# (byteSwap16# (indexWord8ArrayAsWord16# ba# i#))) #else - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (W16# x#)) s0# = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (W16# x#)) s0# = let s1# = writeWord8Array# mba# i# (uncheckedShiftRL# x# 8#) s0# in writeWord8Array# mba# (i# +# 1#) x# s1# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, w2# #) = readWord8Array# mba# i# s0 !(# s2, w1# #) = readWord8Array# mba# (i# +# 1#) s1 in (# s2, BE (W16# (uncheckedShiftL# w2# 8# `or#` w1#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = let w2# = indexWord8Array# ba# i# w1# = indexWord8Array# ba# (i# +# 1#) in BE (W16# (uncheckedShiftL# w2# 8# `or#` w1#)) @@ -154,27 +187,27 @@ instance UnalignedAccess Word32 where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (W32# x#) = writeWord8ArrayAsWord32# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (W32# x#) = writeWord8ArrayAsWord32# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsWord32# mba# i# s0 in (# s1, W32# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = W32# (indexWord8ArrayAsWord32# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = W32# (indexWord8ArrayAsWord32# ba# i#) instance UnalignedAccess (LE Word32) where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (W32# x#)) s0# = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (W32# x#)) s0# = let s1# = writeWord8Array# mba# i# x# s0# s2# = writeWord8Array# mba# (i# +# 1#) (uncheckedShiftRL# x# 8#) s1# s3# = writeWord8Array# mba# (i# +# 2#) (uncheckedShiftRL# x# 16#) s2# in writeWord8Array# mba# (i# +# 3#) (uncheckedShiftRL# x# 24#) s3# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, w1# #) = readWord8Array# mba# i# s0 !(# s2, w2# #) = readWord8Array# mba# (i# +# 1#) s1 !(# s3, w3# #) = readWord8Array# mba# (i# +# 2#) s2 @@ -182,8 +215,8 @@ in (# s4, LE (W32# ((uncheckedShiftL# w4# 24#) `or#` (uncheckedShiftL# w3# 16#) `or#` (uncheckedShiftL# w2# 8#) `or#` w1#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = let w1# = indexWord8Array# ba# i# w2# = indexWord8Array# ba# (i# +# 1#) w3# = indexWord8Array# ba# (i# +# 2#) @@ -204,23 +237,23 @@ -- on X86 we use bswap -- TODO: find out if arch64 support this #if (defined(i386_HOST_ARCH) || defined(x86_64_HOST_ARCH)) && defined(USE_BSWAP) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (W32# x#)) = writeWord8ArrayAsWord32# mba# i# (byteSwap32# x#) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (W32# x#)) = writeWord8ArrayAsWord32# mba# i# (byteSwap32# x#) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsWord32# mba# i# s0 in (# s1, BE (W32# (byteSwap32# x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = BE (W32# (byteSwap32# (indexWord8ArrayAsWord32# ba# i#))) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = BE (W32# (byteSwap32# (indexWord8ArrayAsWord32# ba# i#))) #else - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (W32# x#)) s0# = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (W32# x#)) s0# = let s1# = writeWord8Array# mba# i# (uncheckedShiftRL# x# 24#) s0# s2# = writeWord8Array# mba# (i# +# 1#) (uncheckedShiftRL# x# 16#) s1# s3# = writeWord8Array# mba# (i# +# 2#) (uncheckedShiftRL# x# 8#) s2# in writeWord8Array# mba# (i# +# 3#) x# s3# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, w4# #) = readWord8Array# mba# i# s0 !(# s2, w3# #) = readWord8Array# mba# (i# +# 1#) s1 !(# s3, w2# #) = readWord8Array# mba# (i# +# 2#) s2 @@ -228,8 +261,8 @@ in (# s4, BE (W32# ((uncheckedShiftL# w4# 24#) `or#` (uncheckedShiftL# w3# 16#) `or#` (uncheckedShiftL# w2# 8#) `or#` w1#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = let w4# = indexWord8Array# ba# i# w3# = indexWord8Array# ba# (i# +# 1#) w2# = indexWord8Array# ba# (i# +# 2#) @@ -245,21 +278,21 @@ instance UnalignedAccess Word64 where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (W64# x#) = writeWord8ArrayAsWord64# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (W64# x#) = writeWord8ArrayAsWord64# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsWord64# mba# i# s0 in (# s1, W64# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = W64# (indexWord8ArrayAsWord64# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = W64# (indexWord8ArrayAsWord64# ba# i#) instance UnalignedAccess (LE Word64) where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (W64# x#)) s0# = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (W64# x#)) s0# = let s1# = writeWord8Array# mba# i# x# s0# s2# = writeWord8Array# mba# (i# +# 1#) (uncheckedShiftRL# x# 8#) s1# s3# = writeWord8Array# mba# (i# +# 2#) (uncheckedShiftRL# x# 16#) s2# @@ -268,8 +301,8 @@ s6# = writeWord8Array# mba# (i# +# 5#) (uncheckedShiftRL# x# 40#) s5# s7# = writeWord8Array# mba# (i# +# 6#) (uncheckedShiftRL# x# 48#) s6# in writeWord8Array# mba# (i# +# 7#) (uncheckedShiftRL# x# 56#) s7# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, w1# #) = readWord8Array# mba# i# s0 !(# s2, w2# #) = readWord8Array# mba# (i# +# 1#) s1 !(# s3, w3# #) = readWord8Array# mba# (i# +# 2#) s2 @@ -285,8 +318,8 @@ (uncheckedShiftL# w4# 24#) `or#` (uncheckedShiftL# w3# 16#) `or#` (uncheckedShiftL# w2# 8#) `or#` w1#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = let w1# = indexWord8Array# ba# i# w2# = indexWord8Array# ba# (i# +# 1#) w3# = indexWord8Array# ba# (i# +# 2#) @@ -315,17 +348,17 @@ -- on X86 we use bswap -- TODO: find out if arch64 support this #if (defined(i386_HOST_ARCH) || defined(x86_64_HOST_ARCH)) && defined(USE_BSWAP) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (W64# x#)) = writeWord8ArrayAsWord64# mba# i# (byteSwap64# x#) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (W64# x#)) = writeWord8ArrayAsWord64# mba# i# (byteSwap64# x#) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsWord64# mba# i# s0 in (# s1, BE (W64# (byteSwap64# x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = BE (W64# (byteSwap64# (indexWord8ArrayAsWord64# ba# i#))) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = BE (W64# (byteSwap64# (indexWord8ArrayAsWord64# ba# i#))) #else - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (W64# x#)) s0# = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (W64# x#)) s0# = let s1# = writeWord8Array# mba# i# (uncheckedShiftRL# x# 56#) s0# s2# = writeWord8Array# mba# (i# +# 1#) (uncheckedShiftRL# x# 48#) s1# s3# = writeWord8Array# mba# (i# +# 2#) (uncheckedShiftRL# x# 40#) s2# @@ -334,8 +367,8 @@ s6# = writeWord8Array# mba# (i# +# 5#) (uncheckedShiftRL# x# 16#) s5# s7# = writeWord8Array# mba# (i# +# 6#) (uncheckedShiftRL# x# 8#) s6# in writeWord8Array# mba# (i# +# 7#) x# s7# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, w8# #) = readWord8Array# mba# i# s0 !(# s2, w7# #) = readWord8Array# mba# (i# +# 1#) s1 !(# s3, w6# #) = readWord8Array# mba# (i# +# 2#) s2 @@ -351,8 +384,8 @@ (uncheckedShiftL# w4# 24#) `or#` (uncheckedShiftL# w3# 16#) `or#` (uncheckedShiftL# w2# 8#) `or#` w1#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = let w8# = indexWord8Array# ba# i# w7# = indexWord8Array# ba# (i# +# 1#) w6# = indexWord8Array# ba# (i# +# 2#) @@ -381,58 +414,58 @@ {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 #endif - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (W# x#) = writeWord8ArrayAsWord# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (W# x#) = writeWord8ArrayAsWord# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsWord# mba# i# s0 in (# s1, W# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = W# (indexWord8ArrayAsWord# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = W# (indexWord8ArrayAsWord# ba# i#) instance UnalignedAccess (LE Word) where #if SIZEOF_HSWORD == 4 {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (W# x#)) = writeWord8ArrayAs mba# i# (LE (W32# x#)) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, LE (W32# x#) #) = readWord8ArrayAs mba# i# s0 in (# s1, LE (W# x#) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = case (indexWord8ArrayAs ba# i#) of (LE (W32# x#)) -> LE (W# x#) + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (W# x#)) = writeWord8ArrayAs# mba# i# (LE (W32# x#)) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, LE (W32# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, LE (W# x#) #) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = case (indexWord8ArrayAs# ba# i#) of (LE (W32# x#)) -> LE (W# x#) #else {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (W# x#)) = writeWord8ArrayAs mba# i# (LE (W64# x#)) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, LE (W64# x#) #) = readWord8ArrayAs mba# i# s0 in (# s1, LE (W# x#) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = case (indexWord8ArrayAs ba# i#) of (LE (W64# x#)) -> LE (W# x#) + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (W# x#)) = writeWord8ArrayAs# mba# i# (LE (W64# x#)) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, LE (W64# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, LE (W# x#) #) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = case (indexWord8ArrayAs# ba# i#) of (LE (W64# x#)) -> LE (W# x#) #endif instance UnalignedAccess (BE Word) where #if SIZEOF_HSWORD == 4 {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (W# x#)) = writeWord8ArrayAs mba# i# (BE (W32# x#)) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, BE (W32# x#) #) = readWord8ArrayAs mba# i# s0 in (# s1, BE (W# x#) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = case (indexWord8ArrayAs ba# i#) of (BE (W32# x#)) -> BE (W# x#) + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (W# x#)) = writeWord8ArrayAs# mba# i# (BE (W32# x#)) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, BE (W32# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, BE (W# x#) #) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = case (indexWord8ArrayAs# ba# i#) of (BE (W32# x#)) -> BE (W# x#) #else {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (W# x#)) = writeWord8ArrayAs mba# i# (BE (W64# x#)) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, BE (W64# x#) #) = readWord8ArrayAs mba# i# s0 in (# s1, BE (W# x#) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = case (indexWord8ArrayAs ba# i#) of (BE (W64# x#)) -> BE (W# x#) + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (W# x#)) = writeWord8ArrayAs# mba# i# (BE (W64# x#)) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, BE (W64# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, BE (W# x#) #) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = case (indexWord8ArrayAs# ba# i#) of (BE (W64# x#)) -> BE (W# x#) #endif -------------------------------------------------------------------------------- @@ -440,28 +473,28 @@ instance UnalignedAccess Int16 where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 2 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (I16# x#) = writeWord8ArrayAsInt16# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (I16# x#) = writeWord8ArrayAsInt16# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsInt16# mba# i# s0 in (# s1, I16# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = I16# (indexWord8ArrayAsInt16# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = I16# (indexWord8ArrayAsInt16# ba# i#) instance UnalignedAccess (LE Int16) where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 2 #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (I16# x#)) = - writeWord8ArrayAs mba# i# (LE (W16# (int2Word# x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, LE (W16# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (I16# x#)) = + writeWord8ArrayAs# mba# i# (LE (W16# (int2Word# x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, LE (W16# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, LE (I16# (narrow16Int# (word2Int# x#))) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let LE (W16# x#) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let LE (W16# x#) = indexWord8ArrayAs# ba# i# in LE (I16# (narrow16Int# (word2Int# x#))) #else USE_HOST_IMPL(LE) @@ -473,16 +506,16 @@ #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) USE_HOST_IMPL(BE) #else - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (I16# x#)) = - writeWord8ArrayAs mba# i# (BE (W16# (int2Word# x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, BE (W16# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (I16# x#)) = + writeWord8ArrayAs# mba# i# (BE (W16# (int2Word# x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, BE (W16# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, BE (I16# (narrow16Int# (word2Int# x#))) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let !(BE (W16# x#)) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let !(BE (W16# x#)) = indexWord8ArrayAs# ba# i# in BE (I16# (narrow16Int# (word2Int# x#))) #endif @@ -491,28 +524,28 @@ instance UnalignedAccess Int32 where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (I32# x#) = writeWord8ArrayAsInt32# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (I32# x#) = writeWord8ArrayAsInt32# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsInt32# mba# i# s0 in (# s1, I32# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = I32# (indexWord8ArrayAsInt32# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = I32# (indexWord8ArrayAsInt32# ba# i#) instance UnalignedAccess (LE Int32) where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (I32# x#)) = - writeWord8ArrayAs mba# i# (LE (W32# (int2Word# x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, LE (W32# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (I32# x#)) = + writeWord8ArrayAs# mba# i# (LE (W32# (int2Word# x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, LE (W32# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, LE (I32# (narrow32Int# (word2Int# x#))) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let LE (W32# x#) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let LE (W32# x#) = indexWord8ArrayAs# ba# i# in LE (I32# (narrow32Int# (word2Int# x#))) #else USE_HOST_IMPL(LE) @@ -524,16 +557,16 @@ #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) USE_HOST_IMPL(BE) #else - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (I32# x#)) = - writeWord8ArrayAs mba# i# (BE (W32# (int2Word# x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, BE (W32# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (I32# x#)) = + writeWord8ArrayAs# mba# i# (BE (W32# (int2Word# x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, BE (W32# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, BE (I32# (narrow32Int# (word2Int# x#))) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let !(BE (W32# x#)) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let !(BE (W32# x#)) = indexWord8ArrayAs# ba# i# in BE (I32# (narrow32Int# (word2Int# x#))) #endif @@ -542,28 +575,28 @@ instance UnalignedAccess Int64 where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (I64# x#) = writeWord8ArrayAsInt64# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (I64# x#) = writeWord8ArrayAsInt64# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsInt64# mba# i# s0 in (# s1, I64# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = I64# (indexWord8ArrayAsInt64# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = I64# (indexWord8ArrayAsInt64# ba# i#) instance UnalignedAccess (LE Int64) where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (I64# x#)) = - writeWord8ArrayAs mba# i# (LE (W64# (int2Word# x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, LE (W64# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (I64# x#)) = + writeWord8ArrayAs# mba# i# (LE (W64# (int2Word# x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, LE (W64# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, LE (I64# (word2Int# x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let LE (W64# x#) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let LE (W64# x#) = indexWord8ArrayAs# ba# i# in LE (I64# (word2Int# x#)) #else USE_HOST_IMPL(LE) @@ -575,16 +608,16 @@ #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) USE_HOST_IMPL(BE) #else - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (I64# x#)) = - writeWord8ArrayAs mba# i# (BE (W64# (int2Word# x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, BE (W64# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (I64# x#)) = + writeWord8ArrayAs# mba# i# (BE (W64# (int2Word# x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, BE (W64# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, BE (I64# (word2Int# x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let !(BE (W64# x#)) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let !(BE (W64# x#)) = indexWord8ArrayAs# ba# i# in BE (I64# (word2Int# x#)) #endif @@ -598,58 +631,58 @@ {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 #endif - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (I# x#) = writeWord8ArrayAsInt# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (I# x#) = writeWord8ArrayAsInt# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsInt# mba# i# s0 in (# s1, I# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = I# (indexWord8ArrayAsInt# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = I# (indexWord8ArrayAsInt# ba# i#) instance UnalignedAccess (LE Int) where #if SIZEOF_HSWORD == 4 {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (I# x#)) = writeWord8ArrayAs mba# i# (LE (I32# x#)) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, LE (I32# x#) #) = readWord8ArrayAs mba# i# s0 in (# s1, LE (I# x#) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = case (indexWord8ArrayAs ba# i#) of (LE (I32# x#)) -> LE (I# x#) + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (I# x#)) = writeWord8ArrayAs# mba# i# (LE (I32# x#)) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, LE (I32# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, LE (I# x#) #) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = case (indexWord8ArrayAs# ba# i#) of (LE (I32# x#)) -> LE (I# x#) #else {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (I# x#)) = writeWord8ArrayAs mba# i# (LE (I64# x#)) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, LE (I64# x#) #) = readWord8ArrayAs mba# i# s0 in (# s1, LE (I# x#) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = case (indexWord8ArrayAs ba# i#) of (LE (I64# x#)) -> LE (I# x#) + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (I# x#)) = writeWord8ArrayAs# mba# i# (LE (I64# x#)) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, LE (I64# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, LE (I# x#) #) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = case (indexWord8ArrayAs# ba# i#) of (LE (I64# x#)) -> LE (I# x#) #endif instance UnalignedAccess (BE Int) where #if SIZEOF_HSWORD == 4 {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (I# x#)) = writeWord8ArrayAs mba# i# (BE (I32# x#)) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, BE (I32# x#) #) = readWord8ArrayAs mba# i# s0 in (# s1, BE (I# x#) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = case (indexWord8ArrayAs ba# i#) of (BE (I32# x#)) -> BE (I# x#) + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (I# x#)) = writeWord8ArrayAs# mba# i# (BE (I32# x#)) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, BE (I32# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, BE (I# x#) #) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = case (indexWord8ArrayAs# ba# i#) of (BE (I32# x#)) -> BE (I# x#) #else {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (I# x#)) = writeWord8ArrayAs mba# i# (BE (I64# x#)) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, BE (I64# x#) #) = readWord8ArrayAs mba# i# s0 in (# s1, BE (I# x#) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = case (indexWord8ArrayAs ba# i#) of (BE (I64# x#)) -> BE (I# x#) + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (I# x#)) = writeWord8ArrayAs# mba# i# (BE (I64# x#)) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, BE (I64# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, BE (I# x#) #) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = case (indexWord8ArrayAs# ba# i#) of (BE (I64# x#)) -> BE (I# x#) #endif -------------------------------------------------------------------------------- @@ -657,28 +690,28 @@ instance UnalignedAccess Float where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (F# x#) = writeWord8ArrayAsFloat# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (F# x#) = writeWord8ArrayAsFloat# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsFloat# mba# i# s0 in (# s1, F# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = F# (indexWord8ArrayAsFloat# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = F# (indexWord8ArrayAsFloat# ba# i#) instance UnalignedAccess (LE Float) where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (F# x#)) = - writeWord8ArrayAs mba# i# (LE (W32# (stgFloatToWord32 x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, LE (W32# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (F# x#)) = + writeWord8ArrayAs# mba# i# (LE (W32# (stgFloatToWord32 x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, LE (W32# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, LE (F# (stgWord32ToFloat x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let LE (W32# x#) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let LE (W32# x#) = indexWord8ArrayAs# ba# i# in LE (F# (stgWord32ToFloat x#)) #else USE_HOST_IMPL(LE) @@ -690,16 +723,16 @@ #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) USE_HOST_IMPL(BE) #else - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (F# x#)) = - writeWord8ArrayAs mba# i# (BE (W32# (stgFloatToWord32 x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, BE (W32# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (F# x#)) = + writeWord8ArrayAs# mba# i# (BE (W32# (stgFloatToWord32 x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, BE (W32# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, BE (F# (stgWord32ToFloat x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let !(BE (W32# x#)) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let !(BE (W32# x#)) = indexWord8ArrayAs# ba# i# in BE (F# (stgWord32ToFloat x#)) #endif @@ -708,28 +741,28 @@ instance UnalignedAccess Double where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (D# x#) = writeWord8ArrayAsDouble# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (D# x#) = writeWord8ArrayAsDouble# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsDouble# mba# i# s0 in (# s1, D# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = D# (indexWord8ArrayAsDouble# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = D# (indexWord8ArrayAsDouble# ba# i#) instance UnalignedAccess (LE Double) where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 8 #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (D# x#)) = - writeWord8ArrayAs mba# i# (LE (W64# (stgDoubleToWord64 x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, LE (W64# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (D# x#)) = + writeWord8ArrayAs# mba# i# (LE (W64# (stgDoubleToWord64 x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, LE (W64# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, LE (D# (stgWord64ToDouble x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let LE (W64# x#) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let LE (W64# x#) = indexWord8ArrayAs# ba# i# in LE (D# (stgWord64ToDouble x#)) #else USE_HOST_IMPL(LE) @@ -741,16 +774,16 @@ #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) USE_HOST_IMPL(BE) #else - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (D# x#)) = - writeWord8ArrayAs mba# i# (BE (W64# (stgDoubleToWord64 x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, BE (W64# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (D# x#)) = + writeWord8ArrayAs# mba# i# (BE (W64# (stgDoubleToWord64 x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, BE (W64# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, BE (D# (stgWord64ToDouble x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let !(BE (W64# x#)) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let !(BE (W64# x#)) = indexWord8ArrayAs# ba# i# in BE (D# (stgWord64ToDouble x#)) #endif @@ -759,28 +792,28 @@ instance UnalignedAccess Char where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (C# x#) = writeWord8ArrayAsWideChar# mba# i# x# - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (C# x#) = writeWord8ArrayAsWideChar# mba# i# x# + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = let !(# s1, x# #) = readWord8ArrayAsWideChar# mba# i# s0 in (# s1, C# x# #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = C# (indexWord8ArrayAsWideChar# ba# i#) + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = C# (indexWord8ArrayAsWideChar# ba# i#) instance UnalignedAccess (LE Char) where {-# INLINE unalignedSize #-} unalignedSize = UnalignedSize 4 #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (LE (C# x#)) = - writeWord8ArrayAs mba# i# (LE (I32# (ord# x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, LE (I32# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (LE (C# x#)) = + writeWord8ArrayAs# mba# i# (LE (I32# (ord# x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, LE (I32# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, LE (C# (chr# x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let LE (I32# x#) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let LE (I32# x#) = indexWord8ArrayAs# ba# i# in LE (C# (chr# x#)) #else USE_HOST_IMPL(LE) @@ -792,16 +825,16 @@ #if defined(WORDS_BIGENDIAN) || defined(USE_SHIFT) USE_HOST_IMPL(BE) #else - {-# INLINE writeWord8ArrayAs #-} - writeWord8ArrayAs mba# i# (BE (C# x#)) = - writeWord8ArrayAs mba# i# (BE (I32# (ord# x#))) - {-# INLINE readWord8ArrayAs #-} - readWord8ArrayAs mba# i# s0 = - let !(# s1, BE (I32# x#) #) = readWord8ArrayAs mba# i# s0 + {-# INLINE writeWord8ArrayAs# #-} + writeWord8ArrayAs# mba# i# (BE (C# x#)) = + writeWord8ArrayAs# mba# i# (BE (I32# (ord# x#))) + {-# INLINE readWord8ArrayAs# #-} + readWord8ArrayAs# mba# i# s0 = + let !(# s1, BE (I32# x#) #) = readWord8ArrayAs# mba# i# s0 in (# s1, BE (C# (chr# x#)) #) - {-# INLINE indexWord8ArrayAs #-} - indexWord8ArrayAs ba# i# = - let !(BE (I32# x#)) = indexWord8ArrayAs ba# i# + {-# INLINE indexWord8ArrayAs# #-} + indexWord8ArrayAs# ba# i# = + let !(BE (I32# x#)) = indexWord8ArrayAs# ba# i# in BE (C# (chr# x#)) #endif diff --git a/Z/Data/Builder/Base.hs b/Z/Data/Builder/Base.hs --- a/Z/Data/Builder/Base.hs +++ b/Z/Data/Builder/Base.hs @@ -76,7 +76,6 @@ import Control.Monad.ST import Control.Monad.ST.Unsafe (unsafeInterleaveST) import Data.Bits (shiftL, shiftR, (.&.)) -import Data.Primitive.PrimArray (MutablePrimArray (..)) import Data.Primitive.Ptr (copyPtrToMutablePrimArray) import Data.String (IsString (..)) import Data.Word @@ -84,7 +83,6 @@ import GHC.CString (unpackCString#, unpackCStringUtf8#) import GHC.Prim import GHC.Ptr -import GHC.Types import qualified Z.Data.Array as A import Z.Data.Array.UnalignedAccess import qualified Z.Data.Text.Base as T @@ -396,9 +394,9 @@ {-# SPECIALIZE INLINE encodePrim :: Int8 -> Builder () #-} encodePrim x = do ensureN n - Builder (\ _ k (Buffer (MutablePrimArray mba#) i@(I# i#)) -> do - primitive_ (writeWord8ArrayAs mba# i# x) - k () (Buffer (MutablePrimArray mba#) (i + n))) + Builder (\ _ k (Buffer mpa i) -> do + writePrimWord8ArrayAs mpa i x + k () (Buffer mpa (i + n))) where n = (getUnalignedSize (unalignedSize :: UnalignedSize a)) @@ -498,10 +496,10 @@ {-# INLINE char7 #-} char7 chr = do ensureN 1 - Builder (\ _ k (Buffer mba@(MutablePrimArray mba#) i@(I# i#)) -> do + Builder (\ _ k (Buffer mpa i) -> do let x = V.c2w chr .&. 0x7F - primitive_ (writeWord8ArrayAs mba# i# x) - k () (Buffer mba (i+1))) + writePrimWord8ArrayAs mpa i x + k () (Buffer mpa (i+1))) -- | Turn 'String' into 'Builder' with ASCII8 encoding -- @@ -521,10 +519,10 @@ {-# INLINE char8 #-} char8 chr = do ensureN 1 - Builder (\ _ k (Buffer mba@(MutablePrimArray mba#) i@(I# i#)) -> do + Builder (\ _ k (Buffer mpa i) -> do let x = V.c2w chr - primitive_ (writeWord8ArrayAs mba# i# x) - k () (Buffer mba (i+1))) + writePrimWord8ArrayAs mpa i x + k () (Buffer mpa (i+1))) -- | Write UTF8 encoded 'Text' using 'Builder'. -- diff --git a/Z/Data/CBytes.hs b/Z/Data/CBytes.hs --- a/Z/Data/CBytes.hs +++ b/Z/Data/CBytes.hs @@ -52,6 +52,8 @@ , V.w2c, V.c2w -- * exception , NullPointerException(..) + -- re-export + , CString ) where import Control.DeepSeq diff --git a/Z/Data/JSON/Base.hs b/Z/Data/JSON/Base.hs --- a/Z/Data/JSON/Base.hs +++ b/Z/Data/JSON/Base.hs @@ -701,11 +701,19 @@ B.text . constrFmt s $ conName (undefined :: t c U1 a) -- | Constructor with a single payload -instance (Constructor c, GEncodeJSON (S1 sc f)) => GConstrEncodeJSON (C1 c (S1 sc f)) where +instance (Constructor c, GEncodeJSON (S1 (MetaSel Nothing u ss ds) f)) + => GConstrEncodeJSON (C1 c (S1 (MetaSel Nothing u ss ds) f)) where {-# INLINE gConstrEncodeJSON #-} gConstrEncodeJSON False s (M1 x) = gEncodeJSON s x gConstrEncodeJSON True s (M1 x) = B.curly $ do (constrFmt s $ conName @c undefined) `JB.kv` gEncodeJSON s x + +instance (Constructor c, GEncodeJSON (S1 (MetaSel (Just l) u ss ds) f)) + => GConstrEncodeJSON (C1 c (S1 (MetaSel (Just l) u ss ds) f)) where + {-# INLINE gConstrEncodeJSON #-} + gConstrEncodeJSON False s (M1 x) = B.curly (gEncodeJSON s x) + gConstrEncodeJSON True s (M1 x) = B.curly $ do + (constrFmt s $ conName @c undefined) `JB.kv` B.curly (gEncodeJSON s x) -- | Constructor with multiple payloads instance (GEncodeJSON (a :*: b), GAddPunctuation (a :*: b), Constructor c) diff --git a/Z/Data/Parser/Base.hs b/Z/Data/Parser/Base.hs --- a/Z/Data/Parser/Base.hs +++ b/Z/Data/Parser/Base.hs @@ -3,7 +3,6 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleContexts #-} -{-# LANGUAGE MagicHash #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} @@ -303,9 +302,9 @@ {-# SPECIALIZE INLINE decodePrim :: Parser Int8 #-} decodePrim = do ensureN n ["Z.Data.Parser.Base.decodePrim: not enough bytes"] - Parser (\ _ k (V.PrimVector (A.PrimArray ba#) i@(I# i#) len) -> - let !r = indexWord8ArrayAs ba# i# - in k r (V.PrimVector (A.PrimArray ba#) (i+n) (len-n))) + Parser (\ _ k (V.PrimVector ba i len) -> + let !r = indexPrimWord8ArrayAs ba i + in k r (V.PrimVector ba (i+n) (len-n))) where n = getUnalignedSize (unalignedSize :: UnalignedSize a) @@ -321,9 +320,9 @@ {-# SPECIALIZE INLINE decodePrimLE :: Parser Int16 #-} decodePrimLE = do ensureN n ["Z.Data.Parser.Base.decodePrimLE: not enough bytes"] - Parser (\ _ k (V.PrimVector (A.PrimArray ba#) i@(I# i#) len) -> - let !r = indexWord8ArrayAs ba# i# - in k (getLE r) (V.PrimVector (A.PrimArray ba#) (i+n) (len-n))) + Parser (\ _ k (V.PrimVector ba i len) -> + let !r = indexPrimWord8ArrayAs ba i + in k (getLE r) (V.PrimVector ba (i+n) (len-n))) where n = getUnalignedSize (unalignedSize :: UnalignedSize (LE a)) @@ -339,9 +338,9 @@ {-# SPECIALIZE INLINE decodePrimBE :: Parser Int16 #-} decodePrimBE = do ensureN n ["Z.Data.Parser.Base.decodePrimBE: not enough bytes"] - Parser (\ _ k (V.PrimVector (A.PrimArray ba#) i@(I# i#) len) -> - let !r = indexWord8ArrayAs ba# i# - in k (getBE r) (V.PrimVector (A.PrimArray ba#) (i+n) (len-n))) + Parser (\ _ k (V.PrimVector ba i len) -> + let !r = indexPrimWord8ArrayAs ba i + in k (getBE r) (V.PrimVector ba (i+n) (len-n))) where n = getUnalignedSize (unalignedSize :: UnalignedSize (BE a)) diff --git a/Z/Data/Text/Builder.hs b/Z/Data/Text/Builder.hs --- a/Z/Data/Text/Builder.hs +++ b/Z/Data/Text/Builder.hs @@ -330,10 +330,17 @@ -------------------------------------------------------------------------------- -- | Newtype wrapper for @[Char]@ to provide textual instances. -- --- To encourage using 'Text' as the textual representation, we didn't provide special --- treatment to differentiate instances between @[a]@ and @[Char]@ in various places. +-- We didn't provide special treatment to differentiate instances between @[a]@ and @[Char]@ +-- in various classes, e.g. 'Z.Data.JSON.ToJSON'. +-- -- This newtype is therefore to provide instances similar to @T.Text@, in case you really -- need to wrap a 'String'. +-- +-- >>> Z.Data.JSON.encodeText ("abc" :: String) +-- > "[\"a\",\"b\",\"c\"]" -- Just like any other [a]'s instance +-- >>> Z.Data.JSON.encodeText . Str $ ("abc" :: String) +-- > "\"abc\"" +-- newtype Str = Str { chrs :: [Char] } deriving stock (Eq, Ord, Data, Typeable, Generic) instance Show Str where show = show . chrs diff --git a/Z/Data/Vector/Base.hs b/Z/Data/Vector/Base.hs --- a/Z/Data/Vector/Base.hs +++ b/Z/Data/Vector/Base.hs @@ -153,28 +153,33 @@ {-# INLINE toArr #-} toArr arr = (arr, 0, sizeofArr arr) {-# INLINE fromArr #-} - fromArr = cloneArr + fromArr = fromArray instance Vec SmallArray a where type IArray SmallArray = SmallArray {-# INLINE toArr #-} toArr arr = (arr, 0, sizeofArr arr) {-# INLINE fromArr #-} - fromArr = cloneArr + fromArr = fromArray instance Prim a => Vec PrimArray a where type IArray PrimArray = PrimArray {-# INLINE toArr #-} toArr arr = (arr, 0, sizeofArr arr) {-# INLINE fromArr #-} - fromArr = cloneArr + fromArr = fromArray instance PrimUnlifted a => Vec UnliftedArray a where type IArray UnliftedArray = UnliftedArray {-# INLINE toArr #-} toArr arr = (arr, 0, sizeofArr arr) {-# INLINE fromArr #-} - fromArr = cloneArr + fromArr = fromArray + +fromArray :: Arr arr a => arr a -> Int -> Int -> arr a +{-# INLINE fromArray #-} +fromArray arr offset len | offset == 0 && sizeofArr arr == len = arr + | otherwise = cloneArr arr offset len -- | A pattern synonyms for matching the underline array, offset and length. -- diff --git a/test/Z/Data/Array/UnalignedAccessSpec.hs b/test/Z/Data/Array/UnalignedAccessSpec.hs --- a/test/Z/Data/Array/UnalignedAccessSpec.hs +++ b/test/Z/Data/Array/UnalignedAccessSpec.hs @@ -21,274 +21,274 @@ spec = describe "unaligned acess" . modifyMaxSuccess (*10) . modifyMaxSize (*10) $ do prop "roundtrip Word8" $ \ (w::Word8) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip Word16" $ \ (w::Word16) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip Word32" $ \ (w::Word32) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip Word64" $ \ (w::Word64) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip Word" $ \ (w::Word) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Word16" $ \ (w::Word16) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Word32" $ \ (w::Word32) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Word64" $ \ (w::Word64) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Word" $ \ (w::Word) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Word16" $ \ (w::Word16) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Word32" $ \ (w::Word32) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Word64" $ \ (w::Word64) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Word" $ \ (w::Word) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') -------------------------------------------------------------------------------- prop "roundtrip Int16" $ \ (w::Int16) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Int16" $ \ (w::Int16) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Int16" $ \ (w::Int16) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip Int32" $ \ (w::Int32) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Int32" $ \ (w::Int32) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Int32" $ \ (w::Int32) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip Int64" $ \ (w::Int64) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Int64" $ \ (w::Int64) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Int64" $ \ (w::Int64) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip Int" $ \ (w::Int) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Int" $ \ (w::Int) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Int" $ \ (w::Int) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip Float" $ \ (w::Float) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Float" $ \ (w::Float) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Float" $ \ (w::Float) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip Double" $ \ (w::Double) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Double" $ \ (w::Double) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Double" $ \ (w::Double) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip Char" $ \ (w::Char) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# w) - w' <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# w) + w' <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let w'' = indexWord8ArrayAs ba# 7# + let w'' = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip LE Char" $ \ (w::Char) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (LE w)) - (LE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (LE w)) + (LE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (LE w'') = indexWord8ArrayAs ba# 7# + let (LE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') prop "roundtrip BE Char" $ \ (w::Char) -> ioProperty $ do mba@(MutableByteArray mba#) <- newByteArray 128 - primitive_ (writeWord8ArrayAs mba# 7# (BE w)) - (BE w') <- primitive (readWord8ArrayAs mba# 7#) + primitive_ (writeWord8ArrayAs# mba# 7# (BE w)) + (BE w') <- primitive (readWord8ArrayAs# mba# 7#) (ByteArray ba#) <- unsafeFreezeByteArray mba - let (BE w'') = indexWord8ArrayAs ba# 7# + let (BE w'') = indexWord8ArrayAs# ba# 7# return $ (w === w') .&&. (w === w'') diff --git a/test/Z/Data/JSON/BaseSpec.hs b/test/Z/Data/JSON/BaseSpec.hs --- a/test/Z/Data/JSON/BaseSpec.hs +++ b/test/Z/Data/JSON/BaseSpec.hs @@ -29,6 +29,8 @@ , testTwo :: Maybe Bool , testThree :: Maybe a } + + | RecordII { testFour :: Double } | List [a] deriving (Show, Eq, Generic, FromValue, ToValue, EncodeJSON) @@ -51,6 +53,10 @@ \\"testOne\":0.123456,\ \\"testTwo\":null,\ \\"testThree\":123456}}" + + it "Record are encoded as key values(single field)" $ + JSON.encodeText (RecordII 0.123456 :: T Integer) === + "{\"RecordII\":{\"testFour\":0.123456}}" it "List are encode as array" $ JSON.encodeText (List [Nullary