Control.Monad.Conc.Class

This module captures in a typeclass the interface of concurrency monads.

Deviations: An instance of MonadConc is not required to be an instance of MonadFix, unlike IO. The IORef, MVar, and Ticket types are not required to be instances of Show or Eq, unlike their normal counterparts. The threadCapability, threadWaitRead, threadWaitWrite, threadWaitReadSTM, threadWaitWriteSTM, and mkWeakThreadId functions are not provided. The threadDelay function is not required to delay the thread, merely to yield it. The BlockedIndefinitelyOnMVar (and similar) exceptions are not thrown during testing, so do not rely on them at all.

Documentation

class (Monad m, MonadCatch m, MonadThrow m, MonadMask m, MonadSTM (STM m), Ord (ThreadId m), Show (ThreadId m)) => MonadConc m where

MonadConc is an abstraction over GHC's typical concurrency abstraction. It captures the interface of concurrency monads in terms of how they can operate on shared state and in the presence of exceptions.

Every MonadConc has an associated MonadSTM, transactions of which can be run atomically.

Deriving instances: If you have a newtype wrapper around a type with an existing MonadConc instance, you should be able to derive an instance for your type automatically, in simple cases.

For example:

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE UndecidableInstances #-}

data Env = Env

newtype MyMonad m a = MyMonad { runMyMonad :: ReaderT Env m a }
  deriving (Functor, Applicative, Monad)

deriving instance MonadThrow m => MonadThrow (MyMonad m)
deriving instance MonadCatch m => MonadCatch (MyMonad m)
deriving instance MonadMask  m => MonadMask  (MyMonad m)

deriving instance MonadConc m => MonadConc (MyMonad m)

Do not be put off by the use of UndecidableInstances, it is safe here.

Since: 1.6.0.0

Minimal complete definition

(forkWithUnmask | forkWithUnmaskN), (forkOnWithUnmask | forkOnWithUnmaskN), (forkOSWithUnmask | forkOSWithUnmaskN), isCurrentThreadBound, getNumCapabilities, setNumCapabilities, myThreadId, yield, (newEmptyMVar | newEmptyMVarN), putMVar, tryPutMVar, readMVar, tryReadMVar, takeMVar, tryTakeMVar, (newIORef | newIORefN), atomicModifyIORef, writeIORef, readForCAS, peekTicket', casIORef, modifyIORefCAS, atomically, throwTo

Associated Types

type STM m :: * -> *

The associated MonadSTM for this class.

Since: 1.0.0.0

type MVar m :: * -> *

The mutable reference type, like MVars. This may contain one value at a time, attempting to read or take from an "empty" MVar will block until it is full, and attempting to put to a "full" MVar will block until it is empty.

Since: 1.0.0.0

type IORef m :: * -> *

The mutable non-blocking reference type. These may suffer from relaxed memory effects if functions outside the set newIORef, readIORef, atomicModifyIORef, and atomicWriteIORef are used.

Since: 1.6.0.0

type Ticket m :: * -> *

When performing compare-and-swap operations on IORefs, a Ticket is a proof that a thread observed a specific previous value.

Since: 1.0.0.0

type ThreadId m :: *

An abstract handle to a thread.

Since: 1.0.0.0

Methods

forkWithUnmask :: ((forall a. m a -> m a) -> m ()) -> m (ThreadId m)

Like fork, but the child thread is passed a function that can be used to unmask asynchronous exceptions. This function should not be used within a mask or uninterruptibleMask.

forkWithUnmask = forkWithUnmaskN ""

Since: 1.0.0.0

forkWithUnmaskN :: String -> ((forall a. m a -> m a) -> m ()) -> m (ThreadId m)

Like forkWithUnmask, but the thread is given a name which may be used to present more useful debugging information.

forkWithUnmaskN _ = forkWithUnmask

Since: 1.0.0.0

forkOnWithUnmask :: Int -> ((forall a. m a -> m a) -> m ()) -> m (ThreadId m)

Like forkWithUnmask, but the child thread is pinned to the given CPU, as with forkOn.

forkOnWithUnmask = forkOnWithUnmaskN ""

Since: 1.0.0.0

forkOnWithUnmaskN :: String -> Int -> ((forall a. m a -> m a) -> m ()) -> m (ThreadId m)

Like forkWithUnmaskN, but the child thread is pinned to the given CPU, as with forkOn.

forkOnWithUnmaskN _ = forkOnWithUnmask

Since: 1.0.0.0

forkOSWithUnmask :: ((forall a. m a -> m a) -> m ()) -> m (ThreadId m)

Like forkOS, but the child thread is passed a function that can be used to unmask asynchronous exceptions. This function should not be used within a mask or uninterruptibleMask.

forkOSWithUnmask = forkOSWithUnmaskN ""

Since: 1.5.0.0

forkOSWithUnmaskN :: String -> ((forall a. m a -> m a) -> m ()) -> m (ThreadId m)

Like forkOSWithUnmask, but the thread is given a name which may be used to present more useful debugging information.

forkOSWithUnmaskN _ = forkOSWithUnmask

Since: 1.5.0.0

isCurrentThreadBound :: m Bool

Returns True if the calling thread is bound, that is, if it is safe to use foreign libraries that rely on thread-local state from the calling thread.

This will always be false if your program is not compiled with the threaded runtime.

Since: 1.3.0.0

getNumCapabilities :: m Int

Get the number of Haskell threads that can run simultaneously.

Since: 1.0.0.0

setNumCapabilities :: Int -> m ()

Set the number of Haskell threads that can run simultaneously.

Since: 1.0.0.0

myThreadId :: m (ThreadId m)

Get the ThreadId of the current thread.

Since: 1.0.0.0

yield :: m ()

Allows a context-switch to any other unblocked thread (if any).

Since: 1.0.0.0

threadDelay :: Int -> m ()

Yields the current thread, and optionally suspends the current thread for a given number of microseconds.

If suspended, there is no guarantee that the thread will be rescheduled promptly when the delay has expired, but the thread will never continue to run earlier than specified.

threadDelay _ = yield

Since: 1.0.0.0

newEmptyMVar :: m (MVar m a)

Create a new empty MVar.

newEmptyMVar = newEmptyMVarN ""

Since: 1.0.0.0

newEmptyMVarN :: String -> m (MVar m a)

Create a new empty MVar, but it is given a name which may be used to present more useful debugging information.

newEmptyMVarN _ = newEmptyMVar

Since: 1.0.0.0

putMVar :: MVar m a -> a -> m ()

Put a value into a MVar. If there is already a value there, this will block until that value has been taken, at which point the value will be stored.

Since: 1.0.0.0

tryPutMVar :: MVar m a -> a -> m Bool

Attempt to put a value in a MVar non-blockingly, returning True (and filling the MVar) if there was nothing there, otherwise returning False.

