dejafu-0.3.1.1: dejafu.cabal

-- Initial monad-conc.cabal generated by cabal init.  For further 
-- documentation, see http://haskell.org/cabal/users-guide/

name:                dejafu
version:             0.3.1.1
synopsis:            Overloadable primitives for testable, potentially non-deterministic, concurrency.

description:
  /[Déjà Fu is] A martial art in which the user's limbs move in time as well as space, […] It is best described as "the feeling that you have been kicked in the head this way before"/ -- Terry Pratchett, Thief of Time
  .
  Concurrency is nice, deadlocks and race conditions not so much. The
  @Par@ monad family, as defined in
  <https://hackage.haskell.org/package/abstract-par/docs/Control-Monad-Par-Class.html abstract-par>
  provides deterministic parallelism, but sometimes we can tolerate a
  bit of nondeterminism.
  .
  This package provides a class of monads for potentially
  nondeterministic concurrency, with an interface in the spirit of
  GHC's normal concurrency abstraction.
  .
  == @MonadConc@ with 'IO':
  .
  The intention of the @MonadConc@ class is to provide concurrency
  where any apparent nondeterminism arises purely from the scheduling
  behaviour. To put it another way, a given computation, parametrised
  with a fixed set of scheduling decisions, is deterministic. This
  assumption is used by the testing functionality provided by
  Test.DejaFu.
  .
  Whilst this assumption may not hold in general when 'IO' is
  involved, you should strive to produce test cases where it does.
  .
  == Memory Model
  .
  The testing functionality supports a few different memory models,
  for computations which use non-synchronised `CRef` operations. The
  supported models are:
  .
  * __Sequential Consistency:__ A program behaves as a simple
    interleaving of the actions in different threads. When a CRef is
    written to, that write is immediately visible to all threads.
  .
  * __Total Store Order (TSO):__ Each thread has a write buffer. A
    thread sees its writes immediately, but other threads will only
    see writes when they are committed, which may happen later. Writes
    are committed in the same order that they are created.
  .
  * __Partial Store Order (PSO):__ Each CRef has a write buffer. A
    thread sees its writes immediately, but other threads will only
    see writes when they are committed, which may happen later. Writes
    to different CRefs are not necessarily committed in the same order
    that they are created.
  .
  If a testing function does not take the memory model as a parameter,
  it uses TSO.
  .
  See the <https://github.com/barrucadu/dejafu README> for more
  details.

homepage:            https://github.com/barrucadu/dejafu
license:             MIT
license-file:        LICENSE
author:              Michael Walker
maintainer:          mike@barrucadu.co.uk
-- copyright:           
category:            Concurrency
build-type:          Simple
-- extra-source-files:  
cabal-version:       >=1.10

source-repository head
  type:     git
  location: https://github.com/barrucadu/dejafu.git

source-repository this
  type:     git
  location: https://github.com/barrucadu/dejafu.git
  tag:      dejafu-0.3.1.1

library
  exposed-modules:     Control.Monad.Conc.Class
                     , Control.Monad.STM.Class

                     , Control.Concurrent.Classy
                     , Control.Concurrent.Classy.Chan
                     , Control.Concurrent.Classy.CRef
                     , Control.Concurrent.Classy.MVar
                     , Control.Concurrent.Classy.QSem
                     , Control.Concurrent.Classy.QSemN
                     , Control.Concurrent.Classy.STM
                     , Control.Concurrent.Classy.STM.TVar
                     , Control.Concurrent.Classy.STM.TMVar
                     , Control.Concurrent.Classy.STM.TChan
                     , Control.Concurrent.Classy.STM.TQueue
                     , Control.Concurrent.Classy.STM.TBQueue
                     , Control.Concurrent.Classy.STM.TArray

                     , Test.DejaFu
                     , Test.DejaFu.Deterministic
                     , Test.DejaFu.SCT
                     , Test.DejaFu.STM

                     , Test.DejaFu.Deterministic.Internal
                     , Test.DejaFu.Deterministic.Internal.Common
                     , Test.DejaFu.Deterministic.Internal.Memory
                     , Test.DejaFu.Deterministic.Internal.Threading
                     , Test.DejaFu.Internal
                     , Test.DejaFu.STM.Internal

  -- other-modules:       
  -- other-extensions:    
  build-depends:       base              >=4.8  && <5
                     , array             >=0.5  && <0.6
                     , atomic-primops    >=0.8  && <0.9
                     , containers        >=0.5  && <0.6
                     , dpor              >=0.1  && <0.2
                     , deepseq           >=1.3  && <1.5
                     , exceptions        >=0.7  && <0.9
                     , monad-control     >=1.0  && <1.1
                     , monad-loops       >=0.4  && <0.5
                     , mtl               >=2.2  && <2.3
                     , semigroups        >=0.16 && <0.19
                     , stm               >=2.4  && <2.5
                     , template-haskell  >=2.10 && <2.12
                     , transformers      >=0.4  && <0.6
                     , transformers-base >=0.4  && <0.5
  -- hs-source-dirs:      
  default-language:    Haskell2010
  ghc-options:         -Wall