diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown --- a/CHANGELOG.markdown +++ b/CHANGELOG.markdown @@ -6,6 +6,39 @@ This project is versioned according to the [Package Versioning Policy](https://pvp.haskell.org), the *de facto* standard Haskell versioning scheme. +0.7.1.0 [2017-08-10] (git tag: [dejafu-0.7.1.0][]) +------- + +https://hackage.haskell.org/package/dejafu-0.7.1.0 + +### Test.DejaFu + +- Exposed the new SCT discard functions through `dejafuDiscard` and `dejafuDiscardIO`. + + There are no `dejafusDiscard` and `dejafusDiscardIO` functions because this would probably be + confusing, as the traces are shared. + +- The `Discard` type and `defaultDiscard` function are also exposed. + +### Test.DejaFu.Defaults + +- Added a new `defaultDiscarder` function, which discards nothing. + +### Test.DejaFu.SCT + +- Added new SCT functions to selectively discard results or traces, which can be a significant + memory saving if you know what sorts of results you are interested in: + - New type: `Discard`. + - New functions: `runSCTDiscard`, `resultsSetDiscard`, `sctBoundDiscard`, + `sctUniformRandomDiscard`, and `sctWeightedRandomDiscard`. + - `resultsSet` and `resultsSet'` now discard traces as they are produced, rather than all at the + end, greatly improving performance when traces are large. + +[dejafu-0.7.1.0]: https://github.com/barrucadu/dejafu/releases/tag/dejafu-0.7.1.0 + + +--------------------------------------------------------------------------------------------------- + 0.7.0.2 [2017-06-12] (git tag: [dejafu-0.7.0.2][]) ------- diff --git a/Test/DejaFu.hs b/Test/DejaFu.hs --- a/Test/DejaFu.hs +++ b/Test/DejaFu.hs @@ -107,6 +107,12 @@ , dejafusWay , dejafusWayIO + , Discard(..) + , defaultDiscarder + + , dejafuDiscard + , dejafuDiscardIO + -- ** Memory Models -- | Threads running under modern multicore processors do not behave @@ -378,8 +384,27 @@ -> (String, Predicate a) -- ^ The predicate (with a name) to check -> IO Bool -dejafuWay way memtype conc test = dejafusWay way memtype conc [test] +dejafuWay = dejafuDiscard (const Nothing) +-- | Variant of 'dejafuWay' which can selectively discard results. +-- +-- @since 0.7.1.0 +dejafuDiscard :: Show a + => (Either Failure a -> Maybe Discard) + -- ^ Selectively discard results. + -> Way + -- ^ How to run the concurrent program. + -> MemType + -- ^ The memory model to use for non-synchronised @CRef@ operations. + -> (forall t. ConcST t a) + -- ^ The computation to test + -> (String, Predicate a) + -- ^ The predicate (with a name) to check + -> IO Bool +dejafuDiscard discard way memtype conc (name, test) = do + let traces = runST (runSCTDiscard discard way memtype conc) + doTest name (test traces) + -- | Variant of 'dejafu' which takes a collection of predicates to -- test, returning 'True' if all pass. -- @@ -421,8 +446,15 @@ -- -- @since 0.6.0.0 dejafuWayIO :: Show a => Way -> MemType -> ConcIO a -> (String, Predicate a) -> IO Bool -dejafuWayIO way memtype concio test = - dejafusWayIO way memtype concio [test] +dejafuWayIO = dejafuDiscardIO (const Nothing) + +-- | Variant of 'dejafuDiscard' for computations which do 'IO'. +-- +-- @since 0.7.1.0 +dejafuDiscardIO :: Show a => (Either Failure a -> Maybe Discard) -> Way -> MemType -> ConcIO a -> (String, Predicate a) -> IO Bool +dejafuDiscardIO discard way memtype concio (name, test) = do + traces <- runSCTDiscard discard way memtype concio + doTest name (test traces) -- | Variant of 'dejafus' for computations which do 'IO'. -- diff --git a/Test/DejaFu/Common.hs b/Test/DejaFu/Common.hs --- a/Test/DejaFu/Common.hs +++ b/Test/DejaFu/Common.hs @@ -56,10 +56,14 @@ -- * Memory models , MemType(..) + + -- * Miscellaneous + , runRefCont ) where import Control.DeepSeq (NFData(..)) import Control.Exception (MaskingState(..)) +import Control.Monad.Ref (MonadRef(..)) import Data.List (intercalate, nub, sort) import Data.List.NonEmpty (NonEmpty) import Data.Maybe (fromMaybe, mapMaybe) @@ -738,6 +742,7 @@ -- -- @since 0.5.0.0 showTrace :: Trace -> String +showTrace [] = "" showTrace trc = intercalate "\n" $ concatMap go trc : strkey where go (_,_,CommitCRef _ _) = "C-" go (Start (ThreadId _ i),_,_) = "S" ++ show i ++ "-" @@ -857,6 +862,18 @@ -- | @since 0.5.1.0 instance NFData MemType where rnf m = m `seq` () + +------------------------------------------------------------------------------- +-- Miscellaneous + +-- | Run with a continuation that writes its value into a reference, +-- returning the computation and the reference. Using the reference +-- is non-blocking, it is up to you to ensure you wait sufficiently. +runRefCont :: MonadRef r n => (n () -> x) -> (a -> Maybe b) -> ((a -> x) -> x) -> n (x, r (Maybe b)) +runRefCont act f k = do + ref <- newRef Nothing + let c = k (act . writeRef ref . f) + pure (c, ref) ------------------------------------------------------------------------------- -- Utilities diff --git a/Test/DejaFu/Conc/Internal.hs b/Test/DejaFu/Conc/Internal.hs --- a/Test/DejaFu/Conc/Internal.hs +++ b/Test/DejaFu/Conc/Internal.hs @@ -21,11 +21,10 @@ writeRef) import qualified Data.Foldable as F import Data.Functor (void) -import Data.List (sort) +import Data.List (sortOn) import Data.List.NonEmpty (NonEmpty(..), fromList) import qualified Data.Map.Strict as M -import Data.Maybe (fromJust, isJust, - isNothing) +import Data.Maybe (fromJust, isJust) import Data.Monoid ((<>)) import Data.Sequence (Seq, (<|)) import qualified Data.Sequence as Seq @@ -57,16 +56,13 @@ -> M n r a -> n (Either Failure a, Context n r g, SeqTrace, Maybe (ThreadId, ThreadAction)) runConcurrency sched memtype g idsrc caps ma = do - ref <- newRef Nothing - - let c = runCont ma (AStop . writeRef ref . Just . Right) + (c, ref) <- runRefCont AStop (Just . Right) (runM ma) let ctx = Context { cSchedState = g , cIdSource = idsrc , cThreads = launch' Unmasked initialThread (const c) M.empty , cWriteBuf = emptyBuffer , cCaps = caps } - (finalCtx, trace, finalAction) <- runThreads sched memtype ref ctx out <- readRef ref pure (fromJust out, finalCtx, trace, finalAction) @@ -90,42 +86,28 @@ | isTerminated = pure (ctx, sofar, prior) | isDeadlocked = die sofar prior Deadlock ctx | isSTMLocked = die sofar prior STMDeadlock ctx - | isAborted = die sofar prior Abort $ ctx { cSchedState = g' } - | isNonexistant = die sofar prior InternalError $ ctx { cSchedState = g' } - | isBlocked = die sofar prior InternalError $ ctx { cSchedState = g' } - | otherwise = do - stepped <- stepThread sched memtype chosen (_continuation $ fromJust thread) $ ctx { cSchedState = g' } - case stepped of - (Right ctx', actOrTrc) -> - let (_, trc) = getActAndTrc actOrTrc - threads' = if (interruptible <$> M.lookup chosen (cThreads ctx')) /= Just False - then unblockWaitingOn chosen (cThreads ctx') - else cThreads ctx' - sofarSched' = sofarSched <> map (\(d,_,a) -> (d,a)) (F.toList trc) - ctx'' = ctx' { cThreads = delCommitThreads threads' } - in go (sofar <> trc) sofarSched' (getPrior actOrTrc) ctx'' - (Left failure, actOrTrc) -> - let (_, trc) = getActAndTrc actOrTrc - ctx' = ctx { cSchedState = g', cThreads = delCommitThreads threads } - in die (sofar <> trc) (getPrior actOrTrc) failure ctx' - + | otherwise = + let ctx' = ctx { cSchedState = g' } + in case choice of + Just chosen -> case M.lookup chosen threadsc of + Just thread + | isBlocked thread -> die sofar prior InternalError ctx' + | otherwise -> step chosen thread ctx' + Nothing -> die sofar prior InternalError ctx' + Nothing -> die sofar prior Abort ctx' where (choice, g') = sched sofarSched prior (fromList $ map (\(t,l:|_) -> (t,l)) runnable') (cSchedState ctx) - chosen = fromJust choice - runnable' = [(t, nextActions t) | t <- sort $ M.keys runnable] - runnable = M.filter (isNothing . _blocking) threadsc - thread = M.lookup chosen threadsc + runnable' = [(t, lookahead (_continuation a)) | (t, a) <- sortOn fst $ M.assocs runnable] + runnable = M.filter (not . isBlocked) threadsc threadsc = addCommitThreads (cWriteBuf ctx) threads threads = cThreads ctx - isAborted = isNothing choice - isBlocked = isJust . _blocking $ fromJust thread - isNonexistant = isNothing thread + isBlocked = isJust . _blocking isTerminated = initialThread `notElem` M.keys threads - isDeadlocked = M.null (M.filter (isNothing . _blocking) threads) && + isDeadlocked = M.null (M.filter (not . isBlocked) threads) && (((~= OnMVarFull undefined) <$> M.lookup initialThread threads) == Just True || ((~= OnMVarEmpty undefined) <$> M.lookup initialThread threads) == Just True || ((~= OnMask undefined) <$> M.lookup initialThread threads) == Just True) - isSTMLocked = M.null (M.filter (isNothing . _blocking) threads) && + isSTMLocked = M.null (M.filter (not . isBlocked) threads) && ((~= OnTVar []) <$> M.lookup initialThread threads) == Just True unblockWaitingOn tid = fmap unblock where @@ -133,22 +115,37 @@ Just (OnMask t) | t == tid -> thrd { _blocking = Nothing } _ -> thrd - decision - | Just chosen == (fst <$> prior) = Continue - | (fst <$> prior) `notElem` map (Just . fst) runnable' = Start chosen - | otherwise = SwitchTo chosen - - nextActions t = lookahead . _continuation . fromJust $ M.lookup t threadsc - die sofar' finalDecision reason finalCtx = do writeRef ref (Just $ Left reason) pure (finalCtx, sofar', finalDecision) - getActAndTrc (Single a) = (a, Seq.singleton (decision, runnable', a)) - getActAndTrc (SubC as _) = (Subconcurrency, (decision, runnable', Subconcurrency) <| as) + step chosen thread ctx' = do + (res, actOrTrc) <- stepThread sched memtype chosen (_continuation thread) $ ctx { cSchedState = g' } + let trc = getTrc actOrTrc + let sofar' = sofar <> trc + let sofarSched' = sofarSched <> map (\(d,_,a) -> (d,a)) (F.toList trc) + let prior' = getPrior actOrTrc + case res of + Right ctx'' -> + let threads' = if (interruptible <$> M.lookup chosen (cThreads ctx'')) /= Just False + then unblockWaitingOn chosen (cThreads ctx'') + else cThreads ctx'' + ctx''' = ctx'' { cThreads = delCommitThreads threads' } + in go sofar' sofarSched' prior' ctx''' + Left failure -> + let ctx'' = ctx' { cThreads = delCommitThreads threads } + in die sofar' prior' failure ctx'' + where + decision + | Just chosen == (fst <$> prior) = Continue + | (fst <$> prior) `notElem` map (Just . fst) runnable' = Start chosen + | otherwise = SwitchTo chosen - getPrior (Single a) = Just (chosen, a) - getPrior (SubC _ finalD) = finalD + getTrc (Single a) = Seq.singleton (decision, runnable', a) + getTrc (SubC as _) = (decision, runnable', Subconcurrency) <| as + + getPrior (Single a) = Just (chosen, a) + getPrior (SubC _ finalD) = finalD -------------------------------------------------------------------------------- -- * Single-step execution diff --git a/Test/DejaFu/Defaults.hs b/Test/DejaFu/Defaults.hs --- a/Test/DejaFu/Defaults.hs +++ b/Test/DejaFu/Defaults.hs @@ -19,6 +19,12 @@ defaultWay :: Way defaultWay = systematically defaultBounds +-- | Do not discard any results. +-- +-- @since 0.7.1.0 +defaultDiscarder :: Either Failure a -> Maybe Discard +defaultDiscarder = const Nothing + -- | The default memory model: @TotalStoreOrder@ -- -- @since 0.2.0.0 diff --git a/Test/DejaFu/SCT.hs b/Test/DejaFu/SCT.hs --- a/Test/DejaFu/SCT.hs +++ b/Test/DejaFu/SCT.hs @@ -18,9 +18,18 @@ , uniformly , swarmy , runSCT - , runSCT' , resultsSet + + -- ** Discarding variants + , Discard(..) + , runSCTDiscard + , resultsSetDiscard + + -- ** Strict variants + , runSCT' , resultsSet' + , runSCTDiscard' + , resultsSetDiscard' -- * Bounded Partial-order Reduction @@ -51,6 +60,7 @@ , Bounds(..) , noBounds , sctBound + , sctBoundDiscard -- ** Pre-emption Bounding @@ -91,8 +101,11 @@ , sctUniformRandom , sctWeightedRandom + , sctUniformRandomDiscard + , sctWeightedRandomDiscard ) where +import Control.Applicative ((<|>)) import Control.DeepSeq (NFData(..)) import Control.Monad.Ref (MonadRef) import Data.List (foldl') @@ -201,21 +214,7 @@ -> ConcT r n a -- ^ The computation to run many times. -> n [(Either Failure a, Trace)] -runSCT (Systematic cb) memtype = sctBound memtype cb -runSCT (Weighted g lim use) memtype = sctWeightedRandom memtype g lim use -runSCT (Uniform g lim) memtype = sctUniformRandom memtype g lim - --- | A strict variant of 'runSCT'. --- --- Demanding the result of this will force it to normal form, which --- may be more efficient in some situations. --- --- @since 0.6.0.0 -runSCT' :: (MonadRef r n, NFData a) - => Way -> MemType -> ConcT r n a -> n [(Either Failure a, Trace)] -runSCT' way memtype conc = do - res <- runSCT way memtype conc - rnf res `seq` pure res +runSCT = runSCTDiscard (const Nothing) -- | Return the set of results of a concurrent program. -- @@ -228,9 +227,68 @@ -> ConcT r n a -- ^ The computation to run many times. -> n (Set (Either Failure a)) -resultsSet way memtype conc = - S.fromList . map fst <$> runSCT way memtype conc +resultsSet = resultsSetDiscard (const Nothing) +-- | An @Either Failure a -> Maybe Discard@ value can be used to +-- selectively discard results. +-- +-- @since 0.7.1.0 +data Discard + = DiscardTrace + -- ^ Discard the trace but keep the result. The result will appear + -- to have an empty trace. + | DiscardResultAndTrace + -- ^ Discard the result and the trace. It will simply not be + -- reported as a possible behaviour of the program. + deriving (Eq, Show, Read, Ord, Enum, Bounded) + +instance NFData Discard where + rnf d = d `seq` () + +-- | A variant of 'runSCT' which can selectively discard results. +-- +-- @since 0.7.1.0 +runSCTDiscard :: MonadRef r n + => (Either Failure a -> Maybe Discard) + -- ^ Selectively discard results. + -> Way + -- ^ How to run the concurrent program. + -> MemType + -- ^ The memory model to use for non-synchronised @CRef@ operations. + -> ConcT r n a + -- ^ The computation to run many times. + -> n [(Either Failure a, Trace)] +runSCTDiscard discard (Systematic cb) memtype = sctBoundDiscard discard memtype cb +runSCTDiscard discard (Weighted g lim use) memtype = sctWeightedRandomDiscard discard memtype g lim use +runSCTDiscard discard (Uniform g lim) memtype = sctUniformRandomDiscard discard memtype g lim + +-- | A variant of 'resultsSet' which can selectively discard results. +-- +-- @since 0.7.1.0 +resultsSetDiscard :: (MonadRef r n, Ord a) + => (Either Failure a -> Maybe Discard) + -- ^ Selectively discard results. Traces are always discarded. + -> Way + -- ^ How to run the concurrent program. + -> MemType + -- ^ The memory model to use for non-synchronised @CRef@ operations. + -> ConcT r n a + -- ^ The computation to run many times. + -> n (Set (Either Failure a)) +resultsSetDiscard discard way memtype conc = + let discard' efa = discard efa <|> Just DiscardTrace + in S.fromList . map fst <$> runSCTDiscard discard' way memtype conc + +-- | A strict variant of 'runSCT'. +-- +-- Demanding the result of this will force it to normal form, which +-- may be more efficient in some situations. +-- +-- @since 0.6.0.0 +runSCT' :: (MonadRef r n, NFData a) + => Way -> MemType -> ConcT r n a -> n [(Either Failure a, Trace)] +runSCT' = runSCTDiscard' (const Nothing) + -- | A strict variant of 'resultsSet'. -- -- Demanding the result of this will force it to normal form, which @@ -239,10 +297,32 @@ -- @since 0.6.0.0 resultsSet' :: (MonadRef r n, Ord a, NFData a) => Way -> MemType -> ConcT r n a -> n (Set (Either Failure a)) -resultsSet' way memtype conc = do - res <- resultsSet' way memtype conc +resultsSet' = resultsSetDiscard' (const Nothing) + +-- | A strict variant of 'runSCTDiscard'. +-- +-- Demanding the result of this will force it to normal form, which +-- may be more efficient in some situations. +-- +-- @since 0.7.1.0 +runSCTDiscard' :: (MonadRef r n, NFData a) + => (Either Failure a -> Maybe Discard) -> Way -> MemType -> ConcT r n a -> n [(Either Failure a, Trace)] +runSCTDiscard' discard way memtype conc = do + res <- runSCTDiscard discard way memtype conc rnf res `seq` pure res +-- | A strict variant of 'resultsSetDiscard'. +-- +-- Demanding the result of this will force it to normal form, which +-- may be more efficient in some situations. +-- +-- @since 0.7.1.0 +resultsSetDiscard' :: (MonadRef r n, Ord a, NFData a) + => (Either Failure a -> Maybe Discard) -> Way -> MemType -> ConcT r n a -> n (Set (Either Failure a)) +resultsSetDiscard' discard way memtype conc = do + res <- resultsSetDiscard discard way memtype conc + rnf res `seq` pure res + ------------------------------------------------------------------------------- -- Combined Bounds @@ -394,7 +474,22 @@ -> ConcT r n a -- ^ The computation to run many times -> n [(Either Failure a, Trace)] -sctBound memtype cb conc = go initialState where +sctBound = sctBoundDiscard (const Nothing) + +-- | A variant of 'sctBound' which can selectively discard results. +-- +-- @since 0.7.1.0 +sctBoundDiscard :: MonadRef r n + => (Either Failure a -> Maybe Discard) + -- ^ Selectively discard results. + -> MemType + -- ^ The memory model to use for non-synchronised @CRef@ operations. + -> Bounds + -- ^ The combined bounds. + -> ConcT r n a + -- ^ The computation to run many times + -> n [(Either Failure a, Trace)] +sctBoundDiscard discard memtype cb conc = go initialState where -- Repeatedly run the computation gathering all the results and -- traces into a list until there are no schedules remaining to try. go dp = case findSchedulePrefix dp of @@ -408,8 +503,8 @@ let newDPOR = addTrace conservative trace dp if schedIgnore s - then go newDPOR - else ((res, trace):) <$> go (addBacktracks bpoints newDPOR) + then go newDPOR + else checkDiscard discard res trace $ go (addBacktracks bpoints newDPOR) Nothing -> pure [] @@ -443,14 +538,32 @@ -> ConcT r n a -- ^ The computation to run many times. -> n [(Either Failure a, Trace)] -sctUniformRandom memtype g0 lim0 conc = go g0 (max 0 lim0) where +sctUniformRandom = sctUniformRandomDiscard (const Nothing) + +-- | A variant of 'sctUniformRandom' which can selectively discard +-- results. +-- +-- @since 0.7.1.0 +sctUniformRandomDiscard :: (MonadRef r n, RandomGen g) + => (Either Failure a -> Maybe Discard) + -- ^ Selectively discard results. + -> MemType + -- ^ The memory model to use for non-synchronised @CRef@ operations. + -> g + -- ^ The random number generator. + -> Int + -- ^ The number of executions to perform. + -> ConcT r n a + -- ^ The computation to run many times. + -> n [(Either Failure a, Trace)] +sctUniformRandomDiscard discard memtype g0 lim0 conc = go g0 (max 0 lim0) where go _ 0 = pure [] go g n = do (res, s, trace) <- runConcurrent (randSched $ \g' -> (1, g')) memtype (initialRandSchedState Nothing g) conc - ((res, trace):) <$> go (schedGen s) (n-1) + checkDiscard discard res trace $ go (schedGen s) (n-1) -- | SCT via weighted random scheduling. -- @@ -472,7 +585,27 @@ -> ConcT r n a -- ^ The computation to run many times. -> n [(Either Failure a, Trace)] -sctWeightedRandom memtype g0 lim0 use0 conc = go g0 (max 0 lim0) (max 1 use0) M.empty where +sctWeightedRandom = sctWeightedRandomDiscard (const Nothing) + +-- | A variant of 'sctWeightedRandom' which can selectively discard +-- results. +-- +-- @since 0.7.1.0 +sctWeightedRandomDiscard :: (MonadRef r n, RandomGen g) + => (Either Failure a -> Maybe Discard) + -- ^ Selectively discard results. + -> MemType + -- ^ The memory model to use for non-synchronised @CRef@ operations. + -> g + -- ^ The random number generator. + -> Int + -- ^ The number of executions to perform. + -> Int + -- ^ The number of executions to use the same set of weights for. + -> ConcT r n a + -- ^ The computation to run many times. + -> n [(Either Failure a, Trace)] +sctWeightedRandomDiscard discard memtype g0 lim0 use0 conc = go g0 (max 0 lim0) (max 1 use0) M.empty where go _ 0 _ _ = pure [] go g n 0 _ = go g n (max 1 use0) M.empty go g n use ws = do @@ -480,7 +613,7 @@ memtype (initialRandSchedState (Just ws) g) conc - ((res, trace):) <$> go (schedGen s) (n-1) (use-1) (schedWeights s) + checkDiscard discard res trace $ go (schedGen s) (n-1) (use-1) (schedWeights s) ------------------------------------------------------------------------------- -- Utilities @@ -542,3 +675,10 @@ -- satisfied. (&+&) :: BoundFunc -> BoundFunc -> BoundFunc (&+&) b1 b2 ts dl = b1 ts dl && b2 ts dl + +-- | Apply the discard function. +checkDiscard :: Functor f => (a -> Maybe Discard) -> a -> [b] -> f [(a, [b])] -> f [(a, [b])] +checkDiscard discard res trace rest = case discard res of + Just DiscardResultAndTrace -> rest + Just DiscardTrace -> ((res, []):) <$> rest + Nothing -> ((res, trace):) <$> rest diff --git a/Test/DejaFu/STM.hs b/Test/DejaFu/STM.hs --- a/Test/DejaFu/STM.hs +++ b/Test/DejaFu/STM.hs @@ -71,7 +71,7 @@ instance MonadCatch (STMLike n r) where catch (S stm) handler = toSTM (SCatch (runSTM . handler) stm) -instance Monad n => C.MonadSTM (STMLike n r) where +instance C.MonadSTM (STMLike n r) where type TVar (STMLike n r) = TVar r retry = toSTM (const SRetry) diff --git a/Test/DejaFu/STM/Internal.hs b/Test/DejaFu/STM/Internal.hs --- a/Test/DejaFu/STM/Internal.hs +++ b/Test/DejaFu/STM/Internal.hs @@ -101,12 +101,8 @@ -- | Run a STM transaction, returning an action to undo its effects. doTransaction :: MonadRef r n => M n r a -> IdSource -> n (Result a, n (), IdSource, TTrace) doTransaction ma idsource = do - ref <- newRef Nothing - - let c = runCont ma (SStop . writeRef ref . Just . Right) - + (c, ref) <- runRefCont SStop (Just . Right) (runCont ma) (idsource', undo, readen, written, trace) <- go ref c (pure ()) idsource [] [] [] - res <- readRef ref case res of diff --git a/dejafu.cabal b/dejafu.cabal --- a/dejafu.cabal +++ b/dejafu.cabal @@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/ name: dejafu -version: 0.7.0.2 +version: 0.7.1.0 synopsis: Systematic testing for Haskell concurrency. description: @@ -37,7 +37,7 @@ source-repository this type: git location: https://github.com/barrucadu/dejafu.git - tag: dejafu-0.7.0.2 + tag: dejafu-0.7.1.0 library exposed-modules: Test.DejaFu @@ -67,6 +67,7 @@ , mtl >=2.2 && <2.3 , random >=1.0 && <1.2 , ref-fd >=0.4 && <0.5 + -- remove semigroups dep when GHC 8.4 is out , semigroups >=0.16 && <0.19 , transformers >=0.4 && <0.6 , transformers-base >=0.4 && <0.5