packages feed

stm-lifted 0.1.1.0 → 2.5.0.0

raw patch · 7 files changed

+51/−20 lines, 7 filesdep ~stmPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: stm

API changes (from Hackage documentation)

+ Control.Concurrent.STM.Lifted: atomically :: MonadIO m => STM a -> m a
+ Control.Concurrent.STM.Lifted: data STM a
+ Control.Concurrent.STM.TBQueue.Lifted: data TBQueue a
+ Control.Concurrent.STM.TBQueue.Lifted: flushTBQueue :: () => TBQueue a -> STM [a]
+ Control.Concurrent.STM.TBQueue.Lifted: flushTBQueueIO :: MonadIO m => TBQueue a -> m [a]
+ Control.Concurrent.STM.TBQueue.Lifted: isEmptyTBQueue :: () => TBQueue a -> STM Bool
+ Control.Concurrent.STM.TBQueue.Lifted: isFullTBQueue :: () => TBQueue a -> STM Bool
+ Control.Concurrent.STM.TBQueue.Lifted: lengthTBQueue :: () => TBQueue a -> STM Natural
+ Control.Concurrent.STM.TBQueue.Lifted: lengthTBQueueIO :: MonadIO m => TBQueue a -> m Natural
+ Control.Concurrent.STM.TBQueue.Lifted: newTBQueue :: () => Natural -> STM (TBQueue a)
+ Control.Concurrent.STM.TBQueue.Lifted: peekTBQueue :: () => TBQueue a -> STM a
+ Control.Concurrent.STM.TBQueue.Lifted: readTBQueue :: () => TBQueue a -> STM a
+ Control.Concurrent.STM.TBQueue.Lifted: tryPeekTBQueue :: () => TBQueue a -> STM (Maybe a)
+ Control.Concurrent.STM.TBQueue.Lifted: tryReadTBQueue :: () => TBQueue a -> STM (Maybe a)
+ Control.Concurrent.STM.TBQueue.Lifted: unGetTBQueue :: () => TBQueue a -> a -> STM ()
+ Control.Concurrent.STM.TBQueue.Lifted: writeTBQueue :: () => TBQueue a -> a -> STM ()
+ Control.Concurrent.STM.TChan.Lifted: cloneTChan :: () => TChan a -> STM (TChan a)
+ Control.Concurrent.STM.TChan.Lifted: data TChan a
+ Control.Concurrent.STM.TChan.Lifted: dupTChan :: () => TChan a -> STM (TChan a)
+ Control.Concurrent.STM.TChan.Lifted: isEmptyTChan :: () => TChan a -> STM Bool
+ Control.Concurrent.STM.TChan.Lifted: newBroadcastTChan :: () => STM (TChan a)
+ Control.Concurrent.STM.TChan.Lifted: newTChan :: () => STM (TChan a)
+ Control.Concurrent.STM.TChan.Lifted: peekTChan :: () => TChan a -> STM a
+ Control.Concurrent.STM.TChan.Lifted: readTChan :: () => TChan a -> STM a
+ Control.Concurrent.STM.TChan.Lifted: tryPeekTChan :: () => TChan a -> STM (Maybe a)
+ Control.Concurrent.STM.TChan.Lifted: tryReadTChan :: () => TChan a -> STM (Maybe a)
+ Control.Concurrent.STM.TChan.Lifted: unGetTChan :: () => TChan a -> a -> STM ()
+ Control.Concurrent.STM.TChan.Lifted: writeTChan :: () => TChan a -> a -> STM ()
+ Control.Concurrent.STM.TMVar.Lifted: data TMVar a
+ Control.Concurrent.STM.TMVar.Lifted: isEmptyTMVar :: () => TMVar a -> STM Bool
+ Control.Concurrent.STM.TMVar.Lifted: mkWeakTMVar :: () => TMVar a -> IO () -> IO (Weak (TMVar a))
+ Control.Concurrent.STM.TMVar.Lifted: newEmptyTMVar :: () => STM (TMVar a)
+ Control.Concurrent.STM.TMVar.Lifted: newTMVar :: () => a -> STM (TMVar a)
+ Control.Concurrent.STM.TMVar.Lifted: putTMVar :: () => TMVar a -> a -> STM ()
+ Control.Concurrent.STM.TMVar.Lifted: readTMVar :: () => TMVar a -> STM a
+ Control.Concurrent.STM.TMVar.Lifted: swapTMVar :: () => TMVar a -> a -> STM a
+ Control.Concurrent.STM.TMVar.Lifted: takeTMVar :: () => TMVar a -> STM a
+ Control.Concurrent.STM.TMVar.Lifted: tryPutTMVar :: () => TMVar a -> a -> STM Bool
+ Control.Concurrent.STM.TMVar.Lifted: tryReadTMVar :: () => TMVar a -> STM (Maybe a)
+ Control.Concurrent.STM.TMVar.Lifted: tryTakeTMVar :: () => TMVar a -> STM (Maybe a)
+ Control.Concurrent.STM.TQueue.Lifted: data TQueue a
+ Control.Concurrent.STM.TQueue.Lifted: flushTQueue :: () => TQueue a -> STM [a]
+ Control.Concurrent.STM.TQueue.Lifted: flushTQueueIO :: MonadIO m => TQueue a -> m [a]
+ Control.Concurrent.STM.TQueue.Lifted: isEmptyTQueue :: () => TQueue a -> STM Bool
+ Control.Concurrent.STM.TQueue.Lifted: newTQueue :: () => STM (TQueue a)
+ Control.Concurrent.STM.TQueue.Lifted: peekTQueue :: () => TQueue a -> STM a
+ Control.Concurrent.STM.TQueue.Lifted: readTQueue :: () => TQueue a -> STM a
+ Control.Concurrent.STM.TQueue.Lifted: tryPeekTQueue :: () => TQueue a -> STM (Maybe a)
+ Control.Concurrent.STM.TQueue.Lifted: tryReadTQueue :: () => TQueue a -> STM (Maybe a)
+ Control.Concurrent.STM.TQueue.Lifted: unGetTQueue :: () => TQueue a -> a -> STM ()
+ Control.Concurrent.STM.TQueue.Lifted: writeTQueue :: () => TQueue a -> a -> STM ()
+ Control.Concurrent.STM.TSem.Lifted: signalTSemNIO :: MonadIO m => Natural -> TSem -> m ()
+ Control.Concurrent.STM.TVar.Lifted: data TVar a
+ Control.Concurrent.STM.TVar.Lifted: mkWeakTVar :: () => TVar a -> IO () -> IO (Weak (TVar a))
+ Control.Concurrent.STM.TVar.Lifted: modifyTVar :: () => TVar a -> (a -> a) -> STM ()
+ Control.Concurrent.STM.TVar.Lifted: modifyTVar' :: () => TVar a -> (a -> a) -> STM ()
+ Control.Concurrent.STM.TVar.Lifted: newTVar :: () => a -> STM (TVar a)
+ Control.Concurrent.STM.TVar.Lifted: readTVar :: () => TVar a -> STM a
+ Control.Concurrent.STM.TVar.Lifted: registerDelay :: Int -> IO (TVar Bool)
+ Control.Concurrent.STM.TVar.Lifted: stateTVar :: () => TVar s -> (s -> (a, s)) -> STM a
+ Control.Concurrent.STM.TVar.Lifted: stateTVarIO :: MonadIO m => TVar s -> (s -> (a, s)) -> m a
+ Control.Concurrent.STM.TVar.Lifted: swapTVar :: () => TVar a -> a -> STM a
+ Control.Concurrent.STM.TVar.Lifted: writeTVar :: () => TVar a -> a -> STM ()
- Control.Concurrent.STM.TBQueue.Lifted: newTBQueueIO :: MonadIO m => Int -> m (TBQueue a)
+ Control.Concurrent.STM.TBQueue.Lifted: newTBQueueIO :: MonadIO m => Natural -> m (TBQueue a)
- Control.Concurrent.STM.TSem.Lifted: newTSemIO :: MonadIO m => Int -> m TSem
+ Control.Concurrent.STM.TSem.Lifted: newTSemIO :: MonadIO m => Integer -> m TSem

