hw-prim 0.4.0.7 → 0.5.0.0

raw patch · 25 files changed

+196/−612 lines, 25 filesdep −criteriondep −directorydep −exceptionsPVP ok

version bump matches the API change (PVP)

Dependencies removed: criterion, directory, exceptions, hedgehog, hw-hspec-hedgehog, mmap

API changes (from Hackage documentation)

Files

• bench/Main.hs +0/−53
• hw-prim.cabal +59/−106
• src/HaskellWorks/Data/AtIndex.hs +15/−11
• src/HaskellWorks/Data/Char.hs +0/−5
• src/HaskellWorks/Data/Concat.hs +8/−7
• src/HaskellWorks/Data/Container.hs +7/−5
• src/HaskellWorks/Data/Decode.hs +0/−11
• src/HaskellWorks/Data/Drop.hs +11/−9
• src/HaskellWorks/Data/Empty.hs +8/−6
• src/HaskellWorks/Data/Filter.hs +1/−1
• src/HaskellWorks/Data/FromByteString.hs +21/−21
• src/HaskellWorks/Data/FromForeignRegion.hs +6/−18
• src/HaskellWorks/Data/Generate.hs +6/−4
• src/HaskellWorks/Data/Head.hs +10/−8
• src/HaskellWorks/Data/Length.hs +15/−11
• src/HaskellWorks/Data/Naive.hs +2/−0
• src/HaskellWorks/Data/Sign.hs +0/−62
• src/HaskellWorks/Data/Snoc.hs +0/−93
• src/HaskellWorks/Data/Take.hs +10/−8
• src/HaskellWorks/Data/TreeCursor.hs +1/−6
• src/HaskellWorks/Data/Uncons.hs +13/−11
• src/HaskellWorks/Data/Unsign.hs +3/−0
• src/HaskellWorks/Data/Vector/BoxedVectorLike.hs +0/−58
• src/HaskellWorks/Data/Vector/StorableVectorLike.hs +0/−58
• test/HaskellWorks/Data/FromForeignRegionSpec.hs +0/−40

