Hello community,
here is the log from the commit of package ghc-binary-parser for openSUSE:Factory checked in at 2017-08-31 20:46:24
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-binary-parser (Old)
and /work/SRC/openSUSE:Factory/.ghc-binary-parser.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-binary-parser"
Thu Aug 31 20:46:24 2017 rev:2 rq:513211 version:0.5.5
Changes:
--------
--- /work/SRC/openSUSE:Factory/ghc-binary-parser/ghc-binary-parser.changes 2017-02-28 23:47:24.420055769 +0100
+++ /work/SRC/openSUSE:Factory/.ghc-binary-parser.new/ghc-binary-parser.changes 2017-08-31 20:46:25.723962241 +0200
@@ -1,0 +2,5 @@
+Thu Jul 27 14:06:03 UTC 2017 - psimons@suse.com
+
+- Update to version 0.5.5 revision 3.
+
+-------------------------------------------------------------------
Old:
----
binary-parser-0.5.2.tar.gz
New:
----
binary-parser-0.5.5.tar.gz
binary-parser.cabal
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ ghc-binary-parser.spec ++++++
--- /var/tmp/diff_new_pack.mQGf1o/_old 2017-08-31 20:46:27.431722533 +0200
+++ /var/tmp/diff_new_pack.mQGf1o/_new 2017-08-31 20:46:27.443720850 +0200
@@ -1,7 +1,7 @@
#
# spec file for package ghc-binary-parser
#
-# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -17,24 +17,31 @@
%global pkg_name binary-parser
+%bcond_with tests
Name: ghc-%{pkg_name}
-Version: 0.5.2
+Version: 0.5.5
Release: 0
Summary: A highly-efficient but limited parser API specialised for bytestrings
License: MIT
-Group: System/Libraries
+Group: Development/Languages/Other
Url: https://hackage.haskell.org/package/%{pkg_name}
Source0: https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz
+Source1: https://hackage.haskell.org/package/%{pkg_name}-%{version}/revision/3.cabal#/%{pkg_name}.cabal
BuildRequires: ghc-Cabal-devel
-# Begin cabal-rpm deps:
BuildRequires: ghc-base-prelude-devel
BuildRequires: ghc-bytestring-devel
+BuildRequires: ghc-mtl-devel
BuildRequires: ghc-rpm-macros
-BuildRequires: ghc-success-devel
BuildRequires: ghc-text-devel
BuildRequires: ghc-transformers-devel
BuildRoot: %{_tmppath}/%{name}-%{version}-build
-# End cabal-rpm deps
+%if %{with tests}
+BuildRequires: ghc-quickcheck-instances-devel
+BuildRequires: ghc-rerebase-devel
+BuildRequires: ghc-tasty-devel
+BuildRequires: ghc-tasty-hunit-devel
+BuildRequires: ghc-tasty-quickcheck-devel
+%endif
%description
A highly-efficient but limited parser API specialised for bytestrings.
@@ -52,15 +59,16 @@
%prep
%setup -q -n %{pkg_name}-%{version}
-
+cp -p %{SOURCE1} %{pkg_name}.cabal
%build
%ghc_lib_build
-
%install
%ghc_lib_install
+%check
+%cabal_test
%post devel
%ghc_pkg_recache
++++++ binary-parser-0.5.2.tar.gz -> binary-parser-0.5.5.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/binary-parser-0.5.2/binary-parser.cabal new/binary-parser-0.5.5/binary-parser.cabal
--- old/binary-parser-0.5.2/binary-parser.cabal 2016-02-12 09:00:10.000000000 +0100
+++ new/binary-parser-0.5.5/binary-parser.cabal 2017-04-08 21:51:54.000000000 +0200
@@ -1,15 +1,15 @@
name:
binary-parser
version:
- 0.5.2
+ 0.5.5
synopsis:
A highly-efficient but limited parser API specialised for bytestrings
category:
Parser, Binary
homepage:
- https://github.com/nikita-volkov/binary-parser
+ https://github.com/nikita-volkov/binary-parser
bug-reports:
- https://github.com/nikita-volkov/binary-parser/issues
+ https://github.com/nikita-volkov/binary-parser/issues
author:
Nikita Volkov
=1.10
-
source-repository head
type:
git
location:
git://github.com/nikita-volkov/binary-parser.git
-
library
hs-source-dirs:
library
default-extensions:
- Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFunctor, DeriveGeneric, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, ImpredicativeTypes, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples
+ Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples
default-language:
Haskell2010
other-modules:
@@ -46,10 +44,31 @@
BinaryParser
build-depends:
-- data:
- success >= 0.2 && < 0.3,
bytestring >= 0.10 && < 0.11,
text >= 1 && < 2,
-- general:
- transformers >= 0.3 && < 0.6,
- base-prelude < 2
+ mtl == 2.*,
+ transformers >= 0.4 && < 0.6,
+ base-prelude < 2,
+ base >= 4.7 && < 5
+test-suite tests
+ type:
+ exitcode-stdio-1.0
+ hs-source-dirs:
+ tests
+ main-is:
+ Main.hs
+ default-extensions:
+ Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples
+ default-language:
+ Haskell2010
+ build-depends:
+ binary-parser,
+ -- testing:
+ tasty == 0.11.*,
+ tasty-quickcheck == 0.8.*,
+ tasty-hunit == 0.9.*,
+ quickcheck-instances >= 0.3.11 && < 0.4,
+ -- general:
+ rerebase == 1.*
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/binary-parser-0.5.2/library/BinaryParser/Prelude.hs new/binary-parser-0.5.5/library/BinaryParser/Prelude.hs
--- old/binary-parser-0.5.2/library/BinaryParser/Prelude.hs 2016-02-12 09:00:10.000000000 +0100
+++ new/binary-parser-0.5.5/library/BinaryParser/Prelude.hs 2017-04-08 21:51:54.000000000 +0200
@@ -13,9 +13,22 @@
-- transformers
-------------------------
-import Control.Monad.Trans.State.Strict as Exports hiding (liftCallCC, liftCatch)
-import Control.Monad.Trans.Reader as Exports hiding (liftCallCC, liftCatch)
+import Control.Monad.IO.Class as Exports
import Control.Monad.Trans.Class as Exports
+import Control.Monad.Trans.Cont as Exports hiding (shift, callCC)
+import Control.Monad.Trans.Except as Exports (ExceptT(ExceptT), Except, except, runExcept, runExceptT, mapExcept, mapExceptT, withExcept, withExceptT, throwE, catchE)
+import Control.Monad.Trans.Maybe as Exports
+import Control.Monad.Trans.Reader as Exports (Reader, runReader, mapReader, withReader, ReaderT(ReaderT), runReaderT, mapReaderT, withReaderT)
+import Control.Monad.Trans.State.Strict as Exports (State, runState, evalState, execState, mapState, withState, StateT(StateT), runStateT, evalStateT, execStateT, mapStateT, withStateT)
+import Control.Monad.Trans.Writer.Strict as Exports (Writer, runWriter, execWriter, mapWriter, WriterT(..), execWriterT, mapWriterT)
+
+-- mtl
+-------------------------
+import Control.Monad.Cont.Class as Exports
+import Control.Monad.Error.Class as Exports hiding (Error(..))
+import Control.Monad.Reader.Class as Exports
+import Control.Monad.State.Class as Exports
+import Control.Monad.Writer.Class as Exports
-- bytestring
-------------------------
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/binary-parser-0.5.2/library/BinaryParser.hs new/binary-parser-0.5.5/library/BinaryParser.hs
--- old/binary-parser-0.5.2/library/BinaryParser.hs 2016-02-12 09:00:10.000000000 +0100
+++ new/binary-parser-0.5.5/library/BinaryParser.hs 2017-04-08 21:51:54.000000000 +0200
@@ -1,22 +1,37 @@
+{-# LANGUAGE CPP #-}
module BinaryParser
(
BinaryParser,
run,
failure,
byte,
+ matchingByte,
bytesOfSize,
+ bytesWhile,
unitOfSize,
unitOfBytes,
+ unitWhile,
remainders,
+ fold,
endOfInput,
sized,
+ -- * Extras
+ storableOfSize,
+ beWord16,
+ leWord16,
+ beWord32,
+ leWord32,
+ beWord64,
+ leWord64,
+ asciiIntegral,
)
where
-import BinaryParser.Prelude
+import BinaryParser.Prelude hiding (fold)
import qualified Data.ByteString as ByteString
import qualified Data.ByteString.Unsafe as ByteString
-import qualified Success.Pure as Success
+import qualified Data.ByteString.Internal as A
+import qualified BinaryParser.Prelude as B
-- |
@@ -28,22 +43,22 @@
-- Does not generate fancy error-messages,
-- which contributes to its efficiency.
newtype BinaryParser a =
- BinaryParser ( StateT ByteString ( Success.Success Text ) a )
- deriving ( Functor , Applicative , Alternative , Monad , MonadPlus )
+ BinaryParser ( StateT ByteString ( Except Text ) a )
+ deriving ( Functor , Applicative , Alternative , Monad , MonadPlus , MonadError Text )
-- |
-- Apply a parser to bytes.
{-# INLINE run #-}
run :: BinaryParser a -> ByteString -> Either Text a
run (BinaryParser parser) input =
- mapLeft fold (Success.asEither (evalStateT parser input))
+ runExcept (evalStateT parser input)
-- |
-- Fail with a message.
{-# INLINE failure #-}
failure :: Text -> BinaryParser a
failure text =
- BinaryParser (lift (Success.failure text))
+ BinaryParser (lift (throwE text))
-- |
-- Consume a single byte.
@@ -52,10 +67,36 @@
byte =
BinaryParser $ StateT $ \remainders ->
if ByteString.null remainders
- then Success.failure "End of input"
+ then throwE "End of input"
else pure (ByteString.unsafeHead remainders, ByteString.unsafeDrop 1 remainders)
-- |
+-- Consume a single byte, which satisfies the predicate.
+{-# INLINE satisfyingByte #-}
+satisfyingByte :: (Word8 -> Bool) -> BinaryParser Word8
+satisfyingByte predicate =
+ BinaryParser $ StateT $ \remainders ->
+ case ByteString.uncons remainders of
+ Nothing -> throwE "End of input"
+ Just (head, tail) ->
+ if predicate head
+ then pure (head, tail)
+ else throwE "Byte doesn't satisfy a predicate"
+
+-- |
+-- Consume a single byte, which satisfies the predicate.
+{-# INLINE matchingByte #-}
+matchingByte :: (Word8 -> Either Text a) -> BinaryParser a
+matchingByte matcher =
+ BinaryParser $ StateT $ \remainders ->
+ case ByteString.uncons remainders of
+ Nothing -> throwE "End of input"
+ Just (head, tail) ->
+ case matcher head of
+ Right result -> pure (result, tail)
+ Left error -> throwE error
+
+-- |
-- Consume an amount of bytes.
{-# INLINE bytesOfSize #-}
bytesOfSize :: Int -> BinaryParser ByteString
@@ -63,7 +104,15 @@
BinaryParser $ StateT $ \remainders ->
if ByteString.length remainders >= size
then return (ByteString.unsafeTake size remainders, ByteString.unsafeDrop size remainders)
- else Success.failure "End of input"
+ else throwE "End of input"
+
+-- |
+-- Consume multiple bytes, which satisfy the predicate.
+{-# INLINE bytesWhile #-}
+bytesWhile :: (Word8 -> Bool) -> BinaryParser ByteString
+bytesWhile predicate =
+ BinaryParser $ StateT $ \remainders ->
+ pure (ByteString.span predicate remainders)
-- |
-- Skip an amount of bytes.
@@ -73,7 +122,7 @@
BinaryParser $ StateT $ \remainders ->
if ByteString.length remainders >= size
then return ((), ByteString.unsafeDrop size remainders)
- else Success.failure "End of input"
+ else throwE "End of input"
-- |
-- Skip specific bytes, while failing if they don't match.
@@ -83,7 +132,15 @@
BinaryParser $ StateT $ \remainders ->
if ByteString.isPrefixOf bytes remainders
then return ((), ByteString.unsafeDrop (ByteString.length bytes) remainders)
- else Success.failure "Bytes don't match"
+ else throwE "Bytes don't match"
+
+-- |
+-- Skip bytes, which satisfy the predicate.
+{-# INLINE unitWhile #-}
+unitWhile :: (Word8 -> Bool) -> BinaryParser ()
+unitWhile predicate =
+ BinaryParser $ StateT $ \remainders ->
+ pure ((), ByteString.dropWhile predicate remainders)
-- |
-- Consume all the remaining bytes.
@@ -99,7 +156,24 @@
endOfInput =
BinaryParser $ StateT $ \case
"" -> return ((), ByteString.empty)
- _ -> Success.failure "Not the end of input"
+ _ -> throwE "Not the end of input"
+
+-- |
+-- Left-fold the bytes, terminating before the byte,
+-- on which the step function returns Nothing.
+{-# INLINE fold #-}
+fold :: (a -> Word8 -> Maybe a) -> a -> BinaryParser a
+fold step init =
+ BinaryParser $ StateT $ return . loop init
+ where
+ loop !accumulator remainders =
+ case ByteString.uncons remainders of
+ Nothing -> (accumulator, remainders)
+ Just (head, tail) ->
+ case step accumulator head of
+ Just newAccumulator ->
+ loop newAccumulator tail
+ Nothing -> (accumulator, remainders)
-- |
-- Run a subparser passing it a chunk of the current input of the specified size.
@@ -111,4 +185,104 @@
then
evalStateT stateT (ByteString.unsafeTake size remainders) &
fmap (\result -> (result, ByteString.unsafeDrop size remainders))
- else Success.failure "End of input"
+ else throwE "End of input"
+
+-- |
+-- Storable value of the given amount of bytes.
+{-# INLINE storableOfSize #-}
+storableOfSize :: Storable a => Int -> BinaryParser a
+storableOfSize size =
+ BinaryParser $ StateT $ \(A.PS payloadFP offset length) ->
+ if length >= size
+ then let result =
+ unsafeDupablePerformIO $ withForeignPtr payloadFP $ \ptr -> peekByteOff (castPtr ptr) offset
+ newRemainder =
+ A.PS payloadFP (offset + size) (length - size)
+ in return (result, newRemainder)
+ else throwE "End of input"
+
+-- | Big-endian word of 2 bytes.
+{-# INLINE beWord16 #-}
+beWord16 :: BinaryParser Word16
+#ifdef WORDS_BIGENDIAN
+beWord16 =
+ storableOfSize 2
+#else
+beWord16 =
+ byteSwap16 <$> storableOfSize 2
+#endif
+
+-- | Little-endian word of 2 bytes.
+{-# INLINE leWord16 #-}
+leWord16 :: BinaryParser Word16
+#ifdef WORDS_BIGENDIAN
+leWord16 =
+ byteSwap16 <$> storableOfSize 2
+#else
+leWord16 =
+ storableOfSize 2
+#endif
+
+-- | Big-endian word of 4 bytes.
+{-# INLINE beWord32 #-}
+beWord32 :: BinaryParser Word32
+#ifdef WORDS_BIGENDIAN
+beWord32 =
+ storableOfSize 4
+#else
+beWord32 =
+ byteSwap32 <$> storableOfSize 4
+#endif
+
+-- | Little-endian word of 4 bytes.
+{-# INLINE leWord32 #-}
+leWord32 :: BinaryParser Word32
+#ifdef WORDS_BIGENDIAN
+leWord32 =
+ byteSwap32 <$> storableOfSize 4
+#else
+leWord32 =
+ storableOfSize 4
+#endif
+
+-- | Big-endian word of 8 bytes.
+{-# INLINE beWord64 #-}
+beWord64 :: BinaryParser Word64
+#ifdef WORDS_BIGENDIAN
+beWord64 =
+ storableOfSize 8
+#else
+beWord64 =
+ byteSwap64 <$> storableOfSize 8
+#endif
+
+-- | Little-endian word of 8 bytes.
+{-# INLINE leWord64 #-}
+leWord64 :: BinaryParser Word64
+#ifdef WORDS_BIGENDIAN
+leWord64 =
+ byteSwap64 <$> storableOfSize 8
+#else
+leWord64 =
+ storableOfSize 8
+#endif
+
+-- |
+-- Integral number encoded in ASCII.
+{-# INLINE asciiIntegral #-}
+asciiIntegral :: Integral a => BinaryParser a
+asciiIntegral =
+ do
+ firstDigit <- matchingByte byteDigit
+ fold step firstDigit
+ where
+ byteDigit byte =
+ case byte - 48 of
+ subtracted ->
+ if subtracted <= 9
+ then Right (fromIntegral subtracted)
+ else Left "Not an ASCII decimal byte"
+ step state byte =
+ case byteDigit byte of
+ Right digit -> Just (state * 10 + digit)
+ _ -> Nothing
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/binary-parser-0.5.2/tests/Main.hs new/binary-parser-0.5.5/tests/Main.hs
--- old/binary-parser-0.5.2/tests/Main.hs 1970-01-01 01:00:00.000000000 +0100
+++ new/binary-parser-0.5.5/tests/Main.hs 2017-04-08 21:51:54.000000000 +0200
@@ -0,0 +1,49 @@
+module Main where
+
+import Prelude
+import Test.QuickCheck.Instances
+import Test.Tasty
+import Test.Tasty.HUnit
+import Test.Tasty.QuickCheck
+import qualified Data.ByteString as A
+import qualified Data.ByteString.Builder as C
+import qualified Data.ByteString.Lazy as D
+import qualified BinaryParser as B
+
+
+main =
+ defaultMain $
+ testGroup "All tests" $
+ [
+ builderIsomporhismProperty "byte" B.byte C.word8
+ ,
+ builderIsomporhismProperty "beWord16" B.beWord16 C.word16BE
+ ,
+ builderIsomporhismProperty "beWord32" B.beWord32 C.word32BE
+ ,
+ expectedResultTest "byte consumes" ((,) <$> B.byte <*> B.beWord32) (49, 4) "1\NUL\NUL\NUL\EOT"
+ ,
+ expectedResultTest "Applicative composition" ((,) <$> B.beWord16 <*> B.beWord16) (1, 2) "\NUL\SOH\NUL\STX"
+ ,
+ let parser =
+ do
+ a <- B.beWord16
+ b <- B.beWord16
+ return (a, b)
+ in expectedResultTest "Monadic composition" parser (1, 2) "\NUL\SOH\NUL\STX"
+ ]
+
+builderIsomporhismProperty details parser valueToBuilder =
+ testProperty name $ \value ->
+ B.run parser (D.toStrict (C.toLazyByteString (valueToBuilder value))) ===
+ Right value
+ where
+ name =
+ "builderIsomporhismProperty: " <> details
+
+expectedResultTest details parser expectedValue input =
+ testCase name $ do
+ assertEqual "" (Right expectedValue) (B.run parser input)
+ where
+ name =
+ "expectedResultTest: " <> details
++++++ binary-parser.cabal ++++++
name:
binary-parser
version:
0.5.5
x-revision: 3
synopsis:
A highly-efficient but limited parser API specialised for bytestrings
category:
Parser, Binary
homepage:
https://github.com/nikita-volkov/binary-parser
bug-reports:
https://github.com/nikita-volkov/binary-parser/issues
author:
Nikita Volkov
=1.10
source-repository head type: git location: git://github.com/nikita-volkov/binary-parser.git library hs-source-dirs: library default-extensions: Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples default-language: Haskell2010 other-modules: BinaryParser.Prelude exposed-modules: BinaryParser build-depends: -- data: bytestring >= 0.10 && < 0.11, text >= 1 && < 2, -- general: mtl == 2.*, transformers >= 0.4 && < 0.6, base-prelude >= 1.2 && < 2, base >= 4.7 && < 5 test-suite tests type: exitcode-stdio-1.0 hs-source-dirs: tests main-is: Main.hs default-extensions: Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples default-language: Haskell2010 build-depends: binary-parser, -- testing: tasty == 0.11.*, tasty-quickcheck == 0.8.*, tasty-hunit == 0.9.*, quickcheck-instances >= 0.3.11 && < 0.4, -- general: rerebase == 1.*