Since: 1.0.0.0

readMVar :: MVar m a -> m a

Block until a value is present in the MVar, and then return it. This does not "remove" the value, multiple reads are possible.

Since: 1.0.0.0

tryReadMVar :: MVar m a -> m (Maybe a)

Attempt to read a value from a MVar non-blockingly, returning a Just if there is something there, otherwise returning Nothing. As with readMVar, this does not "remove" the value.

Since: 1.1.0.0

takeMVar :: MVar m a -> m a

Take a value from a MVar. This "empties" the MVar, allowing a new value to be put in. This will block if there is no value in the MVar already, until one has been put.

Since: 1.0.0.0

tryTakeMVar :: MVar m a -> m (Maybe a)

Attempt to take a value from a MVar non-blockingly, returning a Just (and emptying the MVar) if there was something there, otherwise returning Nothing.

Since: 1.0.0.0

newIORef :: a -> m (IORef m a)

Create a new reference.

newIORef = newIORefN ""

Since: 1.6.0.0

newIORefN :: String -> a -> m (IORef m a)

Create a new reference, but it is given a name which may be used to present more useful debugging information.

newIORefN _ = newIORef

Since: 1.6.0.0

readIORef :: IORef m a -> m a

Read the current value stored in a reference.

readIORef ioref = readForCAS ioref >>= peekTicket

Since: 1.6.0.0

atomicModifyIORef :: IORef m a -> (a -> (a, b)) -> m b

Atomically modify the value stored in a reference. This imposes a full memory barrier.

Since: 1.6.0.0

writeIORef :: IORef m a -> a -> m ()

Write a new value into an IORef, without imposing a memory barrier. This means that relaxed memory effects can be observed.

Since: 1.6.0.0

atomicWriteIORef :: IORef m a -> a -> m ()

Replace the value stored in a reference, with the barrier-to-reordering property that atomicModifyIORef has.

atomicWriteIORef r a = atomicModifyIORef r $ const (a, ())

Since: 1.6.0.0

readForCAS :: IORef m a -> m (Ticket m a)

Read the current value stored in a reference, returning a Ticket, for use in future compare-and-swap operations.

Since: 1.6.0.0

peekTicket' :: Proxy m -> Ticket m a -> a

Extract the actual Haskell value from a Ticket.

The Proxy m is to determine the m in the Ticket type.

Since: 1.4.0.0

casIORef :: IORef m a -> Ticket m a -> a -> m (Bool, Ticket m a)

Perform a machine-level compare-and-swap (CAS) operation on a IORef. Returns an indication of success and a Ticket for the most current value in the IORef.

This is strict in the "new" value argument.

Since: 1.6.0.0

modifyIORefCAS :: IORef m a -> (a -> (a, b)) -> m b

A replacement for atomicModifyIORef using a compare-and-swap.

This is strict in the "new" value argument.

Since: 1.6.0.0

modifyIORefCAS_ :: IORef m a -> (a -> a) -> m ()

A variant of modifyIORefCAS which doesn't return a result.

modifyIORefCAS_ ioref f = modifyIORefCAS ioref (\a -> (f a, ()))

Since: 1.6.0.0

atomically :: STM m a -> m a

Perform an STM transaction atomically.

Since: 1.0.0.0

readTVarConc :: TVar (STM m) a -> m a

Read the current value stored in a TVar. This may be implemented differently for speed.

readTVarConc = atomically . readTVar

Since: 1.0.0.0

throwTo :: Exception e => ThreadId m -> e -> m ()

Throw an exception to the target thread. This blocks until the exception is delivered, and it is just as if the target thread had raised it with throw. This can interrupt a blocked action.

Since: 1.0.0.0

Instances

MonadConc IO

Since: 1.0.0.0

Defined in Control.Monad.Conc.Class

Associated Types

type STM IO :: Type -> Type

type MVar IO :: Type -> Type

type IORef IO :: Type -> Type

type Ticket IO :: Type -> Type

type ThreadId IO :: Type

Methods

forkWithUnmask :: ((forall a. IO a -> IO a) -> IO ()) -> IO (ThreadId IO)

forkWithUnmaskN :: String -> ((forall a. IO a -> IO a) -> IO ()) -> IO (ThreadId IO)

forkOnWithUnmask :: Int -> ((forall a. IO a -> IO a) -> IO ()) -> IO (ThreadId IO)

forkOnWithUnmaskN :: String -> Int -> ((forall a. IO a -> IO a) -> IO ()) -> IO (ThreadId IO)

forkOSWithUnmask :: ((forall a. IO a -> IO a) -> IO ()) -> IO (ThreadId IO)

forkOSWithUnmaskN :: String -> ((forall a. IO a -> IO a) -> IO ()) -> IO (ThreadId IO)

isCurrentThreadBound :: IO Bool

getNumCapabilities :: IO Int

setNumCapabilities :: Int -> IO ()

myThreadId :: IO (ThreadId IO)

yield :: IO ()

threadDelay :: Int -> IO ()

newEmptyMVar :: IO (MVar IO a)

newEmptyMVarN :: String -> IO (MVar IO a)

putMVar :: MVar IO a -> a -> IO ()

tryPutMVar :: MVar IO a -> a -> IO Bool

readMVar :: MVar IO a -> IO a

tryReadMVar :: MVar IO a -> IO (Maybe a)

takeMVar :: MVar IO a -> IO a

tryTakeMVar :: MVar IO a -> IO (Maybe a)

newIORef :: a -> IO (IORef IO a)

newIORefN :: String -> a -> IO (IORef IO a)

readIORef :: IORef IO a -> IO a

atomicModifyIORef :: IORef IO a -> (a -> (a, b)) -> IO b

writeIORef :: IORef IO a -> a -> IO ()

atomicWriteIORef :: IORef IO a -> a -> IO ()

readForCAS :: IORef IO a -> IO (Ticket IO a)

peekTicket' :: Proxy IO -> Ticket IO a -> a

casIORef :: IORef IO a -> Ticket IO a -> a -> IO (Bool, Ticket IO a)

modifyIORefCAS :: IORef IO a -> (a -> (a, b)) -> IO b

modifyIORefCAS_ :: IORef IO a -> (a -> a) -> IO ()

atomically :: STM IO a -> IO a

readTVarConc :: TVar (STM IO) a -> IO a

throwTo :: Exception e => ThreadId IO -> e -> IO ()

(MonadConc m, Monoid w) => MonadConc (WriterT w m)

New threads inherit the writer state of their parent, but do not communicate results back.

Since: 1.0.0.0

Defined in Control.Monad.Conc.Class

Associated Types

type STM (WriterT w m) :: Type -> Type

type MVar (WriterT w m) :: Type -> Type

type IORef (WriterT w m) :: Type -> Type

