diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown deleted file mode 100644 --- a/CHANGELOG.markdown +++ /dev/null @@ -1,289 +0,0 @@ -Release Notes -============= - -All notable changes to this project will be documented in this file. - -This project is versioned according to the [Package Versioning Policy](https://pvp.haskell.org), the -*de facto* standard Haskell versioning scheme. - - -1.4.0.0 -------- - -- **Date** 2017-01-19 -- **Git tag** [concurrency-1.4.0.0][] -- **Hackage** https://hackage.haskell.org/package/concurrency-1.4.0.0 - -### Control.Monad.Conc.Class - -- The `peekTicket'` now has a more concrete type, to make deriving newtype instances of `MonadConc` - possible. - - - Old: `MonadConc m => proxy m -> Ticket m a -> a` - - New: `MonadConc m => Proxy m -> Ticket m a -> a` - -[concurrency-1.4.0.0]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.4.0.0 - - ---------------------------------------------------------------------------------------------------- - - -1.3.0.0 -------- - -- **Date** 2017-12-23 -- **Git tag** [concurrency-1.3.0.0][] -- **Hackage** https://hackage.haskell.org/package/concurrency-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. - -[concurrency-1.3.0.0]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.3.0.0 - - ---------------------------------------------------------------------------------------------------- - - -1.2.3.0 -------- - -- **Date** 2017-11-30 -- **Git tag** [concurrency-1.2.3.0][] -- **Hackage** https://hackage.haskell.org/package/concurrency-1.2.3.0 - -### Control.Concurrent.Classy.Async - -- New named-thread variants of the `withAsync*` functions: `withAsyncN`, `withAsyncOnN`, - `withAsyncWithUnmaskN`, and `withAsyncOnWithUnmaskN` (#148). - -[concurrency-1.2.3.0]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.2.3.0 - - ---------------------------------------------------------------------------------------------------- - - -1.2.2.0 -------- - -- **Date** 2017-11-05 -- **Git tag** [concurrency-1.2.2.0][] -- **Hackage** https://hackage.haskell.org/package/concurrency-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) - -[concurrency-1.2.2.0]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.2.2.0 - - ---------------------------------------------------------------------------------------------------- - - -1.2.1.2 -------- - -- **Date** 2017-10-14 -- **Git tag** [concurrency-1.2.1.2][] -- **Hackage** https://hackage.haskell.org/package/concurrency-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). - -[concurrency-1.2.1.2]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.2.1.2 - - ---------------------------------------------------------------------------------------------------- - - -1.2.1.1 -------- - -- **Date** 2017-10-11 -- **Git tag** [concurrency-1.2.1.1][] -- **Hackage** https://hackage.haskell.org/package/concurrency-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. - -[concurrency-1.2.1.1]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.2.1.1 - - ---------------------------------------------------------------------------------------------------- - - -1.2.1.0 -------- - -- **Date** 2017-10-02 -- **Git tag** [concurrency-1.2.1.0][] -- **Hackage** https://hackage.haskell.org/package/concurrency-1.2.1.0 - -### Control.Concurrent.Classy.Async - -- New named-thread variants of the `async*` functions: `asyncN`, `asyncOnN`, `asyncWithUnmaskN`, and - `asyncOnWithUnmaskN` (#125). - -[concurrency-1.2.1.0]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.2.1.0 - - ---------------------------------------------------------------------------------------------------- - - -1.2.0.0 -------- - -- **Date** 2017-09-16 -- **Git tag** [concurrency-1.2.0.0][] -- **Hackage** https://hackage.haskell.org/package/concurrency-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`. - -[concurrency-1.2.0.0]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.2.0.0 - - ---------------------------------------------------------------------------------------------------- - - -1.1.2.1 -------- - -- **Date** 2017-06-07 -- **Git tag** [concurrency-1.1.2.1][] -- **Hackage** https://hackage.haskell.org/package/concurrency-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. - -[concurrency-1.1.2.1]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.1.2.1 - - ---------------------------------------------------------------------------------------------------- - - -1.1.2.0 -------- - -- **Date** 2017-04-05 -- **Git tag** [concurrency-1.1.2.0][] -- **Hackage** https://hackage.haskell.org/package/concurrency-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. - -[concurrency-1.1.2.0]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.1.2.0 - - ---------------------------------------------------------------------------------------------------- - - -1.1.1.0 -------- - -- **Date** 2017-03-04 -- **Git tag** [concurrency-1.1.1.0][] -- **Hackage** https://hackage.haskell.org/package/concurrency-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__. - -[concurrency-1.1.1.0]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.1.1.0 - - ---------------------------------------------------------------------------------------------------- - - -1.1.0.0 -------- - -- **Date** 2017-02-21 -- **Git tag** [concurrency-1.1.0.0][] -- **Hackage** https://hackage.haskell.org/package/concurrency-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. - -[concurrency-1.1.0.0]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.1.0.0 - - ---------------------------------------------------------------------------------------------------- - - -1.0.0.0 -------- - -- **Date** 2016-09-10 -- **Git tag** [concurrency-1.0.0.0][] -- **Hackage** https://hackage.haskell.org/package/concurrency-1.0.0.0 - -Initial release. Go read the API docs. - -[concurrency-1.0.0.0]: https://github.com/barrucadu/dejafu/releases/tag/concurrency-1.0.0.0 diff --git a/CHANGELOG.rst b/CHANGELOG.rst new file mode 100644 --- /dev/null +++ b/CHANGELOG.rst @@ -0,0 +1,272 @@ +Release Notes +============= + +This project is versioned according to the PVP_, the *de facto* +standard Haskell versioning scheme. + +.. _PVP: https://pvp.haskell.org/ + + +1.4.0.1 (2018-02-26) +-------------------- + +* Git: :tag:`concurrency-1.4.0.1` +* Hackage: :hackage:`concurrency-1.4.0.1` + +Miscellaneous +~~~~~~~~~~~~~ + +* The upper bound on :hackage:`exceptions` is <0.10. + + +1.4.0.0 (2018-01-19) +-------------------- + +* Git: :tag:`concurrency-1.4.0.0` +* Hackage: :hackage:`concurrency-1.4.0.0` + +Changed +~~~~~~~ + +* ``Control.Monad.Conc.Class.peekTicket'`` has a more concrete type, + to make deriving newtype instances of ``MonadConc`` possible: + + * Old: ``MonadConc m => proxy m -> Ticket m a -> a`` + * New: ``MonadConc m => Proxy m -> Ticket m a -> a`` + + +1.3.0.0 - The Bound Thread Release (2017-12-23) +----------------------------------------------- + +* Git: :tag:`concurrency-1.3.0.0` +* Hackage: :hackage:`concurrency-1.3.0.0` + +**Note:** bound threads are only supported if you compile with GHC and +link with -threaded. + +Added +~~~~~ + +* (:pull:`145`) Bound thread variants of the ``withAsync`` functions: + + * ``Control.Concurrent.Classy.Async.asyncBound`` + * ``Control.Concurrent.Classy.Async.asyncBoundN`` + * ``Control.Concurrent.Classy.Async.withAsyncBound`` + * ``Control.Concurrent.Classy.Async.withAsyncBoundN`` + +* (:pull:`145`) Bound thread functions in ``MonadConc``: + + * ``Control.Monad.Conc.Class.forkOS`` + * ``Control.Monad.Conc.Class.forkOSN`` + * ``Control.Monad.Conc.Class.isCurrentThreadBound`` + +* (:pull:`145`) Helper functions for bound threads: + + * ``Control.Monad.Conc.Class.runInBoundThread`` + * ``Control.Monad.Conc.Class.runInUnboundThread`` + +Changed +~~~~~~~ + +* (:pull:`145`) ``Control.Monad.Conc.Class.rtsSupportsBoundThreads`` + is a re-export from ``Control.Concurrent``. + + +1.2.3.0 (2017-11-30) +-------------------- + +* Git: :tag:`concurrency-1.2.3.0` +* Hackage: :hackage:`concurrency-1.2.3.0` + +Added +~~~~~ + +* (:issue:`148`) Named thread variants of the ``withAsync`` functions: + + * ``Control.Concurrent.Classy.Async.withAsyncN`` + * ``Control.Concurrent.Classy.Async.withAsyncOnN`` + * ``Control.Concurrent.Classy.Async.withAsyncWithUnmaskN`` + * ``Control.Concurrent.Classy.Async.withAsyncOnWithUnmaskN`` + + +1.2.2.0 (2017-11-05) +-------------------- + +* Git: :tag:`concurrency-1.2.2.0` +* Hackage: :hackage:`concurrency-1.2.2.0` + +Added +~~~~~ + +* (:issue:`144`) ``IsConc`` and ``IsSTM`` wrapper types: + + * ``Control.Monad.Conc.Class.IsConc`` (constructor unexported) + * ``Control.Monad.Conc.Class.toIsConc`` + * ``Control.Monad.Conc.Class.fromIsConc`` + * ``Control.Monad.STM.Class.IsSTM`` (constructor unexported) + * ``Control.Monad.STM.Class.toIsSTM`` + * ``Control.Monad.STM.Class.fromIsSTM`` + +Changed +~~~~~~~ + +* ``Control.Monad.Conc.Class.modifyCRefCAS_`` for transformer + instances delegates to the underlying monad, rather than using the + default definition in terms of ``modifyCRefCAS``. + + +1.2.1.2 (2017-10-14) +-------------------- + +* Git: :tag:`concurrency-1.2.1.2` +* Hackage: :hackage:`concurrency-1.2.1.2` + +Fixed +~~~~~ + +* (:issue:`134`) ``Control.Monad.Conc.Class.forkWithUnmask`` and + ``forkOnWithUnmask`` for the ``IO`` instance does not infinitely + loop (bug introduced in :tag:`concurrency-1.2.1.1`). + + +1.2.1.1 (2017-10-11) +-------------------- + +* Git: :tag:`concurrency-1.2.1.1` +* Hackage: :hackage:`concurrency-1.2.1.1` + +Changed +~~~~~~~ + +* Named threads for ``IO`` are implemented with + ``GHC.Conc.labelThread``. + + +1.2.1.0 (2017-10-02) +-------------------- + +* Git: :tag:`concurrency-1.2.1.0` +* Hackage: :hackage:`concurrency-1.2.1.0` + +Added +~~~~~ + +* (:pull:`125`) Named thread variants of the ``async`` functions: + + * ``Control.Concurrent.Classy.Async.asyncN`` + * ``Control.Concurrent.Classy.Async.asyncOnN`` + * ``Control.Concurrent.Classy.Async.asyncWithUnmaskN`` + * ``Control.Concurrent.Classy.Async.asyncOnWithUnmaskN`` + + +1.2.0.0 (2017-09-16) +-------------------- + +* Git: :tag:`concurrency-1.2.0.0` +* Hackage: :hackage:`concurrency-1.2.0.0` + +Changed +~~~~~~~ + +* ``MonadPlus`` is a superclass of ``MonadSTM``. + +* ``Control.Monad.STM.Class.orElse`` is a top-level alias for + ``mplus``. + +* ``Control.Monad.STM.Class.retry`` is a top-level alias for + ``mzero``. + + +1.1.2.1 (2017-06-07) +-------------------- + +* Git: :tag:`concurrency-1.1.2.1` +* Hackage: :hackage:`concurrency-1.1.2.1` + +Changed +~~~~~~~ + +* ``Control.Concurrent.Classy.MVar.isEmptyMVar`` does not briefly + empties the ``MVar``, and does not block. + + +1.1.2.0 (2017-04-05) +-------------------- + +* Git: :tag:`concurrency-1.1.2.0` +* Hackage: :hackage:`concurrency-1.1.2.0` + +Added +~~~~~ + +* Missing functions copied from :hackage:`async`: + + * ``Control.Concurrent.Classy.Async.uninterruptibleCancel`` + * ``Control.Concurrent.Classy.Async.replicateConcurrently`` + * ``Control.Concurrent.Classy.Async.concurrently_`` + * ``Control.Concurrent.Classy.Async.mapConcurrently_`` + * ``Control.Concurrent.Classy.Async.forConcurrently_`` + * ``Control.Concurrent.Classy.Async.replicateConcurrently_`` + +* ``Control.Concurrent.Classy.Async.Concurrently`` has a ``Semigroup`` + instance when built with :hackage:`base` >= 4.9. + +* ``Control.Concurrent.Classy.Async.Concurrently`` has a ``Monoid`` + instance. + +* ``Control.Monad.Conc.Class`` re-exports + ``Control.Monad.Catch.mask_`` and ``uninterruptibleMask_``. + +Changed +~~~~~~~ + +* (:pull:`77`) To match changes in :hackage:`async`, + ``Control.Concurrent.Classy.Async.cancel`` and ``withAsync`` block + until the ``Async`` is killed. + +Miscellaneous +~~~~~~~~~~~~~ + +* Every definition, class, and instance now has a Haddock ``@since`` + annotation. + + +1.1.1.0 - The Async Release (2017-03-04) +---------------------------------------- + +* Git: :tag:`concurrency-1.1.1.0` +* Hackage: :hackage:`concurrency-1.1.1.0` + +Added +~~~~~ + +* The ``Control.Concurrent.Classy.Async`` module. + + +1.1.0.0 (2017-02-21) +-------------------- + +* Git: :tag:`concurrency-1.1.0.0` +* Hackage: :hackage:`concurrency-1.1.0.0` + +Added +~~~~~ + +* ``Control.Monad.Conc.Class.tryReadMVar`` + +Removed +~~~~~~~ + +* ``Control.Monad.Conc.Class._concMessage`` + + +1.0.0.0 - The Initial Release (2016-09-10) +------------------------------------------ + +* Git: :tag:`concurrency-1.0.0.0` +* Hackage: :hackage:`concurrency-1.0.0.0` + +Added +~~~~~ + +* Everything. diff --git a/concurrency.cabal b/concurrency.cabal --- a/concurrency.cabal +++ b/concurrency.cabal @@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/ name: concurrency -version: 1.4.0.0 +version: 1.4.0.1 synopsis: Typeclasses, functions, and data types for concurrency and STM. description: @@ -22,7 +22,7 @@ copyright: (c) 2016--2017 Michael Walker category: Concurrency build-type: Simple -extra-source-files: README.markdown CHANGELOG.markdown +extra-source-files: README.markdown CHANGELOG.rst cabal-version: >=1.10 source-repository head @@ -32,7 +32,7 @@ source-repository this type: git location: https://github.com/barrucadu/dejafu.git - tag: concurrency-1.4.0.0 + tag: concurrency-1.4.0.1 library exposed-modules: Control.Monad.Conc.Class @@ -58,7 +58,7 @@ build-depends: base >=4.8 && <5 , array >=0.5 && <0.6 , atomic-primops >=0.8 && <0.9 - , exceptions >=0.7 && <0.9 + , exceptions >=0.7 && <0.10 , monad-control >=1.0 && <1.1 , mtl >=2.2 && <2.3 , stm >=2.4 && <2.5