Files

README.md view
@@ -1,4 +1,4 @@-[![Build status][linux-build-icon]][linux-build]+[![Build status][linux-build-icon]][linux-build]  [![Hackage][hackage-version-icon]][hackage-link] # STM Generalized with MonadIO  This package contains generalization of [STM] with [MonadIO].@@ -8,4 +8,7 @@  [STM]: http://hackage.haskell.org/package/stm [MonadIO]: http://hackage.haskell.org/package/transformers-0.3.0.0/docs/Control-Monad-IO-Class.html++[hackage-version-icon]: https://img.shields.io/hackage/v/stm-lifted.svg+[hackage-link]: https://hackage.haskell.org/package/stm-lifted 
src/Control/Concurrent/STM/Lifted.hs view
@@ -1,9 +1,17 @@-module Control.Concurrent.STM.Lifted (module All) where+module Control.Concurrent.STM.Lifted+    ( STM, atomically -import Control.Concurrent.STM.TVar.Lifted    as All-import Control.Concurrent.STM.TChan.Lifted   as All-import Control.Concurrent.STM.TMVar.Lifted   as All-import Control.Concurrent.STM.TQueue.Lifted  as All-import Control.Concurrent.STM.TBQueue.Lifted as All-import Internal                             as All (STM, atomically)+    , module Control.Concurrent.STM.TVar.Lifted+    , module Control.Concurrent.STM.TChan.Lifted+    , module Control.Concurrent.STM.TMVar.Lifted+    , module Control.Concurrent.STM.TQueue.Lifted+    , module Control.Concurrent.STM.TBQueue.Lifted+    ) where++import Control.Concurrent.STM.TVar.Lifted+import Control.Concurrent.STM.TChan.Lifted+import Control.Concurrent.STM.TMVar.Lifted+import Control.Concurrent.STM.TQueue.Lifted+import Control.Concurrent.STM.TBQueue.Lifted+import Internal (STM, atomically) 
src/Control/Concurrent/STM/TBQueue/Lifted.hs view
@@ -3,22 +3,24 @@     , newTBQueueIO     , readTBQueueIO     , tryReadTBQueueIO+    , flushTBQueueIO     , peekTBQueueIO     , tryPeekTBQueueIO     , writeTBQueueIO     , unGetTBQueueIO+    , lengthTBQueueIO     , isEmptyTBQueueIO     , isFullTBQueueIO     ) where +import Numeric.Natural (Natural) import Control.Concurrent.STM.TBQueue as All hiding (newTBQueueIO) import qualified Control.Concurrent.STM.TBQueue as STM import Internal  ---------------------------------------------------------------------- --newTBQueueIO :: MonadIO m => Int -> m (TBQueue a)+newTBQueueIO :: MonadIO m => Natural -> m (TBQueue a) newTBQueueIO = liftIO . STM.newTBQueueIO  writeTBQueueIO :: MonadIO m => TBQueue a -> a -> m ()@@ -30,6 +32,9 @@ tryReadTBQueueIO :: MonadIO m => TBQueue a -> m (Maybe a) tryReadTBQueueIO = atomically . tryReadTBQueue +flushTBQueueIO :: MonadIO m => TBQueue a -> m [a]+flushTBQueueIO = atomically . flushTBQueue+ peekTBQueueIO :: MonadIO m => TBQueue a -> m a peekTBQueueIO = atomically . peekTBQueue @@ -38,6 +43,9 @@  unGetTBQueueIO :: MonadIO m => TBQueue a -> a -> m () unGetTBQueueIO = atomically .: unGetTBQueue++lengthTBQueueIO :: MonadIO m => TBQueue a -> m Natural+lengthTBQueueIO = atomically . lengthTBQueue  isEmptyTBQueueIO :: MonadIO m => TBQueue a -> m Bool isEmptyTBQueueIO = atomically . isEmptyTBQueue
src/Control/Concurrent/STM/TQueue/Lifted.hs view
@@ -3,6 +3,7 @@     , newTQueueIO     , readTQueueIO     , tryReadTQueueIO+    , flushTQueueIO     , peekTQueueIO     , tryPeekTQueueIO     , writeTQueueIO@@ -27,6 +28,9 @@  tryReadTQueueIO :: MonadIO m => TQueue a -> m (Maybe a) tryReadTQueueIO = atomically . tryReadTQueue++flushTQueueIO :: MonadIO m => TQueue a -> m [a]+flushTQueueIO = atomically . flushTQueue  peekTQueueIO :: MonadIO m => TQueue a -> m a peekTQueueIO = atomically . peekTQueue
src/Control/Concurrent/STM/TSem/Lifted.hs view
@@ -3,14 +3,16 @@     , newTSemIO     , waitTSemIO     , signalTSemIO+    , signalTSemNIO     ) where +import Numeric.Natural (Natural) import Control.Concurrent.STM.TSem as All import Internal  ---------------------------------------------------------------------- -newTSemIO :: MonadIO m => Int -> m TSem+newTSemIO :: MonadIO m => Integer -> m TSem newTSemIO = atomically . newTSem  waitTSemIO :: MonadIO m => TSem -> m ()@@ -19,3 +21,5 @@ signalTSemIO :: MonadIO m => TSem -> m () signalTSemIO = atomically . signalTSem +signalTSemNIO :: MonadIO m => Natural -> TSem -> m ()+signalTSemNIO = atomically .: signalTSemN
src/Control/Concurrent/STM/TVar/Lifted.hs view
@@ -5,6 +5,7 @@     , writeTVarIO     , modifyTVarIO     , modifyTVarIO'+    , stateTVarIO     , swapTVarIO     ) where @@ -31,6 +32,9 @@ -- | Strict version modifyTVarIO' :: MonadIO m => TVar a -> (a -> a) -> m () modifyTVarIO' = atomically .: modifyTVar'++stateTVarIO :: MonadIO m => TVar s -> (s -> (a, s)) -> m a+stateTVarIO = atomically .: stateTVar  swapTVarIO :: MonadIO m => TVar a -> a -> m a swapTVarIO = atomically .: swapTVar
stm-lifted.cabal view
@@ -1,15 +1,14 @@-name:		stm-lifted-version:        0.1.1.0-synopsis:	Software Transactional Memory lifted to MonadIO-license:	BSD3-license-file:	LICENSE+name:           stm-lifted+version:        2.5.0.0+synopsis:       Software Transactional Memory lifted to MonadIO+license:        BSD3+license-file:   LICENSE author:         Maksymilian Owsianny-maintainer:	Maksymilian.Owsianny@gmail.com+maintainer:     Maksymilian.Owsianny@gmail.com bug-reports:    https://github.com/MaxOw/stm-lifted/issues-Copyright:      (c) 2013 Maksymilian Owsianny+Copyright:      (c) 2013-2019 Maksymilian Owsianny category:       Concurrency, MonadIO build-type:     Simple-stability:      Experimental cabal-version:  >= 1.10  description:@@ -25,6 +24,7 @@ library   default-language: Haskell2010   hs-source-dirs: src+  ghc-options: -Wall   exposed-modules:       Control.Concurrent.STM.Lifted     , Control.Concurrent.STM.TVar.Lifted@@ -37,4 +37,4 @@   build-depends:       base          >= 4.5     && < 5     , transformers  >= 0.2     && < 0.6-    , stm           >= 2.4.4.1 && < 3+    , stm           >= 2.5     && < 2.6