type Ticket (WriterT w m) :: Type -> Type

type ThreadId (WriterT w m) :: Type

Methods

forkWithUnmask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

forkWithUnmaskN :: String -> ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

forkOnWithUnmask :: Int -> ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

forkOnWithUnmaskN :: String -> Int -> ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

forkOSWithUnmask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

forkOSWithUnmaskN :: String -> ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

isCurrentThreadBound :: WriterT w m Bool

getNumCapabilities :: WriterT w m Int

setNumCapabilities :: Int -> WriterT w m ()

myThreadId :: WriterT w m (ThreadId (WriterT w m))

yield :: WriterT w m ()

threadDelay :: Int -> WriterT w m ()

newEmptyMVar :: WriterT w m (MVar (WriterT w m) a)

newEmptyMVarN :: String -> WriterT w m (MVar (WriterT w m) a)

putMVar :: MVar (WriterT w m) a -> a -> WriterT w m ()

tryPutMVar :: MVar (WriterT w m) a -> a -> WriterT w m Bool

readMVar :: MVar (WriterT w m) a -> WriterT w m a

tryReadMVar :: MVar (WriterT w m) a -> WriterT w m (Maybe a)

takeMVar :: MVar (WriterT w m) a -> WriterT w m a

tryTakeMVar :: MVar (WriterT w m) a -> WriterT w m (Maybe a)

newIORef :: a -> WriterT w m (IORef (WriterT w m) a)

newIORefN :: String -> a -> WriterT w m (IORef (WriterT w m) a)

readIORef :: IORef (WriterT w m) a -> WriterT w m a

atomicModifyIORef :: IORef (WriterT w m) a -> (a -> (a, b)) -> WriterT w m b

writeIORef :: IORef (WriterT w m) a -> a -> WriterT w m ()

atomicWriteIORef :: IORef (WriterT w m) a -> a -> WriterT w m ()

readForCAS :: IORef (WriterT w m) a -> WriterT w m (Ticket (WriterT w m) a)

peekTicket' :: Proxy (WriterT w m) -> Ticket (WriterT w m) a -> a

casIORef :: IORef (WriterT w m) a -> Ticket (WriterT w m) a -> a -> WriterT w m (Bool, Ticket (WriterT w m) a)

modifyIORefCAS :: IORef (WriterT w m) a -> (a -> (a, b)) -> WriterT w m b

modifyIORefCAS_ :: IORef (WriterT w m) a -> (a -> a) -> WriterT w m ()

atomically :: STM (WriterT w m) a -> WriterT w m a

readTVarConc :: TVar (STM (WriterT w m)) a -> WriterT w m a

throwTo :: Exception e => ThreadId (WriterT w m) -> e -> WriterT w m ()

MonadConc m => MonadConc (StateT s m)

New threads inherit the state of their parent, but do not communicate results back.

Since: 1.0.0.0

Defined in Control.Monad.Conc.Class

Associated Types

type STM (StateT s m) :: Type -> Type

type MVar (StateT s m) :: Type -> Type

type IORef (StateT s m) :: Type -> Type

type Ticket (StateT s m) :: Type -> Type

type ThreadId (StateT s m) :: Type

Methods

forkWithUnmask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

forkWithUnmaskN :: String -> ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

forkOnWithUnmask :: Int -> ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

forkOnWithUnmaskN :: String -> Int -> ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

forkOSWithUnmask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

forkOSWithUnmaskN :: String -> ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

isCurrentThreadBound :: StateT s m Bool

getNumCapabilities :: StateT s m Int

setNumCapabilities :: Int -> StateT s m ()

myThreadId :: StateT s m (ThreadId (StateT s m))

yield :: StateT s m ()

threadDelay :: Int -> StateT s m ()

newEmptyMVar :: StateT s m (MVar (StateT s m) a)

newEmptyMVarN :: String -> StateT s m (MVar (StateT s m) a)

putMVar :: MVar (StateT s m) a -> a -> StateT s m ()

tryPutMVar :: MVar (StateT s m) a -> a -> StateT s m Bool

readMVar :: MVar (StateT s m) a -> StateT s m a

tryReadMVar :: MVar (StateT s m) a -> StateT s m (Maybe a)

takeMVar :: MVar (StateT s m) a -> StateT s m a

tryTakeMVar :: MVar (StateT s m) a -> StateT s m (Maybe a)

newIORef :: a -> StateT s m (IORef (StateT s m) a)

newIORefN :: String -> a -> StateT s m (IORef (StateT s m) a)

readIORef :: IORef (StateT s m) a -> StateT s m a

atomicModifyIORef :: IORef (StateT s m) a -> (a -> (a, b)) -> StateT s m b

writeIORef :: IORef (StateT s m) a -> a -> StateT s m ()

atomicWriteIORef :: IORef (StateT s m) a -> a -> StateT s m ()

readForCAS :: IORef (StateT s m) a -> StateT s m (Ticket (StateT s m) a)

peekTicket' :: Proxy (StateT s m) -> Ticket (StateT s m) a -> a

casIORef :: IORef (StateT s m) a -> Ticket (StateT s m) a -> a -> StateT s m (Bool, Ticket (StateT s m) a)

modifyIORefCAS :: IORef (StateT s m) a -> (a -> (a, b)) -> StateT s m b

modifyIORefCAS_ :: IORef (StateT s m) a -> (a -> a) -> StateT s m ()

atomically :: STM (StateT s m) a -> StateT s m a

readTVarConc :: TVar (STM (StateT s m)) a -> StateT s m a

throwTo :: Exception e => ThreadId (StateT s m) -> e -> StateT s m ()

MonadConc m => MonadConc (IdentityT m)

Since: 1.0.0.0

Defined in Control.Monad.Conc.Class

Associated Types

type STM (IdentityT m) :: Type -> Type

type MVar (IdentityT m) :: Type -> Type

type IORef (IdentityT m) :: Type -> Type

type Ticket (IdentityT m) :: Type -> Type

type ThreadId (IdentityT m) :: Type

Methods

forkWithUnmask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m ()) -> IdentityT m (ThreadId (IdentityT m))

forkWithUnmaskN :: String -> ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m ()) -> IdentityT m (ThreadId (IdentityT m))

forkOnWithUnmask :: Int -> ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m ()) -> IdentityT m (ThreadId (IdentityT m))

forkOnWithUnmaskN :: String -> Int -> ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m ()) -> IdentityT m (ThreadId (IdentityT m))

forkOSWithUnmask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m ()) -> IdentityT m (ThreadId (IdentityT m))

forkOSWithUnmaskN :: String -> ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m ()) -> IdentityT m (ThreadId (IdentityT m))

isCurrentThreadBound :: IdentityT m Bool

getNumCapabilities :: IdentityT m Int

setNumCapabilities :: Int -> IdentityT m ()

