{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE RankNTypes #-}
module Context.Concurrent
(
forkIO
, forkFinally
, forkIOWithUnmask
, forkOn
, forkOnWithUnmask
, forkOS
, forkOSWithUnmask
, runInBoundThread
, runInUnboundThread
, ThreadId
, myThreadId
, killThread
, throwTo
, getNumCapabilities
, setNumCapabilities
, threadCapability
, yield
, threadDelay
, threadWaitRead
, threadWaitWrite
, threadWaitReadSTM
, threadWaitWriteSTM
, rtsSupportsBoundThreads
, isCurrentThreadBound
, mkWeakThreadId
, module Control.Concurrent.MVar
, module Control.Concurrent.Chan
, module Control.Concurrent.QSem
, module Control.Concurrent.QSemN
) where
import Control.Concurrent
( ThreadId, getNumCapabilities, isCurrentThreadBound, killThread, mkWeakThreadId, myThreadId
, rtsSupportsBoundThreads, setNumCapabilities, threadCapability, threadDelay, threadWaitRead
, threadWaitReadSTM, threadWaitWrite, threadWaitWriteSTM, throwTo, yield
)
import Control.Concurrent.Chan
import Control.Concurrent.MVar
import Control.Concurrent.QSem
import Control.Concurrent.QSemN
import Control.Exception (SomeException)
import Prelude
import qualified Context.Internal as Internal
import qualified Control.Concurrent as Concurrent
import qualified Control.Exception as Exception
forkIO :: IO () -> IO ThreadId
forkIO action = do
Internal.withPropagator \propagate -> do
Concurrent.forkIO $ propagate action
forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
forkFinally action and_then = do
Internal.withPropagator \propagate -> do
Exception.mask \restore -> do
Concurrent.forkIO $ propagate do
Exception.try (restore action) >>= and_then
forkIOWithUnmask :: ((forall a. IO a -> IO a) -> IO ()) -> IO ThreadId
forkIOWithUnmask io = do
Internal.withPropagator \propagate -> do
Concurrent.forkIOWithUnmask \restore -> do
propagate $ io restore
forkOn :: Int -> IO () -> IO ThreadId
forkOn cpu action = do
Internal.withPropagator \propagate -> do
Concurrent.forkOn cpu $ propagate action
forkOnWithUnmask :: Int -> ((forall a. IO a -> IO a) -> IO ()) -> IO ThreadId
forkOnWithUnmask cpu io = do
Internal.withPropagator \propagate -> do
Concurrent.forkOnWithUnmask cpu \restore -> do
propagate $ io restore
forkOS :: IO () -> IO ThreadId
forkOS action = do
Internal.withPropagator \propagate -> do
Concurrent.forkOS $ propagate action
forkOSWithUnmask :: ((forall a. IO a -> IO a) -> IO ()) -> IO ThreadId
forkOSWithUnmask io = do
Internal.withPropagator \propagate -> do
Concurrent.forkOSWithUnmask \restore -> do
propagate $ io restore
runInBoundThread :: IO a -> IO a
runInBoundThread action =
Internal.withPropagator \propagate -> do
Concurrent.runInBoundThread $ propagate action
runInUnboundThread :: IO a -> IO a
runInUnboundThread action =
Internal.withPropagator \propagate -> do
Concurrent.runInUnboundThread $ propagate action