Add getShortByteString

Remove unneeded CPP

Author: konsumlamm

changelog.md

@@ -4,6 +4,7 @@ binary
 binary-0.9.0.0
 --------------
 
+- Add `Data.Binary.Get.getShortByteString`
 - Don't reexport `Data.Word` from `Data.Binary`
 
 binary-0.8.9.2

src/Data/Binary/Builder.hs

@@ -28,9 +28,7 @@ module Data.Binary.Builder (
     , append
     , fromByteString        -- :: S.ByteString -> Builder
     , fromLazyByteString    -- :: L.ByteString -> Builder
-#if MIN_VERSION_bytestring(0,10,4)
     , fromShortByteString   -- :: T.ByteString -> Builder
-#endif
     -- * Flushing the buffer state
     , flush
 
@@ -66,12 +64,9 @@ module Data.Binary.Builder (
     , putStringUtf8
     ) where
 
-import qualified Data.ByteString      as S
-import qualified Data.ByteString.Lazy as L
-
-#if MIN_VERSION_bytestring(0,10,4)
+import qualified Data.ByteString       as S
+import qualified Data.ByteString.Lazy  as L
 import qualified Data.ByteString.Short as T
-#endif
 
 import qualified Data.ByteString.Builder as B
 import qualified Data.ByteString.Builder.Extra as B
@@ -127,15 +122,13 @@ fromLazyByteString :: L.ByteString -> Builder
 fromLazyByteString = B.lazyByteString
 {-# INLINE fromLazyByteString #-}
 
-#if MIN_VERSION_bytestring(0,10,4)
 -- | /O(n)./ A builder taking 'T.ShortByteString' and copy it to a Builder,
 -- satisfying
 --
 -- * @'toLazyByteString' ('fromShortByteString' bs) = 'L.fromChunks' ['T.fromShort' bs]
 fromShortByteString :: T.ShortByteString -> Builder
 fromShortByteString = B.shortByteString
 {-# INLINE fromShortByteString #-}
-#endif
 
 ------------------------------------------------------------------------
 

src/Data/Binary/Class.hs

@@ -89,9 +89,7 @@ import Data.Kind (Type)
 import GHC.Exts (RuntimeRep(..), VecCount, VecElem)
 #endif
 import qualified Data.ByteString as B
-#if MIN_VERSION_bytestring(0,10,4)
 import qualified Data.ByteString.Short as BS
-#endif
 import qualified Data.Map        as Map
 import qualified Data.Set        as Set
 import qualified Data.IntMap     as IntMap
@@ -638,12 +636,10 @@ instance Binary ByteString where
     get    = get >>= getLazyByteString
 
 
-#if MIN_VERSION_bytestring(0,10,4)
 instance Binary BS.ShortByteString where
    put bs = put (BS.length bs)
             <> putShortByteString bs
-   get = get >>= fmap BS.toShort . getByteString
-#endif
+   get = get >>= getShortByteString
 
 ------------------------------------------------------------------------
 -- Maps and Sets

src/Data/Binary/Get.hs

@@ -171,6 +171,7 @@ module Data.Binary.Get (
     , getLazyByteString
     , getLazyByteStringNul
     , getRemainingLazyByteString
+    , getShortByteString
 
     -- ** Decoding Words
     , getWord8
@@ -232,6 +233,7 @@ import qualified Data.ByteString as B
 import qualified Data.ByteString.Unsafe as B
 import qualified Data.ByteString.Lazy as L
 import qualified Data.ByteString.Lazy.Internal as L
+import Data.ByteString.Short (ShortByteString, toShort)
 
 import Data.Binary.Get.Internal hiding ( Decoder(..), runGetIncremental )
 import qualified Data.Binary.Get.Internal as I
@@ -432,6 +434,9 @@ getLazyByteStringNul = withInputChunks () consumeUntilNul L.fromChunks failOnEOF
 getRemainingLazyByteString :: Get L.ByteString
 getRemainingLazyByteString = withInputChunks () consumeAll L.fromChunks resumeOnEOF
 
+getShortByteString :: Int -> Get ShortByteString
+getShortByteString = fmap toShort . getByteString
+
 ------------------------------------------------------------------------
 -- Primitives
 

src/Data/Binary/Put.hs

@@ -38,9 +38,7 @@ module Data.Binary.Put (
     , putInt8
     , putByteString
     , putLazyByteString
-#if MIN_VERSION_bytestring(0,10,4)
     , putShortByteString
-#endif
 
     -- * Big-endian primitives
     , putWord16be
@@ -88,9 +86,7 @@ import Data.Int
 import Data.Word
 import qualified Data.ByteString      as S
 import qualified Data.ByteString.Lazy as L
-#if MIN_VERSION_bytestring(0,10,4)
 import Data.ByteString.Short
-#endif
 
 #ifdef HAS_SEMIGROUP
 import Data.Semigroup
@@ -226,12 +222,10 @@ putLazyByteString   :: L.ByteString -> Put
 putLazyByteString   = tell . B.fromLazyByteString
 {-# INLINE putLazyByteString #-}
 
-#if MIN_VERSION_bytestring(0,10,4)
 -- | Write 'ShortByteString' to the buffer
 putShortByteString :: ShortByteString -> Put
 putShortByteString = tell . B.fromShortByteString
 {-# INLINE putShortByteString #-}
-#endif
 
 -- | Write a Word16 in big endian format
 putWord16be         :: Word16 -> Put

tests/Arbitrary.hs

@@ -7,17 +7,13 @@ import Test.QuickCheck
 
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Lazy as L
-#if MIN_VERSION_bytestring(0,10,4)
 import qualified Data.ByteString.Short as S
-#endif
 
 instance Arbitrary L.ByteString where
   arbitrary = fmap L.fromChunks arbitrary
 
 instance Arbitrary B.ByteString where
   arbitrary = B.pack `fmap` arbitrary
 
-#if MIN_VERSION_bytestring(0,10,4)
 instance Arbitrary S.ShortByteString where
   arbitrary = S.toShort `fmap` arbitrary
-#endif

tests/QC.hs

@@ -16,9 +16,7 @@ import           Control.Monad                        (unless, liftM2)
 import qualified Data.ByteString                      as B
 import qualified Data.ByteString.Lazy                 as L
 import qualified Data.ByteString.Lazy.Internal        as L
-#if MIN_VERSION_bytestring(0,10,4)
 import           Data.ByteString.Short                (ShortByteString)
-#endif
 import           Data.Int
 import           Data.Ratio
 import           Data.Typeable
@@ -716,20 +714,16 @@ tests =
 
             , test' "B.ByteString" (test :: T B.ByteString) test
             , test' "L.ByteString" (test :: T L.ByteString) test
-#if MIN_VERSION_bytestring(0,10,4)
             , test' "ShortByteString" (test :: T ShortByteString) test
-#endif
             ]
 
         , testGroup "Invariants" $ map (uncurry testProperty)
             [ ("B.ByteString invariant",   p (prop_invariant :: B B.ByteString                 ))
             , ("[B.ByteString] invariant", p (prop_invariant :: B [B.ByteString]               ))
             , ("L.ByteString invariant",   p (prop_invariant :: B L.ByteString                 ))
             , ("[L.ByteString] invariant", p (prop_invariant :: B [L.ByteString]               ))
-#if MIN_VERSION_bytestring(0,10,4)
             , ("ShortByteString invariant",  p (prop_invariant :: B ShortByteString            ))
             , ("[ShortByteString] invariant", p (prop_invariant :: B [ShortByteString]         ))
-#endif
             ]
 #ifdef HAS_FIXED_CONSTRUCTOR
         , testGroup "Fixed"