myThreadId :: IdentityT m (ThreadId (IdentityT m))

yield :: IdentityT m ()

threadDelay :: Int -> IdentityT m ()

newEmptyMVar :: IdentityT m (MVar (IdentityT m) a)

newEmptyMVarN :: String -> IdentityT m (MVar (IdentityT m) a)

putMVar :: MVar (IdentityT m) a -> a -> IdentityT m ()

tryPutMVar :: MVar (IdentityT m) a -> a -> IdentityT m Bool

readMVar :: MVar (IdentityT m) a -> IdentityT m a

tryReadMVar :: MVar (IdentityT m) a -> IdentityT m (Maybe a)

takeMVar :: MVar (IdentityT m) a -> IdentityT m a

tryTakeMVar :: MVar (IdentityT m) a -> IdentityT m (Maybe a)

newIORef :: a -> IdentityT m (IORef (IdentityT m) a)

newIORefN :: String -> a -> IdentityT m (IORef (IdentityT m) a)

readIORef :: IORef (IdentityT m) a -> IdentityT m a

atomicModifyIORef :: IORef (IdentityT m) a -> (a -> (a, b)) -> IdentityT m b

writeIORef :: IORef (IdentityT m) a -> a -> IdentityT m ()

atomicWriteIORef :: IORef (IdentityT m) a -> a -> IdentityT m ()

readForCAS :: IORef (IdentityT m) a -> IdentityT m (Ticket (IdentityT m) a)

peekTicket' :: Proxy (IdentityT m) -> Ticket (IdentityT m) a -> a

casIORef :: IORef (IdentityT m) a -> Ticket (IdentityT m) a -> a -> IdentityT m (Bool, Ticket (IdentityT m) a)

modifyIORefCAS :: IORef (IdentityT m) a -> (a -> (a, b)) -> IdentityT m b

modifyIORefCAS_ :: IORef (IdentityT m) a -> (a -> a) -> IdentityT m ()

atomically :: STM (IdentityT m) a -> IdentityT m a

readTVarConc :: TVar (STM (IdentityT m)) a -> IdentityT m a

throwTo :: Exception e => ThreadId (IdentityT m) -> e -> IdentityT m ()

MonadConc m => MonadConc (StateT s m)

New threads inherit the state of their parent, but do not communicate results back.

Since: 1.0.0.0

Defined in Control.Monad.Conc.Class

Associated Types

type STM (StateT s m) :: Type -> Type

type MVar (StateT s m) :: Type -> Type

type IORef (StateT s m) :: Type -> Type

type Ticket (StateT s m) :: Type -> Type

type ThreadId (StateT s m) :: Type

Methods

forkWithUnmask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

forkWithUnmaskN :: String -> ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

forkOnWithUnmask :: Int -> ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

forkOnWithUnmaskN :: String -> Int -> ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

forkOSWithUnmask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

forkOSWithUnmaskN :: String -> ((forall a. StateT s m a -> StateT s m a) -> StateT s m ()) -> StateT s m (ThreadId (StateT s m))

isCurrentThreadBound :: StateT s m Bool

getNumCapabilities :: StateT s m Int

setNumCapabilities :: Int -> StateT s m ()

myThreadId :: StateT s m (ThreadId (StateT s m))

yield :: StateT s m ()

threadDelay :: Int -> StateT s m ()

newEmptyMVar :: StateT s m (MVar (StateT s m) a)

newEmptyMVarN :: String -> StateT s m (MVar (StateT s m) a)

putMVar :: MVar (StateT s m) a -> a -> StateT s m ()

tryPutMVar :: MVar (StateT s m) a -> a -> StateT s m Bool

readMVar :: MVar (StateT s m) a -> StateT s m a

tryReadMVar :: MVar (StateT s m) a -> StateT s m (Maybe a)

takeMVar :: MVar (StateT s m) a -> StateT s m a

tryTakeMVar :: MVar (StateT s m) a -> StateT s m (Maybe a)

newIORef :: a -> StateT s m (IORef (StateT s m) a)

newIORefN :: String -> a -> StateT s m (IORef (StateT s m) a)

readIORef :: IORef (StateT s m) a -> StateT s m a

atomicModifyIORef :: IORef (StateT s m) a -> (a -> (a, b)) -> StateT s m b

writeIORef :: IORef (StateT s m) a -> a -> StateT s m ()

atomicWriteIORef :: IORef (StateT s m) a -> a -> StateT s m ()

readForCAS :: IORef (StateT s m) a -> StateT s m (Ticket (StateT s m) a)

peekTicket' :: Proxy (StateT s m) -> Ticket (StateT s m) a -> a

casIORef :: IORef (StateT s m) a -> Ticket (StateT s m) a -> a -> StateT s m (Bool, Ticket (StateT s m) a)

modifyIORefCAS :: IORef (StateT s m) a -> (a -> (a, b)) -> StateT s m b

modifyIORefCAS_ :: IORef (StateT s m) a -> (a -> a) -> StateT s m ()

atomically :: STM (StateT s m) a -> StateT s m a

readTVarConc :: TVar (STM (StateT s m)) a -> StateT s m a

throwTo :: Exception e => ThreadId (StateT s m) -> e -> StateT s m ()

(MonadConc m, Monoid w) => MonadConc (WriterT w m)

New threads inherit the writer state of their parent, but do not communicate results back.

Since: 1.0.0.0

Defined in Control.Monad.Conc.Class

Associated Types

type STM (WriterT w m) :: Type -> Type

type MVar (WriterT w m) :: Type -> Type

type IORef (WriterT w m) :: Type -> Type

type Ticket (WriterT w m) :: Type -> Type

type ThreadId (WriterT w m) :: Type

Methods

forkWithUnmask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

forkWithUnmaskN :: String -> ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

forkOnWithUnmask :: Int -> ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

forkOnWithUnmaskN :: String -> Int -> ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

forkOSWithUnmask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

forkOSWithUnmaskN :: String -> ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m ()) -> WriterT w m (ThreadId (WriterT w m))

isCurrentThreadBound :: WriterT w m Bool

getNumCapabilities :: WriterT w m Int

setNumCapabilities :: Int -> WriterT w m ()

myThreadId :: WriterT w m (ThreadId (WriterT w m))

yield :: WriterT w m ()

threadDelay :: Int -> WriterT w m ()

newEmptyMVar :: WriterT w m (MVar (WriterT w m) a)

newEmptyMVarN :: String -> WriterT w m (MVar (WriterT w m) a)

putMVar :: MVar (WriterT w m) a -> a -> WriterT w m ()

tryPutMVar :: MVar (WriterT w m) a -> a -> WriterT w m Bool

readMVar :: MVar (WriterT w m) a -> WriterT w m a

tryReadMVar :: MVar (WriterT w m) a -> WriterT w m (Maybe a)