@@ -1,53 +0,0 @@-{-# LANGUAGE BangPatterns        #-}-{-# LANGUAGE ScopedTypeVariables #-}--module Main where--import Criterion.Main-import Data.Monoid-import Data.Word-import Foreign-import HaskellWorks.Data.FromForeignRegion--import qualified Data.ByteString          as BS-import qualified Data.ByteString.Internal as BSI-import qualified Data.Vector.Storable     as DVS-import qualified System.IO                as IO-import qualified System.IO.MMap           as IO--setupEnvByteString :: FilePath -> IO BS.ByteString-setupEnvByteString filepath = do-  (fptr :: ForeignPtr Word8, offset, size) <- IO.mmapFileForeignPtr filepath IO.ReadOnly Nothing-  let !bs = BSI.fromForeignPtr (castForeignPtr fptr) offset size-  return bs--mmapVectorLike :: FromForeignRegion a => FilePath -> IO a-mmapVectorLike filePath = do-  region <- IO.mmapFileForeignPtr filePath IO.ReadOnly Nothing-  let !bs = fromForeignRegion region-  return bs--sumFileByteString :: FilePath -> IO ()-sumFileByteString filePath = do-  !(bs :: BS.ByteString) <- mmapVectorLike filePath-  IO.hPutStrLn IO.stderr $ "Length ByteString: " <> show (BS.length bs)-  let !_ = BS.foldl' (+) 0 bs-  return ()--sumFileVectorWord64 :: FilePath -> IO ()-sumFileVectorWord64 filePath = do-  !(v :: DVS.Vector Word64) <- mmapVectorLike filePath-  IO.hPutStrLn IO.stderr $ "Length Vector: " <> show (DVS.length v)-  let !_ = DVS.foldl' (+) 0 v-  return ()--benchRankJson40Conduits :: [Benchmark]-benchRankJson40Conduits =-  [ env (return ()) $ \_ -> bgroup "medium.csv"-    [ bench "Foldl' over ByteString"    (whnfIO (sumFileByteString   "corpus/medium.csv"))-    , bench "Foldl' over Vector Word64" (whnfIO (sumFileVectorWord64 "corpus/medium.csv"))-    ]-  ]--main :: IO ()-main = defaultMain benchRankJson40Conduits

@@ -1,111 +1,64 @@--- This file has been generated from package.yaml by hpack version 0.20.0.------ see: https://github.com/sol/hpack------ hash: 5f0d8912b294f5b5be8549239e1bc23d7911505275f8894882eaafa4bf683b5a--name:           hw-prim-version:        0.4.0.7-synopsis:       Primitive functions and data types-description:    Please see README.md-category:       Data-stability:      Experimental-homepage:       http://github.com/haskell-works/hw-prim#readme-bug-reports:    https://github.com/haskell-works/hw-prim/issues-author:         John Ky-maintainer:     newhoggy@gmail.com-copyright:      2016-2018 John Ky-license:        BSD3-license-file:   LICENSE-build-type:     Simple-cabal-version:  >= 1.10--extra-source-files:-    README.md--source-repository head-  type: git-  location: https://github.com/haskell-works/hw-prim+name:                   hw-prim+version:                0.5.0.0+synopsis:               Primitive functions and data types+description:            Please see README.md+homepage:               http://github.com/haskell-works/hw-prim#readme+license:                BSD3+license-file:           LICENSE+author:                 John Ky+maintainer:             newhoggy@gmail.com+copyright:              2016 John Ky+category:               Data+stability:              Experimental+build-type:             Simple+extra-source-files:     README.md+cabal-version:          >= 1.22  library-  hs-source-dirs:-      src-  ghc-options: -Wall -O2 -msse4.2-  build-depends:-      base >=4 && <5-    , bytestring-    , mmap-    , vector-  exposed-modules:-      HaskellWorks.Data.AtIndex-      HaskellWorks.Data.ByteString-      HaskellWorks.Data.Char.IsChar-      HaskellWorks.Data.Concat-      HaskellWorks.Data.Container-      HaskellWorks.Data.Decode-      HaskellWorks.Data.Drop-      HaskellWorks.Data.Empty-      HaskellWorks.Data.Filter-      HaskellWorks.Data.FromByteString-      HaskellWorks.Data.FromForeignRegion-      HaskellWorks.Data.Generate-      HaskellWorks.Data.Head-      HaskellWorks.Data.Length-      HaskellWorks.Data.Naive-      HaskellWorks.Data.Positioning-      HaskellWorks.Data.Search-      HaskellWorks.Data.Sign-      HaskellWorks.Data.Snoc-      HaskellWorks.Data.Take-      HaskellWorks.Data.TreeCursor-      HaskellWorks.Data.Uncons-      HaskellWorks.Data.Unsign-      HaskellWorks.Data.Vector.AsVector64-      HaskellWorks.Data.Vector.BoxedVectorLike-      HaskellWorks.Data.Vector.StorableVectorLike-  other-modules:-      HaskellWorks.Data.Char-      Paths_hw_prim-  default-language: Haskell2010+  hs-source-dirs:       src+  exposed-modules:      HaskellWorks.Data.AtIndex+                      , HaskellWorks.Data.ByteString+                      , HaskellWorks.Data.Char.IsChar+                      , HaskellWorks.Data.Concat+                      , HaskellWorks.Data.Container+                      , HaskellWorks.Data.Drop+                      , HaskellWorks.Data.Empty+                      , HaskellWorks.Data.Filter+                      , HaskellWorks.Data.FromByteString+                      , HaskellWorks.Data.FromForeignRegion+                      , HaskellWorks.Data.Generate+                      , HaskellWorks.Data.Head+                      , HaskellWorks.Data.Length+                      , HaskellWorks.Data.Naive+                      , HaskellWorks.Data.Positioning+                      , HaskellWorks.Data.Search+                      , HaskellWorks.Data.Take+                      , HaskellWorks.Data.TreeCursor+                      , HaskellWorks.Data.Uncons+                      , HaskellWorks.Data.Unsign+                      , HaskellWorks.Data.Vector.AsVector64+  build-depends:        base                          >= 4          && < 5+                      , bytestring+                      , vector +  default-language:     Haskell2010+  ghc-options:          -Wall -O2 -msse4.2+ test-suite hw-prim-test-  type: exitcode-stdio-1.0-  main-is: Spec.hs-  hs-source-dirs:-      test-  ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N-  build-depends:-      QuickCheck-    , base >=4 && <5-    , bytestring-    , directory-    , exceptions-    , hedgehog-    , hspec-    , hw-hspec-hedgehog-    , hw-prim-    , mmap-    , vector-  other-modules:-      HaskellWorks.Data.FromByteStringSpec-      HaskellWorks.Data.FromForeignRegionSpec-      HaskellWorks.Data.SearchSpec-      Paths_hw_prim-  default-language: Haskell2010+  type:                 exitcode-stdio-1.0+  hs-source-dirs:       test+  main-is:              Spec.hs+  other-modules:        HaskellWorks.Data.FromByteStringSpec+                      , HaskellWorks.Data.SearchSpec+  build-depends:        base                          >= 4          && < 5+                      , bytestring+                      , hspec+                      , hw-prim+                      , QuickCheck+                      , vector+  ghc-options:          -threaded -rtsopts -with-rtsopts=-N -Wall+  default-language:     Haskell2010 -benchmark bench-  type: exitcode-stdio-1.0-  main-is: Main.hs-  hs-source-dirs:-      bench-  ghc-options: -Wall -O2 -msse4.2-  build-depends:-      base >=4 && <5-    , bytestring-    , criterion-    , hw-prim-    , mmap-    , vector-  other-modules:-      Paths_hw_prim-  default-language: Haskell2010+source-repository head+  type:     git+  location: https://github.com/haskell-works/hw-prim

@@ -1,23 +1,27 @@-{-# LANGUAGE FlexibleInstances   #-}+{-# LANGUAGE FlexibleInstances     #-} {-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE TypeFamilies        #-}+{-# LANGUAGE TypeFamilies          #-}  module HaskellWorks.Data.AtIndex-    ( Container(..)-    , AtIndex(..)+    ( AtIndex(..)+    , Container(..)     , Length(..)     ) where -import qualified Data.ByteString               as BS-import           Data.Int-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS-import           Data.Word-import           HaskellWorks.Data.Length-import           HaskellWorks.Data.Positioning+import Data.Int+import Data.Word+import HaskellWorks.Data.Length+import HaskellWorks.Data.Positioning +import qualified Data.ByteString      as BS+import qualified Data.Vector          as DV+import qualified Data.Vector.Storable as DVS+ class Length v => AtIndex v where+  -- | Element at the given index   (!!!)   :: v -> Position -> Elem v++  -- | Element at the given index   atIndex :: v -> Position -> Elem v  instance AtIndex [a] where

@@ -1,5 +0,0 @@-module HaskellWorks.Data.Char-  ( module X-  ) where--import HaskellWorks.Data.Char.IsChar as X

@@ -6,15 +6,16 @@   ( Concat(..)   ) where -import qualified Data.ByteString               as BS-import           Data.Int-import qualified Data.List                     as L-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS-import           Data.Word+import Data.Int+import Data.Word --- | Class of values that support vector like operations+import qualified Data.ByteString      as BS+import qualified Data.List            as L+import qualified Data.Vector          as DV+import qualified Data.Vector.Storable as DVS+ class Concat v where+  -- | Concatenate list of values   concat :: [v] -> v  instance Concat [a] where

@@ -6,13 +6,15 @@     ( Container(..)     ) where -import qualified Data.ByteString               as BS-import           Data.Int-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS-import           Data.Word+import Data.Int+import Data.Word +import qualified Data.ByteString      as BS+import qualified Data.Vector          as DV+import qualified Data.Vector.Storable as DVS+ class Container a where+  -- | Element type of a container   type Elem a  instance Container [a] where

@@ -1,11 +0,0 @@-{-# LANGUAGE MultiParamTypeClasses #-}--module HaskellWorks.Data.Decode-  ( Decode(..)-  , DecodeError(..)-  ) where--data DecodeError = DecodeError String deriving (Eq, Show)--class Decode s t where-  decode :: s -> Either DecodeError t

@@ -7,17 +7,19 @@     , Drop(..)     ) where -import qualified Data.ByteString               as BS-import           Data.Int-import qualified Data.List                     as L-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS-import           Data.Word-import           HaskellWorks.Data.Container-import           HaskellWorks.Data.Positioning-import           Prelude hiding (drop)+import Data.Int+import Data.Word+import HaskellWorks.Data.Container+import HaskellWorks.Data.Positioning+import Prelude                       hiding (drop) +import qualified Data.ByteString      as BS+import qualified Data.List            as L+import qualified Data.Vector          as DV+import qualified Data.Vector.Storable as DVS+ class Container v => Drop v where+  -- | Drop the first element from the container   drop :: Count -> v -> v  instance Drop [a] where

@@ -7,14 +7,16 @@     ( Empty(..)     ) where -import qualified Data.ByteString               as BS-import           Data.Int-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS-import           Data.Word-import           HaskellWorks.Data.Container+import Data.Int+import Data.Word+import HaskellWorks.Data.Container +import qualified Data.ByteString      as BS+import qualified Data.Vector          as DV+import qualified Data.Vector.Storable as DVS+ class Container a => Empty a where+  -- | Empty container   empty :: a  instance Empty [a] where

@@ -15,8 +15,8 @@ import           Data.Word import           HaskellWorks.Data.Container --- | Class of values that support vector like operations class Container v => Filter v where+  -- | Filter the element of a container with the given predicate   filter :: (Elem v -> Bool) -> v -> v  instance Filter String where

@@ -1,16 +1,16 @@-{-# LANGUAGE FlexibleInstances  #-}-{-# LANGUAGE InstanceSigs       #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE InstanceSigs      #-}  module HaskellWorks.Data.FromByteString   ( FromByteString(..)   ) where -import           Data.Bits-import qualified Data.ByteString            as BS-import qualified Data.Vector.Storable       as DVS-import           Data.Word+import Data.Bits+import Data.Word --- | Class for byte-string-like datastructures+import qualified Data.ByteString      as BS+import qualified Data.Vector.Storable as DVS+ class FromByteString a where   -- | Convert a byte string to a value of type @a   fromByteString :: BS.ByteString -> a@@ -20,47 +20,47 @@   fromByteString bs = DVS.unfoldrN (BS.length bs) gen bs     where gen :: BS.ByteString -> Maybe (Word8, BS.ByteString)           gen cs = case BS.uncons cs of-            Just (d, ds)  -> Just (d, ds)-            Nothing       -> Nothing+            Just (d, ds) -> Just (d, ds)+            Nothing      -> Nothing  instance FromByteString (DVS.Vector Word16) where   fromByteString :: BS.ByteString -> DVS.Vector Word16   fromByteString bs = DVS.unfoldrN (BS.length bs `div` 2 + 2) gen bs     where gen :: BS.ByteString -> Maybe (Word16, BS.ByteString)           gen cs = case BS.uncons cs of-            Just (d, ds)  -> gen' 8 (fromIntegral d) ds-            Nothing       -> Nothing+            Just (d, ds) -> gen' 8 (fromIntegral d) ds+            Nothing      -> Nothing           gen' :: Int -> Word16 -> BS.ByteString -> Maybe (Word16, BS.ByteString)           gen' n w cs             | n >= 16   = Just (w, cs)             | otherwise = case BS.uncons cs of-                Just (d, ds)  -> gen' (n + 8) (w .|. (fromIntegral d `shiftL` fromIntegral n)) ds-                Nothing       -> Just (w, cs)+                Just (d, ds) -> gen' (n + 8) (w .|. (fromIntegral d `shiftL` fromIntegral n)) ds+                Nothing      -> Just (w, cs)  instance FromByteString (DVS.Vector Word32) where   fromByteString :: BS.ByteString -> DVS.Vector Word32   fromByteString bs = DVS.unfoldrN (BS.length bs `div` 4 + 4) gen bs     where gen :: BS.ByteString -> Maybe (Word32, BS.ByteString)           gen cs = case BS.uncons cs of-            Just (d, ds)  -> gen' 8 (fromIntegral d) ds-            Nothing       -> Nothing+            Just (d, ds) -> gen' 8 (fromIntegral d) ds+            Nothing      -> Nothing           gen' :: Int -> Word32 -> BS.ByteString -> Maybe (Word32, BS.ByteString)           gen' n w cs             | n >= 32   = Just (w, cs)             | otherwise = case BS.uncons cs of-                Just (d, ds)  -> gen' (n + 8) (w .|. (fromIntegral d `shiftL` fromIntegral n)) ds-                Nothing       -> Just (w, cs)+                Just (d, ds) -> gen' (n + 8) (w .|. (fromIntegral d `shiftL` fromIntegral n)) ds+                Nothing      -> Just (w, cs)  instance FromByteString (DVS.Vector Word64) where   fromByteString :: BS.ByteString -> DVS.Vector Word64   fromByteString bs = DVS.unfoldrN (BS.length bs `div` 8 + 8) gen bs     where gen :: BS.ByteString -> Maybe (Word64, BS.ByteString)           gen cs = case BS.uncons cs of-            Just (d, ds)  -> gen' 8 (fromIntegral d) ds-            Nothing       -> Nothing+            Just (d, ds) -> gen' 8 (fromIntegral d) ds+            Nothing      -> Nothing           gen' :: Int -> Word64 -> BS.ByteString -> Maybe (Word64, BS.ByteString)           gen' n w cs             | n >= 64   = Just (w, cs)             | otherwise = case BS.uncons cs of-                Just (d, ds)  -> gen' (n + 8) (w .|. (fromIntegral d `shiftL` fromIntegral n)) ds-                Nothing       -> Just (w, cs)+                Just (d, ds) -> gen' (n + 8) (w .|. (fromIntegral d `shiftL` fromIntegral n)) ds+                Nothing      -> Just (w, cs)

@@ -1,23 +1,17 @@-{-# LANGUAGE BangPatterns      #-} {-# LANGUAGE FlexibleInstances #-} -module HaskellWorks.Data.FromForeignRegion-  ( FromForeignRegion(..)-  , ForeignRegion-  , mmapFromForeignRegion-  ) where+module HaskellWorks.Data.FromForeignRegion where  import Data.Word import Foreign.ForeignPtr+import HaskellWorks.Data.FromByteString  import qualified Data.ByteString          as BS import qualified Data.ByteString.Internal as BSI import qualified Data.Vector.Storable     as DVS-import qualified System.IO.MMap           as IO  type ForeignRegion = (ForeignPtr Word8, Int, Int) --- | Class for datastructures that can be created from a foreign region class FromForeignRegion a where   -- | Create a value of type @a from a foreign region.   fromForeignRegion :: ForeignRegion -> a@@ -26,19 +20,13 @@   fromForeignRegion (fptr, offset, size) = BSI.fromForeignPtr (castForeignPtr fptr) offset size  instance FromForeignRegion (DVS.Vector Word8) where-  fromForeignRegion (fptr, offset, size) = DVS.unsafeFromForeignPtr (castForeignPtr fptr) offset size+  fromForeignRegion = fromByteString . fromForeignRegion  instance FromForeignRegion (DVS.Vector Word16) where-  fromForeignRegion (fptr, offset, size) = DVS.unsafeFromForeignPtr (castForeignPtr fptr) offset ((size + 1) `div` 2)+  fromForeignRegion = fromByteString . fromForeignRegion  instance FromForeignRegion (DVS.Vector Word32) where-  fromForeignRegion (fptr, offset, size) = DVS.unsafeFromForeignPtr (castForeignPtr fptr) offset ((size + 3) `div` 4)+  fromForeignRegion = fromByteString . fromForeignRegion  instance FromForeignRegion (DVS.Vector Word64) where-  fromForeignRegion (fptr, offset, size) = DVS.unsafeFromForeignPtr (castForeignPtr fptr) offset ((size + 7) `div` 8)--mmapFromForeignRegion :: FromForeignRegion a => FilePath -> IO a-mmapFromForeignRegion filePath = do-  region <- IO.mmapFileForeignPtr filePath IO.ReadOnly Nothing-  let !bs = fromForeignRegion region-  return bs+  fromForeignRegion = fromByteString . fromForeignRegion

@@ -7,15 +7,17 @@   , Generate(..)   ) where -import qualified Data.ByteString               as BS import           Data.Int-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS import           Data.Word import           HaskellWorks.Data.Container --- | Class of values that support vector like operations+import qualified Data.ByteString               as BS+import qualified Data.Vector                   as DV+import qualified Data.Vector.Storable          as DVS+ class Container v => Generate v where+  -- | Generate a container of the given size using element produced by the+  -- provided function.   generate :: Int -> (Int -> Elem v) -> v  instance Generate String where

@@ -7,16 +7,18 @@     , Head(..)     ) where -import qualified Data.ByteString               as BS-import           Data.Int-import qualified Data.List                     as L-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS-import           Data.Word-import           HaskellWorks.Data.Container-import           Prelude hiding (head)+import Data.Int+import Data.Word+import HaskellWorks.Data.Container+import Prelude                     hiding (head) +import qualified Data.ByteString      as BS+import qualified Data.List            as L+import qualified Data.Vector          as DV+import qualified Data.Vector.Storable as DVS+ class Container v => Head v where+  -- | The first element of the container.   head :: v -> Elem v  instance Head [a] where

@@ -1,23 +1,27 @@-{-# LANGUAGE FlexibleInstances     #-}-{-# LANGUAGE TypeFamilies          #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE TypeFamilies      #-}  module HaskellWorks.Data.Length     ( Container(..)     , Length(..)     ) where -import qualified Data.ByteString               as BS-import           Data.Int-import qualified Data.List                     as L-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS-import           Data.Word-import           HaskellWorks.Data.Container-import           HaskellWorks.Data.Positioning-import           Prelude hiding (length)+import Data.Int+import Data.Word+import HaskellWorks.Data.Container+import HaskellWorks.Data.Positioning+import Prelude                       hiding (length) +import qualified Data.ByteString      as BS+import qualified Data.List            as L+import qualified Data.Vector          as DV+import qualified Data.Vector.Storable as DVS+ class Container v => Length v where+  -- | The length of the container   length :: v -> Count++  -- | The length of the container given as a position   end :: v -> Position   end = fromIntegral . length   {-# INLINE end #-}

@@ -3,6 +3,8 @@     , naive     ) where +-- | Data type providing reference implementations of typeclasses.  Such+-- implementations may be inefficient. newtype Naive a = Naive a deriving (Eq, Show)  naive :: Naive a -> a

@@ -1,62 +0,0 @@-{-# LANGUAGE TypeFamilies #-}--module HaskellWorks.Data.Sign-    ( Sign(..)-    ) where--import Data.Int-import Data.Word--class Sign a where-  type SignOf a-  sign :: a -> SignOf a--instance Sign Word where-  type SignOf Word = Int-  sign = fromIntegral-  {-# INLINE sign #-}--instance Sign Word8 where-  type SignOf Word8 = Int8-  sign = fromIntegral-  {-# INLINE sign #-}--instance Sign Word16 where-  type SignOf Word16 = Int16-  sign = fromIntegral-  {-# INLINE sign #-}--instance Sign Word32 where-  type SignOf Word32 = Int32-  sign = fromIntegral-  {-# INLINE sign #-}--instance Sign Word64 where-  type SignOf Word64 = Int64-  sign = fromIntegral-  {-# INLINE sign #-}--instance Sign Int where-  type SignOf Int = Int-  sign = fromIntegral-  {-# INLINE sign #-}--instance Sign Int8 where-  type SignOf Int8 = Int8-  sign = fromIntegral-  {-# INLINE sign #-}--instance Sign Int16 where-  type SignOf Int16 = Int16-  sign = fromIntegral-  {-# INLINE sign #-}--instance Sign Int32 where-  type SignOf Int32 = Int32-  sign = fromIntegral-  {-# INLINE sign #-}--instance Sign Int64 where-  type SignOf Int64 = Int64-  sign = fromIntegral-  {-# INLINE sign #-}

@@ -1,93 +0,0 @@-{-# LANGUAGE FlexibleInstances     #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE TypeFamilies          #-}--module HaskellWorks.Data.Snoc-    ( Snoc(..)-    ) where--import qualified Data.ByteString               as BS-import           Data.Int-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS-import           Data.Word-import           HaskellWorks.Data.Container--class Container v => Snoc v where-  snoc :: v -> Elem v -> v--instance Snoc [a] where-  snoc v a = v ++ [a]-  {-# INLINE snoc #-}--instance Snoc BS.ByteString where-  snoc = BS.snoc-  {-# INLINE snoc #-}--instance Snoc (DV.Vector Word8) where-  snoc = DV.snoc-  {-# INLINE snoc #-}--instance Snoc (DV.Vector Word16) where-  snoc = DV.snoc-  {-# INLINE snoc #-}--instance Snoc (DV.Vector Word32) where-  snoc = DV.snoc-  {-# INLINE snoc #-}--instance Snoc (DV.Vector Word64) where-  snoc = DV.snoc-  {-# INLINE snoc #-}--instance Snoc (DVS.Vector Word8) where-  snoc = DVS.snoc-  {-# INLINE snoc #-}--instance Snoc (DVS.Vector Word16) where-  snoc = DVS.snoc-  {-# INLINE snoc #-}--instance Snoc (DVS.Vector Word32) where-  snoc = DVS.snoc-  {-# INLINE snoc #-}--instance Snoc (DVS.Vector Word64) where-  snoc = DVS.snoc-  {-# INLINE snoc #-}--instance Snoc (DV.Vector Int8) where-  snoc = DV.snoc-  {-# INLINE snoc #-}--instance Snoc (DV.Vector Int16) where-  snoc = DV.snoc-  {-# INLINE snoc #-}--instance Snoc (DV.Vector Int32) where-  snoc = DV.snoc-  {-# INLINE snoc #-}--instance Snoc (DV.Vector Int64) where-  snoc = DV.snoc-  {-# INLINE snoc #-}--instance Snoc (DVS.Vector Int8) where-  snoc = DVS.snoc-  {-# INLINE snoc #-}--instance Snoc (DVS.Vector Int16) where-  snoc = DVS.snoc-  {-# INLINE snoc #-}--instance Snoc (DVS.Vector Int32) where-  snoc = DVS.snoc-  {-# INLINE snoc #-}--instance Snoc (DVS.Vector Int64) where-  snoc = DVS.snoc-  {-# INLINE snoc #-}--instance Snoc (DVS.Vector Int) where-  snoc = DVS.snoc-  {-# INLINE snoc #-}

@@ -7,16 +7,18 @@     , Take(..)     ) where -import qualified Data.ByteString               as BS-import           Data.Int-import qualified Data.List                     as L-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS-import           Data.Word-import           HaskellWorks.Data.Container-import           HaskellWorks.Data.Positioning+import Data.Int+import Data.Word+import HaskellWorks.Data.Container+import HaskellWorks.Data.Positioning +import qualified Data.ByteString      as BS+import qualified Data.List            as L+import qualified Data.Vector          as DV+import qualified Data.Vector.Storable as DVS+ class Container v => Take v where+  -- | Take the first n elements from a container   take :: Count -> v -> v  instance Take [a] where

@@ -1,13 +1,8 @@--- |--- Copyright: 2016 John Ky--- License: MIT------ Tree Cursor module HaskellWorks.Data.TreeCursor     ( TreeCursor(..)     ) where -import           HaskellWorks.Data.Positioning+import HaskellWorks.Data.Positioning  class TreeCursor k where   firstChild  :: k -> Maybe k

@@ -7,23 +7,25 @@     , Uncons(..)     ) where -import qualified Data.ByteString               as BS-import           Data.Int-import           Data.Maybe-import qualified Data.Vector                   as DV-import qualified Data.Vector.Storable          as DVS-import           Data.Word-import           HaskellWorks.Data.Container-import           HaskellWorks.Data.Drop-import           Prelude hiding (drop)+import Data.Int+import Data.Maybe+import Data.Word+import HaskellWorks.Data.Container+import HaskellWorks.Data.Drop+import Prelude                     hiding (drop) +import qualified Data.ByteString      as BS+import qualified Data.Vector          as DV+import qualified Data.Vector.Storable as DVS+ class Drop v => Uncons v where+  -- | Uncons the head from the container   uncons :: v -> Maybe (Elem v, v)  instance Uncons String where   uncons s = case s of-    (x:xs)  -> Just (x, xs)-    _       -> Nothing+    (x:xs) -> Just (x, xs)+    _      -> Nothing   {-# INLINE uncons   #-}  instance Uncons BS.ByteString where

@@ -8,7 +8,10 @@ import Data.Word  class Unsign a where+  -- | The correspond unsigned version of a type   type UnsignOf a++  -- | Convert to an unsigned type   unsign :: a -> UnsignOf a  instance Unsign Int where

@@ -1,58 +0,0 @@-{-# LANGUAGE AllowAmbiguousTypes   #-}-{-# LANGUAGE FlexibleInstances     #-}-{-# LANGUAGE MultiParamTypeClasses #-}--module HaskellWorks.Data.Vector.BoxedVectorLike-  ( BoxedVectorLike(..)-  ) where--import qualified Data.Vector      as DV-import           Data.Word-import           Foreign.Storable---- | Class of values that support boxed vector like operations-class BoxedVectorLike v e where-  bImap :: (Int -> a -> b) -> v a -> v b-  bMap :: (a -> b) -> v a -> v b-  bUnfoldr :: (Storable a) => (b -> Maybe (a, b)) -> b -> v a-  bUnfoldrN :: (Storable a) => Int -> (b -> Maybe (a, b)) -> b -> v a--instance BoxedVectorLike DV.Vector Word8 where-  bImap = DV.imap-  bMap = DV.map-  bUnfoldr = DV.unfoldr-  bUnfoldrN = DV.unfoldrN-  {-# INLINE bImap     #-}-  {-# INLINE bMap      #-}-  {-# INLINE bUnfoldr  #-}-  {-# INLINE bUnfoldrN #-}--instance BoxedVectorLike DV.Vector Word16 where-  bImap = DV.imap-  bMap = DV.map-  bUnfoldr = DV.unfoldr-  bUnfoldrN = DV.unfoldrN-  {-# INLINE bImap     #-}-  {-# INLINE bMap      #-}-  {-# INLINE bUnfoldr  #-}-  {-# INLINE bUnfoldrN #-}--instance BoxedVectorLike DV.Vector Word32 where-  bImap = DV.imap-  bMap = DV.map-  bUnfoldr = DV.unfoldr-  bUnfoldrN = DV.unfoldrN-  {-# INLINE bImap     #-}-  {-# INLINE bMap      #-}-  {-# INLINE bUnfoldr  #-}-  {-# INLINE bUnfoldrN #-}--instance BoxedVectorLike DV.Vector Word64 where-  bImap = DV.imap-  bMap = DV.map-  bUnfoldr = DV.unfoldr-  bUnfoldrN = DV.unfoldrN-  {-# INLINE bImap     #-}-  {-# INLINE bMap      #-}-  {-# INLINE bUnfoldr  #-}-  {-# INLINE bUnfoldrN #-}

@@ -1,58 +0,0 @@-{-# LANGUAGE AllowAmbiguousTypes   #-}-{-# LANGUAGE FlexibleInstances     #-}-{-# LANGUAGE MultiParamTypeClasses #-}--module HaskellWorks.Data.Vector.StorableVectorLike-  ( StorableVectorLike(..)-  ) where--import qualified Data.Vector.Storable as DVS-import           Data.Word-import           Foreign.Storable---- | Class of values that support storable vector like operations-class StorableVectorLike v e where-  sImap :: (Storable a, Storable b) => (Int -> a -> b) -> v a -> v b-  sMap :: (Storable a, Storable b) => (a -> b) -> v a -> v b-  sUnfoldr :: (Storable a) => (b -> Maybe (a, b)) -> b -> v a-  sUnfoldrN :: (Storable a) => Int -> (b -> Maybe (a, b)) -> b -> v a--instance StorableVectorLike DVS.Vector Word8 where-  sImap = DVS.imap-  sMap = DVS.map-  sUnfoldr = DVS.unfoldr-  sUnfoldrN = DVS.unfoldrN-  {-# INLINABLE sImap     #-}-  {-# INLINABLE sMap      #-}-  {-# INLINABLE sUnfoldr  #-}-  {-# INLINABLE sUnfoldrN #-}--instance StorableVectorLike DVS.Vector Word16 where-  sImap = DVS.imap-  sMap = DVS.map-  sUnfoldr = DVS.unfoldr-  sUnfoldrN = DVS.unfoldrN-  {-# INLINABLE sImap     #-}-  {-# INLINABLE sMap      #-}-  {-# INLINABLE sUnfoldr  #-}-  {-# INLINABLE sUnfoldrN #-}--instance StorableVectorLike DVS.Vector Word32 where-  sImap = DVS.imap-  sMap = DVS.map-  sUnfoldr = DVS.unfoldr-  sUnfoldrN = DVS.unfoldrN-  {-# INLINABLE sImap     #-}-  {-# INLINABLE sMap      #-}-  {-# INLINABLE sUnfoldr  #-}-  {-# INLINABLE sUnfoldrN #-}--instance StorableVectorLike DVS.Vector Word64 where-  sImap = DVS.imap-  sMap = DVS.map-  sUnfoldr = DVS.unfoldr-  sUnfoldrN = DVS.unfoldrN-  {-# INLINABLE sImap     #-}-  {-# INLINABLE sMap      #-}-  {-# INLINABLE sUnfoldr  #-}-  {-# INLINABLE sUnfoldrN #-}

@@ -1,40 +0,0 @@-{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}-{-# LANGUAGE BangPatterns               #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE OverloadedLists            #-}-{-# LANGUAGE ScopedTypeVariables        #-}-{-# LANGUAGE StandaloneDeriving         #-}--module HaskellWorks.Data.FromForeignRegionSpec (spec) where--import Control.Monad.IO.Class-import Data.Word-import Data.Word-import HaskellWorks.Data.FromByteString-import HaskellWorks.Data.FromForeignRegion-import HaskellWorks.Hspec.Hedgehog-import Hedgehog-import Hedgehog.Internal.Gen-import Test.Hspec--import qualified Data.ByteString                     as BS-import qualified Data.Vector.Storable                as DVS-import qualified HaskellWorks.Data.FromForeignRegion as IO-import qualified Hedgehog.Gen                        as G-import qualified Hedgehog.Range                      as R-import qualified System.Directory                    as IO-import qualified System.IO                           as IO--{-# ANN module ("HLint: Ignore Redundant do" :: String) #-}--spec :: Spec-spec = describe "HaskellWorks.Data.FromForeignRegionSpec" $ do-  it "Be able to load file into Vector" $ requireProperty $ do-    ws <- forAll $ G.list (R.linear 0 (1024 * 16)) (G.word8 R.constantBounded)-    liftIO $ IO.createDirectoryIfMissing True "./tmp"-    (fp, h) <- liftIO $ IO.openBinaryTempFile "./tmp" "property-test-.txt"-    liftIO $ BS.hPut h (BS.pack ws)-    liftIO $ IO.hClose h-    !(_ :: DVS.Vector Word64) <- liftIO $ IO.mmapFromForeignRegion fp-    liftIO $ IO.removeFile fp-    True === True