concurrency

Typeclasses, functions, and data types for concurrency and STM.

https://github.com/barrucadu/dejafu

Version on this page:1.3.0.0
LTS Haskell 23.24:1.11.0.3
Stackage Nightly 2025-05-28:1.11.0.3
Latest on Hackage:1.11.0.3

See all snapshots concurrency appears in

MIT licensed by Michael Walker
Maintained by [email protected]
This version can be pinned in stack with:concurrency-1.3.0.0@sha256:62bf185fe7e02b0f06a254a659452282ec80085f23873f68d16d60b2204c442c,2795

Module documentation for 1.3.0.0

  • Control
    • Control.Concurrent
      • Control.Concurrent.Classy
        • Control.Concurrent.Classy.Async
        • Control.Concurrent.Classy.CRef
        • Control.Concurrent.Classy.Chan
        • Control.Concurrent.Classy.MVar
        • Control.Concurrent.Classy.QSem
        • Control.Concurrent.Classy.QSemN
        • Control.Concurrent.Classy.STM
          • Control.Concurrent.Classy.STM.TArray
          • Control.Concurrent.Classy.STM.TBQueue
          • Control.Concurrent.Classy.STM.TChan
          • Control.Concurrent.Classy.STM.TMVar
          • Control.Concurrent.Classy.STM.TQueue
          • Control.Concurrent.Classy.STM.TVar
    • Control.Monad
      • Control.Monad.Conc
        • Control.Monad.Conc.Class
      • Control.Monad.STM
        • Control.Monad.STM.Class
Used by 1 package in nightly-2018-01-16(full list with versions):
dejafu

concurrency

A typeclass abstraction over much of Control.Concurrent (and some extras!). If you’re looking for a general introduction to Haskell concurrency, you should check out the excellent Parallel and Concurrent Programming in Haskell, by Simon Marlow. If you are already familiar with concurrent Haskell, just change all the imports from Control.Concurrent.* to Control.Concurrent.Classy.* and fix the type errors.

A brief list of supported functionality:

  • Threads: both unbound and bound.
  • Getting and setting capablities.
  • Yielding and delaying.
  • Mutable state: STM, MVar, and IORef.
  • Atomic compare-and-swap for IORef.
  • Exceptions.
  • All of the data structures in Control.Concurrent.* and Control.Concurrent.STM.* have typeclass-abstracted equivalents.
  • A reimplementation of the async package, providing a higher-level interface over threads, allowing users to conveniently run MonadConc operations asynchronously and wait for their results.

This is quite a rich set of functionality, although it is not complete. If there is something else you need, file an issue!

This used to be part of dejafu, but with the dejafu-0.4.0.0 release, it was split out into its own package.

The documentation of the latest developmental version is available online.

Why this and not something else?

  • Why not base: like lifted-base, concurrency uses typeclasses to make function types more generic. This automatically eliminates calls to lift in many cases, resulting in clearer and simpler code.

  • Why not lifted-base: fundamentally, lifted-base is still using actual threads and actual mutable variables. When using a concurrency-specific typeclass, this isn’t necessarily the case. The dejafu library provides non-IO-based implementations to allow testing concurrent programs.

  • Why not IOSpec: IOSpec provides many of the operations this library does, however it uses a free monad to do so, which has extra allocation overhead. Furthermore, it does not expose enough of the internals in order to accurately test real-execution semantics, such as relaxed memory.

Contributing

Bug reports, pull requests, and comments are very welcome!

Feel free to contact me on GitHub, through IRC (#haskell on freenode), or email ([email protected]).

Changes

Release Notes

All notable changes to this project will be documented in this file.

This project is versioned according to the Package Versioning Policy, the de facto standard Haskell versioning scheme.

1.3.0.0

Control.Concurrent.Classy.Async

  • New asyncBound, asyncBoundN, withAsyncBound, and withAsyncBoundN functions for doing asynchronous actions on bound threads. (#126)

Control.Monad.Conc.Class

  • MonadConc now supports bound threads with new forkOS, forkOSN, and isCurrentThreadBound functions. (#126)

  • New runInBoundThread and runInUnboundThread functions. (#126)

  • The rtsSupportsBoundThreads definition is now the definition from Control.Concurrent re-exported, not just False. (#126)

Note that bound threads are only supported if you compile with GHC and link with -threaded.

1.2.3.0

Control.Concurrent.Classy.Async

  • New named-thread variants of the withAsync* functions: withAsyncN, withAsyncOnN, withAsyncWithUnmaskN, and withAsyncOnWithUnmaskN (#148).

1.2.2.0

Control.Monad.Conc.Class

  • A new IsConc type (and toIsConc, fromIsConc functions), where a value of type IsConc m a can only be constructed if m has a MonadConc instance. Its STM type is IsSTM (STM m). (#144)

  • The provided transformer instances now use the modifyCRefCAS_ of the underlying monad, rather than the default definition in terms of modifyCRefCAS.

Control.Monad.STM.Class

  • A new IsSTM type (and toIsSTM, fromIsSTM functions), where a value of type IsSTM m a can only be constructed if m has a MonadSTM instance. (#144)

1.2.1.2

Control.Monad.Conc.Class

  • Fixes an infinite loop introduced for the IO instance of MonadConc in forkWithUnmask and forkOnWithUnmask in 1.2.1.1 (#134).

1.2.1.1

Control.Monad.Conc.Class

  • The IO instance of MonadConc now names threads with GHC.Conc.labelThread, so thread names now appear in debugging traces of normal execution.

1.2.1.0

Control.Concurrent.Classy.Async

  • New named-thread variants of the async* functions: asyncN, asyncOnN, asyncWithUnmaskN, and asyncOnWithUnmaskN (#125).

1.2.0.0

Control.Monad.STM.Class

  • MonadSTM now has a MonadPlus constraint.
  • The orElse and retry functions have been promoted to top-level definitions, and are aliases for mplus and mzero.

1.1.2.1

Changed

  • The isEmptyMVar function is now implemented using tryReadMVar instead of a combination of tryTakeMVar and putMVar. It no longer modifies the contents of the MVar and can no longer block.

Miscellaneous

  • There is now a changelog.

1.1.2.0

Control.Concurrent.Classy.Async

  • New functions:
    • uninterruptibleCancel function, which is cancel inside an uninterruptible mask.
    • replicateConcurrently function, which performs an action many times in separate threads.
    • concurrently_, mapConcurrently_, forConcurrently_, and replicateConcurrently_ functions, which discard the result of the non-_ version.
  • New instances:
    • Semigroup instance for Concurrently when built with base 4.9.
    • Monoid instance for Concurrently.

Control.Monad.Conc.Class

  • The mask_ and uninterruptibleMask_ functions from Control.Monad.Catch are now re-exported.

Changed

  • The cancel and the withAsync functions now block until the Async action terminates, to match changes in the main async package.

Miscellaneous

  • Every definition, class, and instance now has a Haddock “@since” annotation.

1.1.1.0

Miscellaneous

  • The async-dejafu package has been pulled into this package as the Control.Concurrent.Classy.Async module. async-dejafu is now deprecated.

1.1.0.0

Control.Monad.Conc.Class

  • The MonadConc class now defines tryReadMVar, a non-blocking version of readMVar akin to tryTakeMVar.
  • The MonadConc class no longer defines _concMessage, there is no alternative provided, it is just gone.

1.0.0.0

Initial release. Go read the API docs.