takeMVar :: MVar (WriterT w m) a -> WriterT w m a

tryTakeMVar :: MVar (WriterT w m) a -> WriterT w m (Maybe a)

newIORef :: a -> WriterT w m (IORef (WriterT w m) a)

newIORefN :: String -> a -> WriterT w m (IORef (WriterT w m) a)

readIORef :: IORef (WriterT w m) a -> WriterT w m a

atomicModifyIORef :: IORef (WriterT w m) a -> (a -> (a, b)) -> WriterT w m b

writeIORef :: IORef (WriterT w m) a -> a -> WriterT w m ()

atomicWriteIORef :: IORef (WriterT w m) a -> a -> WriterT w m ()

readForCAS :: IORef (WriterT w m) a -> WriterT w m (Ticket (WriterT w m) a)

peekTicket' :: Proxy (WriterT w m) -> Ticket (WriterT w m) a -> a

casIORef :: IORef (WriterT w m) a -> Ticket (WriterT w m) a -> a -> WriterT w m (Bool, Ticket (WriterT w m) a)

modifyIORefCAS :: IORef (WriterT w m) a -> (a -> (a, b)) -> WriterT w m b

modifyIORefCAS_ :: IORef (WriterT w m) a -> (a -> a) -> WriterT w m ()

atomically :: STM (WriterT w m) a -> WriterT w m a

readTVarConc :: TVar (STM (WriterT w m)) a -> WriterT w m a

throwTo :: Exception e => ThreadId (WriterT w m) -> e -> WriterT w m ()

MonadConc m => MonadConc (IsConc m)

Defined in Control.Monad.Conc.Class

Associated Types

type STM (IsConc m) :: Type -> Type

type MVar (IsConc m) :: Type -> Type

type IORef (IsConc m) :: Type -> Type

type Ticket (IsConc m) :: Type -> Type

type ThreadId (IsConc m) :: Type

Methods

forkWithUnmask :: ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

forkWithUnmaskN :: String -> ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

forkOnWithUnmask :: Int -> ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

forkOnWithUnmaskN :: String -> Int -> ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

forkOSWithUnmask :: ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

forkOSWithUnmaskN :: String -> ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

isCurrentThreadBound :: IsConc m Bool

getNumCapabilities :: IsConc m Int

setNumCapabilities :: Int -> IsConc m ()

myThreadId :: IsConc m (ThreadId (IsConc m))

yield :: IsConc m ()

threadDelay :: Int -> IsConc m ()

newEmptyMVar :: IsConc m (MVar (IsConc m) a)

newEmptyMVarN :: String -> IsConc m (MVar (IsConc m) a)

putMVar :: MVar (IsConc m) a -> a -> IsConc m ()

tryPutMVar :: MVar (IsConc m) a -> a -> IsConc m Bool

readMVar :: MVar (IsConc m) a -> IsConc m a

tryReadMVar :: MVar (IsConc m) a -> IsConc m (Maybe a)

takeMVar :: MVar (IsConc m) a -> IsConc m a

tryTakeMVar :: MVar (IsConc m) a -> IsConc m (Maybe a)

newIORef :: a -> IsConc m (IORef (IsConc m) a)

newIORefN :: String -> a -> IsConc m (IORef (IsConc m) a)

readIORef :: IORef (IsConc m) a -> IsConc m a

atomicModifyIORef :: IORef (IsConc m) a -> (a -> (a, b)) -> IsConc m b

writeIORef :: IORef (IsConc m) a -> a -> IsConc m ()

atomicWriteIORef :: IORef (IsConc m) a -> a -> IsConc m ()

readForCAS :: IORef (IsConc m) a -> IsConc m (Ticket (IsConc m) a)

peekTicket' :: Proxy (IsConc m) -> Ticket (IsConc m) a -> a

casIORef :: IORef (IsConc m) a -> Ticket (IsConc m) a -> a -> IsConc m (Bool, Ticket (IsConc m) a)

modifyIORefCAS :: IORef (IsConc m) a -> (a -> (a, b)) -> IsConc m b

modifyIORefCAS_ :: IORef (IsConc m) a -> (a -> a) -> IsConc m ()

atomically :: STM (IsConc m) a -> IsConc m a

readTVarConc :: TVar (STM (IsConc m)) a -> IsConc m a

throwTo :: Exception e => ThreadId (IsConc m) -> e -> IsConc m ()

MonadConc m => MonadConc (ReaderT r m)

New threads inherit the reader state of their parent, but do not communicate results back.

Since: 1.0.0.0

Defined in Control.Monad.Conc.Class

Associated Types

type STM (ReaderT r m) :: Type -> Type

type MVar (ReaderT r m) :: Type -> Type

type IORef (ReaderT r m) :: Type -> Type

type Ticket (ReaderT r m) :: Type -> Type

type ThreadId (ReaderT r m) :: Type

Methods

forkWithUnmask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m ()) -> ReaderT r m (ThreadId (ReaderT r m))

forkWithUnmaskN :: String -> ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m ()) -> ReaderT r m (ThreadId (ReaderT r m))

forkOnWithUnmask :: Int -> ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m ()) -> ReaderT r m (ThreadId (ReaderT r m))

forkOnWithUnmaskN :: String -> Int -> ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m ()) -> ReaderT r m (ThreadId (ReaderT r m))

forkOSWithUnmask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m ()) -> ReaderT r m (ThreadId (ReaderT r m))

forkOSWithUnmaskN :: String -> ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m ()) -> ReaderT r m (ThreadId (ReaderT r m))

isCurrentThreadBound :: ReaderT r m Bool

getNumCapabilities :: ReaderT r m Int

setNumCapabilities :: Int -> ReaderT r m ()

myThreadId :: ReaderT r m (ThreadId (ReaderT r m))

yield :: ReaderT r m ()

threadDelay :: Int -> ReaderT r m ()

newEmptyMVar :: ReaderT r m (MVar (ReaderT r m) a)

newEmptyMVarN :: String -> ReaderT r m (MVar (ReaderT r m) a)

putMVar :: MVar (ReaderT r m) a -> a -> ReaderT r m ()

tryPutMVar :: MVar (ReaderT r m) a -> a -> ReaderT r m Bool

readMVar :: MVar (ReaderT r m) a -> ReaderT r m a

tryReadMVar :: MVar (ReaderT r m) a -> ReaderT r m (Maybe a)

takeMVar :: MVar (ReaderT r m) a -> ReaderT r m a

tryTakeMVar :: MVar (ReaderT r m) a -> ReaderT r m (Maybe a)

newIORef :: a -> ReaderT r m (IORef (ReaderT r m) a)

newIORefN :: String -> a -> ReaderT r m (IORef (ReaderT r m) a)

readIORef :: IORef (ReaderT r m) a -> ReaderT r m a

atomicModifyIORef :: IORef (ReaderT r m) a -> (a -> (a, b)) -> ReaderT r m b

writeIORef :: IORef (ReaderT r m) a -> a -> ReaderT r m ()

atomicWriteIORef :: IORef (ReaderT r m) a -> a -> ReaderT r m ()

readForCAS :: IORef (ReaderT r m) a -> ReaderT r m (Ticket (ReaderT r m) a)

peekTicket' :: Proxy (ReaderT r m) -> Ticket (ReaderT r m) a -> a

casIORef :: IORef (ReaderT r m) a -> Ticket (ReaderT r m) a -> a -> ReaderT r m (Bool, Ticket (ReaderT r m) a)

modifyIORefCAS :: IORef (ReaderT r m) a -> (a -> (a, b)) -> ReaderT r m b

modifyIORefCAS_ :: IORef (ReaderT r m) a -> (a -> a) -> ReaderT r m ()

atomically :: STM (ReaderT r m) a -> ReaderT r m a

readTVarConc :: TVar (STM (ReaderT r m)) a -> ReaderT r m a

throwTo :: Exception e => ThreadId (ReaderT r m) -> e -> ReaderT r m ()

(MonadConc m, Monoid w) => MonadConc (RWST r w s m)

New threads inherit the states of their parent, but do not communicate results back.

Since: 1.0.0.0

Defined in Control.Monad.Conc.Class

Associated Types

type STM (RWST r w s m) :: Type -> Type

type MVar (RWST r w s m) :: Type -> Type

type IORef (RWST r w s m) :: Type -> Type

type Ticket (RWST r w s m) :: Type -> Type

type ThreadId (RWST r w s m) :: Type

Methods

forkWithUnmask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

forkWithUnmaskN :: String -> ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

forkOnWithUnmask :: Int -> ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

forkOnWithUnmaskN :: String -> Int -> ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

forkOSWithUnmask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

forkOSWithUnmaskN :: String -> ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

isCurrentThreadBound :: RWST r w s m Bool

getNumCapabilities :: RWST r w s m Int

setNumCapabilities :: Int -> RWST r w s m ()

myThreadId :: RWST r w s m (ThreadId (RWST r w s m))

yield :: RWST r w s m ()

threadDelay :: Int -> RWST r w s m ()

newEmptyMVar :: RWST r w s m (MVar (RWST r w s m) a)

newEmptyMVarN :: String -> RWST r w s m (MVar (RWST r w s m) a)

putMVar :: MVar (RWST r w s m) a -> a -> RWST r w s m ()

tryPutMVar :: MVar (RWST r w s m) a -> a -> RWST r w s m Bool

readMVar :: MVar (RWST r w s m) a -> RWST r w s m a

tryReadMVar :: MVar (RWST r w s m) a -> RWST r w s m (Maybe a)

takeMVar :: MVar (RWST r w s m) a -> RWST r w s m a

tryTakeMVar :: MVar (RWST r w s m) a -> RWST r w s m (Maybe a)

newIORef :: a -> RWST r w s m (IORef (RWST r w s m) a)

newIORefN :: String -> a -> RWST r w s m (IORef (RWST r w s m) a)

readIORef :: IORef (RWST r w s m) a -> RWST r w s m a

atomicModifyIORef :: IORef (RWST r w s m) a -> (a -> (a, b)) -> RWST r w s m b

writeIORef :: IORef (RWST r w s m) a -> a -> RWST r w s m ()

atomicWriteIORef :: IORef (RWST r w s m) a -> a -> RWST r w s m ()

readForCAS :: IORef (RWST r w s m) a -> RWST r w s m (Ticket (RWST r w s m) a)

peekTicket' :: Proxy (RWST r w s m) -> Ticket (RWST r w s m) a -> a

casIORef :: IORef (RWST r w s m) a -> Ticket (RWST r w s m) a -> a -> RWST r w s m (Bool, Ticket (RWST r w s m) a)

modifyIORefCAS :: IORef (RWST r w s m) a -> (a -> (a, b)) -> RWST r w s m b

modifyIORefCAS_ :: IORef (RWST r w s m) a -> (a -> a) -> RWST r w s m ()

atomically :: STM (RWST r w s m) a -> RWST r w s m a

readTVarConc :: TVar (STM (RWST r w s m)) a -> RWST r w s m a

throwTo :: Exception e => ThreadId (RWST r w s m) -> e -> RWST r w s m ()

(MonadConc m, Monoid w) => MonadConc (RWST r w s m)

New threads inherit the states of their parent, but do not communicate results back.

Since: 1.0.0.0

Defined in Control.Monad.Conc.Class

Associated Types

type STM (RWST r w s m) :: Type -> Type

type MVar (RWST r w s m) :: Type -> Type

type IORef (RWST r w s m) :: Type -> Type

type Ticket (RWST r w s m) :: Type -> Type

type ThreadId (RWST r w s m) :: Type

Methods

forkWithUnmask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

forkWithUnmaskN :: String -> ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

forkOnWithUnmask :: Int -> ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

forkOnWithUnmaskN :: String -> Int -> ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

forkOSWithUnmask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

forkOSWithUnmaskN :: String -> ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m ()) -> RWST r w s m (ThreadId (RWST r w s m))

isCurrentThreadBound :: RWST r w s m Bool

getNumCapabilities :: RWST r w s m Int

setNumCapabilities :: Int -> RWST r w s m ()

myThreadId :: RWST r w s m (ThreadId (RWST r w s m))

yield :: RWST r w s m ()

threadDelay :: Int -> RWST r w s m ()

newEmptyMVar :: RWST r w s m (MVar (RWST r w s m) a)

newEmptyMVarN :: String -> RWST r w s m (MVar (RWST r w s m) a)

putMVar :: MVar (RWST r w s m) a -> a -> RWST r w s m ()

tryPutMVar :: MVar (RWST r w s m) a -> a -> RWST r w s m Bool

readMVar :: MVar (RWST r w s m) a -> RWST r w s m a

tryReadMVar :: MVar (RWST r w s m) a -> RWST r w s m (Maybe a)

takeMVar :: MVar (RWST r w s m) a -> RWST r w s m a

tryTakeMVar :: MVar (RWST r w s m) a -> RWST r w s m (Maybe a)

newIORef :: a -> RWST r w s m (IORef (RWST r w s m) a)

newIORefN :: String -> a -> RWST r w s m (IORef (RWST r w s m) a)

readIORef :: IORef (RWST r w s m) a -> RWST r w s m a

atomicModifyIORef :: IORef (RWST r w s m) a -> (a -> (a, b)) -> RWST r w s m b

writeIORef :: IORef (RWST r w s m) a -> a -> RWST r w s m ()

atomicWriteIORef :: IORef (RWST r w s m) a -> a -> RWST r w s m ()

readForCAS :: IORef (RWST r w s m) a -> RWST r w s m (Ticket (RWST r w s m) a)

peekTicket' :: Proxy (RWST r w s m) -> Ticket (RWST r w s m) a -> a

casIORef :: IORef (RWST r w s m) a -> Ticket (RWST r w s m) a -> a -> RWST r w s m (Bool, Ticket (RWST r w s m) a)

modifyIORefCAS :: IORef (RWST r w s m) a -> (a -> (a, b)) -> RWST r w s m b

modifyIORefCAS_ :: IORef (RWST r w s m) a -> (a -> a) -> RWST r w s m ()

atomically :: STM (RWST r w s m) a -> RWST r w s m a

readTVarConc :: TVar (STM (RWST r w s m)) a -> RWST r w s m a

throwTo :: Exception e => ThreadId (RWST r w s m) -> e -> RWST r w s m ()

Threads

fork :: MonadConc m => m () -> m (ThreadId m)

Fork a computation to happen concurrently. Communication may happen over MVars.

Since: 1.5.0.0

forkOn :: MonadConc m => Int -> m () -> m (ThreadId m)

Fork a computation to happen on a specific processor. The specified int is the capability number, typically capabilities correspond to physical processors or cores but this is implementation dependent. The int is interpreted modulo to the total number of capabilities as returned by getNumCapabilities.

Since: 1.5.0.0

forkOS :: MonadConc m => m () -> m (ThreadId m)

Fork a computation to happen in a bound thread, which is necessary if you need to call foreign (non-Haskell) libraries that make use of thread-local state, such as OpenGL.

Since: 1.5.0.0

forkFinally :: MonadConc m => m a -> (Either SomeException a -> m ()) -> m (ThreadId m)

Fork a thread and call the supplied function when the thread is about to terminate, with an exception or a returned value. The function is called with asynchronous exceptions masked.

This function is useful for informing the parent when a child terminates, for example.

Since: 1.0.0.0

spawn :: MonadConc m => m a -> m (MVar m a)

Create a concurrent computation for the provided action, and return a MVar which can be used to query the result.

Since: 1.0.0.0

killThread :: MonadConc m => ThreadId m -> m ()

Raise the ThreadKilled exception in the target thread. Note that if the thread is prepared to catch this exception, it won't actually kill it.

Since: 1.0.0.0

Bound threads

Support for multiple operating system threads and bound threads as described below is currently only available in the GHC runtime system if you use the -threaded option when linking.

Other Haskell systems do not currently support multiple operating system threads.

A bound thread is a haskell thread that is bound to an operating system thread. While the bound thread is still scheduled by the Haskell run-time system, the operating system thread takes care of all the foreign calls made by the bound thread.

To a foreign library, the bound thread will look exactly like an ordinary operating system thread created using OS functions like pthread_create or CreateThread.

rtsSupportsBoundThreads :: Bool

True if bound threads are supported. If rtsSupportsBoundThreads is False, isCurrentThreadBound will always return False and both forkOS and runInBoundThread will fail.

runInBoundThread :: MonadConc m => m a -> m a

Run the computation passed as the first argument. If the calling thread is not bound, a bound thread is created temporarily. runInBoundThread doesn't finish until the inner computation finishes.

You can wrap a series of foreign function calls that rely on thread-local state with runInBoundThread so that you can use them without knowing whether the current thread is bound.

Since: 1.3.0.0

runInUnboundThread :: MonadConc m => m a -> m a

Run the computation passed as the first argument. If the calling thread is bound, an unbound thread is created temporarily using fork. runInBoundThread doesn't finish until the inner computation finishes.

Use this function only in the rare case that you have actually observed a performance loss due to the use of bound threads. A program that doesn't need its main thread to be bound and makes heavy use of concurrency (e.g. a web server), might want to wrap its main action in runInUnboundThread.

Note that exceptions which are thrown to the current thread are thrown in turn to the thread that is executing the given computation. This ensures there's always a way of killing the forked thread.

Since: 1.3.0.0

Named Threads

forkN :: MonadConc m => String -> m () -> m (ThreadId m)

Like fork, but the thread is given a name which may be used to present more useful debugging information.

Since: 1.0.0.0

forkOnN :: MonadConc m => String -> Int -> m () -> m (ThreadId m)

Like forkOn, but the thread is given a name which may be used to present more useful debugging information.

Since: 1.0.0.0

forkOSN :: MonadConc m => String -> m () -> m (ThreadId m)

Like forkOS, but the thread is given a name which may be used to present more useful debugging information.

Since: 1.5.0.0

Exceptions

throw :: (MonadConc m, Exception e) => e -> m a

Throw an exception. This will "bubble up" looking for an exception handler capable of dealing with it and, if one is not found, the thread is killed.

Since: 1.0.0.0

catch :: (MonadConc m, Exception e) => m a -> (e -> m a) -> m a

Catch an exception. This is only required to be able to catch exceptions raised by throw, unlike the more general Control.Exception.catch function. If you need to be able to catch all errors, you will have to use IO.

Since: 1.0.0.0

mask :: MonadConc m => ((forall a. m a -> m a) -> m b) -> m b

Executes a computation with asynchronous exceptions masked. That is, any thread which attempts to raise an exception in the current thread with throwTo will be blocked until asynchronous exceptions are unmasked again.

The argument passed to mask is a function that takes as its argument another function, which can be used to restore the prevailing masking state within the context of the masked computation. This function should not be used within an uninterruptibleMask.

Since: 1.0.0.0

mask_ :: MonadMask m => m a -> m a

Like mask, but does not pass a restore action to the argument.

uninterruptibleMask :: MonadConc m => ((forall a. m a -> m a) -> m b) -> m b

Like mask, but the masked computation is not interruptible. THIS SHOULD BE USED WITH GREAT CARE, because if a thread executing in uninterruptibleMask blocks for any reason, then the thread (and possibly the program, if this is the main thread) will be unresponsive and unkillable. This function should only be necessary if you need to mask exceptions around an interruptible operation, and you can guarantee that the interruptible operation will only block for a short period of time. The supplied unmasking function should not be used within a mask.

Since: 1.0.0.0

uninterruptibleMask_ :: MonadMask m => m a -> m a

Like uninterruptibleMask, but does not pass a restore action to the argument.

Mutable State

newMVar :: MonadConc m => a -> m (MVar m a)

Create a new MVar containing a value.

Since: 1.0.0.0

newMVarN :: MonadConc m => String -> a -> m (MVar m a)

Create a new MVar containing a value, but it is given a name which may be used to present more useful debugging information.

Since: 1.0.0.0

cas :: MonadConc m => IORef m a -> a -> m (Bool, a)

Compare-and-swap a value in a IORef, returning an indication of success and the new value.

Since: 1.6.0.0

peekTicket :: forall m a. MonadConc m => Ticket m a -> m a

Extract the actual Haskell value from a Ticket.

This doesn't do do any monadic computation, the m appears in the result type to determine the m in the Ticket type.

Since: 1.0.0.0

Utilities for type shenanigans

data IsConc m a

A value of type IsConc m a can only be constructed if m has a MonadConc instance.

Since: 1.2.2.0

Instances

Monad m => Monad (IsConc m)

Defined in Control.Monad.Conc.Class

Methods

(>>=) :: IsConc m a -> (a -> IsConc m b) -> IsConc m b

(>>) :: IsConc m a -> IsConc m b -> IsConc m b

return :: a -> IsConc m a

fail :: String -> IsConc m a

Functor m => Functor (IsConc m)

Defined in Control.Monad.Conc.Class

Methods

fmap :: (a -> b) -> IsConc m a -> IsConc m b

(<$) :: a -> IsConc m b -> IsConc m a

Applicative m => Applicative (IsConc m)

Defined in Control.Monad.Conc.Class

Methods

pure :: a -> IsConc m a

(<*>) :: IsConc m (a -> b) -> IsConc m a -> IsConc m b

liftA2 :: (a -> b -> c) -> IsConc m a -> IsConc m b -> IsConc m c

(*>) :: IsConc m a -> IsConc m b -> IsConc m b

(<*) :: IsConc m a -> IsConc m b -> IsConc m a

MonadThrow m => MonadThrow (IsConc m)

Defined in Control.Monad.Conc.Class

Methods

throwM :: Exception e => e -> IsConc m a

MonadCatch m => MonadCatch (IsConc m)

Defined in Control.Monad.Conc.Class

Methods

catch :: Exception e => IsConc m a -> (e -> IsConc m a) -> IsConc m a

MonadMask m => MonadMask (IsConc m)

Defined in Control.Monad.Conc.Class

Methods

mask :: ((forall a. IsConc m a -> IsConc m a) -> IsConc m b) -> IsConc m b

uninterruptibleMask :: ((forall a. IsConc m a -> IsConc m a) -> IsConc m b) -> IsConc m b

generalBracket :: IsConc m a -> (a -> ExitCase b -> IsConc m c) -> (a -> IsConc m b) -> IsConc m (b, c)

MonadConc m => MonadConc (IsConc m)

Defined in Control.Monad.Conc.Class

Associated Types

type STM (IsConc m) :: Type -> Type

type MVar (IsConc m) :: Type -> Type

type IORef (IsConc m) :: Type -> Type

type Ticket (IsConc m) :: Type -> Type

type ThreadId (IsConc m) :: Type

Methods

forkWithUnmask :: ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

forkWithUnmaskN :: String -> ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

forkOnWithUnmask :: Int -> ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

forkOnWithUnmaskN :: String -> Int -> ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

forkOSWithUnmask :: ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

forkOSWithUnmaskN :: String -> ((forall a. IsConc m a -> IsConc m a) -> IsConc m ()) -> IsConc m (ThreadId (IsConc m))

isCurrentThreadBound :: IsConc m Bool

getNumCapabilities :: IsConc m Int

setNumCapabilities :: Int -> IsConc m ()

myThreadId :: IsConc m (ThreadId (IsConc m))

yield :: IsConc m ()

threadDelay :: Int -> IsConc m ()

newEmptyMVar :: IsConc m (MVar (IsConc m) a)

newEmptyMVarN :: String -> IsConc m (MVar (IsConc m) a)

putMVar :: MVar (IsConc m) a -> a -> IsConc m ()

tryPutMVar :: MVar (IsConc m) a -> a -> IsConc m Bool

readMVar :: MVar (IsConc m) a -> IsConc m a

tryReadMVar :: MVar (IsConc m) a -> IsConc m (Maybe a)

takeMVar :: MVar (IsConc m) a -> IsConc m a

tryTakeMVar :: MVar (IsConc m) a -> IsConc m (Maybe a)

newIORef :: a -> IsConc m (IORef (IsConc m) a)

newIORefN :: String -> a -> IsConc m (IORef (IsConc m) a)

readIORef :: IORef (IsConc m) a -> IsConc m a

atomicModifyIORef :: IORef (IsConc m) a -> (a -> (a, b)) -> IsConc m b

writeIORef :: IORef (IsConc m) a -> a -> IsConc m ()

atomicWriteIORef :: IORef (IsConc m) a -> a -> IsConc m ()

readForCAS :: IORef (IsConc m) a -> IsConc m (Ticket (IsConc m) a)

peekTicket' :: Proxy (IsConc m) -> Ticket (IsConc m) a -> a

casIORef :: IORef (IsConc m) a -> Ticket (IsConc m) a -> a -> IsConc m (Bool, Ticket (IsConc m) a)

modifyIORefCAS :: IORef (IsConc m) a -> (a -> (a, b)) -> IsConc m b

modifyIORefCAS_ :: IORef (IsConc m) a -> (a -> a) -> IsConc m ()

atomically :: STM (IsConc m) a -> IsConc m a

readTVarConc :: TVar (STM (IsConc m)) a -> IsConc m a

throwTo :: Exception e => ThreadId (IsConc m) -> e -> IsConc m ()

type STM (IsConc m)

Defined in Control.Monad.Conc.Class

type STM (IsConc m) = IsSTM (STM m)

type MVar (IsConc m)

Defined in Control.Monad.Conc.Class

type MVar (IsConc m) = MVar m

type IORef (IsConc m)

Defined in Control.Monad.Conc.Class

type IORef (IsConc m) = IORef m

type Ticket (IsConc m)

Defined in Control.Monad.Conc.Class

type Ticket (IsConc m) = Ticket m

type ThreadId (IsConc m)

Defined in Control.Monad.Conc.Class

type ThreadId (IsConc m) = ThreadId m

toIsConc :: MonadConc m => m a -> IsConc m a

Wrap an m a value inside an IsConc if m has a MonadConc instance.

Since: 1.2.2.0

fromIsConc :: MonadConc m => IsConc m a -> m a

Unwrap an IsConc value.

Since: 1.2.2.0

Utilities for instance writers

liftedF :: (MonadTransControl t, MonadConc m) => (forall x. StT t x -> x) -> (m a -> m b) -> t m a -> t m b

Given a function to remove the transformer-specific state, lift a function invocation.

Since: 1.0.0.0

liftedFork :: (MonadTransControl t, MonadConc m) => (forall x. StT t x -> x) -> (((forall x. m x -> m x) -> m a) -> m b) -> ((forall x. t m x -> t m x) -> t m a) -> t m b

Given a function to remove the transformer-specific state, lift a fork(on)WithUnmask invocation.

Since: 1.0.0.0