Abstracts queues like TBQueue.

For documentation on the constructors, see the module Polysemy.Conc.Data.Queue.

import Polysemy.Conc (Queue, QueueResult)
import Polysemy.Conc.Effect.Queue as Queue

prog :: Member (Queue Int) r => Sem r (QueueResult Int)
prog = do
  Queue.write 5
  Queue.write 10
  Queue.read >>= \case
    QueueResult.Success i -> fmap (i +) <$> Queue.read
    r -> pure r

Encodes failure reasons for queues.

For documentation on the constructors, see the module Polysemy.Conc.Data.QueueResult.

import qualified Polysemy.Conc.Data.QueueResult as QueueResult

Interpret Queue with a TBMQueue.

Interpret Queue with a TBQueue.

Variant of interpretQueueListReadOnlyAtomicWith that interprets the AtomicState.

Reinterpret Queue as AtomicState with a list that cannot be written to. Useful for testing.

Variant of interpretQueueListReadOnlyAtomicWith that interprets the State.

Reinterpret Queue as State with a list that cannot be written to. Useful for testing.

Turn a Success into Just.

Read from a Queue repeatedly until it is closed.

When an element is received, call action and recurse.

Read from a Queue repeatedly until it is closed.

When an element is received, call action and recurse if it returns True. When no element is available, evaluate na and recurse if it returns True.

Abstracts an MVar.

For documentation on the constructors, see the module Polysemy.Conc.Effect.Sync.

import Polysemy.Conc (Sync)
import qualified Polysemy.Conc.Effect.Sync as Sync

prog :: Member (Sync Int) r => Sem r Int
prog = do
  Sync.putTry 5
  Sync.takeBlock

An interface to a shared variable (MVar) that can only be read.

Convenience alias.

Interpret Sync with an empty MVar.

Interpret Sync with an MVar containing the specified value.

Run an action with a locally scoped Sync variable.

This avoids a dependency on Embed IO in application logic while still allowing the variable to be scoped.

Interpret Sync for locally scoped use with an empty MVar.

Interpret Sync for locally scoped use with an MVar containing the specified value.

Run SyncRead in terms of Sync.

An exclusive lock or mutex, protecting a region from concurrent access.

Run an action if the lock is available, block otherwise.

Run the second action if the lock is available, or the first action otherwise.

Run an action if the lock is available, skip and return Nothing otherwise.

Run an action if the lock is available, skip otherwise. Return ().

Interpret Lock as a reentrant lock, allowing nested calls to lock unless called from a different thread (as in, async was called in a higher-order action passed to lock.)

Interpret Lock by executing all actions unconditionally.

This effect abstracts over the concept of a quantity semaphore, a concurrency primitive that contains a number of slots that can be acquired and released.

Interpret Semaphore as a QSem.

Interpret Semaphore as a TSem.

A single-use synchronization point that blocks all consumers who called gate until signal is called.

The constructors are exported from Polysemy.Conc.Gate.

Convenience alias for scoped Gate.

Interpret Scoped_ Gate with an MVar ().

Interpret Gate with an MVar.

Abstract the concept of running two programs concurrently, aborting the other when one terminates. Timeout is a simpler variant, where one thread just sleeps for a given interval.

Run both programs concurrently, returning the result of the faster one.

Specialization of race for the case where both actions return the same type, obviating the need for Either.

Run the first action if the second action doesn't finish within the specified interval.

Specialization of timeout for the case where the main action returns the same type as the fallback, obviating the need for Either.

Version of timeout that takes a pure fallback value.

Specialization of timeoutAs for the case where the main action return the same type as the fallback, obviating the need for Either.

Specialization of timeout for unit actions.

Variant of timeout that returns Maybe.

Variant of timeout that calls Stop with the supplied error when the action times out.

Run an action repeatedly until it returns Right or the timout has been exceeded.

Run an action repeatedly until it returns Right or the timout has been exceeded.

If the action failed at least once, the last error will be returned in case of timeout.

Interpret Race in terms of race and timeout. Since this has to pass higher-order thunks as IO arguments, it is interpreted in terms of 'Final IO'.

An event publisher that can be consumed from multiple threads.

Consume events emitted by Events.

Publish one event.

Consume one event emitted by Events.

Create a new scope for Events, causing the nested program to get its own copy of the event stream. To be used with interpretEventsChan.

Create a new scope for Events, causing the nested program to get its own copy of the event stream.

Calls signal before running the argument to ensure that subscribe has finished creating a channel, for use with asynchronous execution.

Create a new scope for Events, causing the nested program to get its own copy of the event stream.

Executes in a new thread, ensuring that the main thread blocks until subscribe has finished creating a channel.

Pull repeatedly from the Events channel, passing the event to the supplied callback. Stop when the action returns False.

Pull repeatedly from the Events channel, passing the event to the supplied callback. Stop when the action returns False.

Signals the caller that the channel was successfully subscribed to using the Gate effect.

Start a new thread that pulls repeatedly from the Events channel, passing the event to the supplied callback and stops when the action returns False.

Pull repeatedly from the Events channel, passing the event to the supplied callback.

Pull repeatedly from the Events channel, passing the event to the supplied callback.

Signals the caller that the channel was successfully subscribed to using the Gate effect.

Start a new thread that pulls repeatedly from the Events channel, passing the event to the supplied callback.

Block until a value matching the predicate has been published to the Events channel.

Return the first value published to the Events channel for which the function produces Just.

Block until the specified value has been published to the Events channel.

Pull repeatedly from Consume, passing the event to the supplied callback. Stop when the action returns False.

Pull repeatedly from Consume, passing the event to the supplied callback.

Block until a value matching the predicate has been returned by Consume.

Return the first value returned by Consume for which the function produces Just.

Block until the specified value has been returned by Consume.

Convenience alias for the consumer effect.

Interpret Events and Consume together by connecting them to the two ends of an unagi channel. Consume is only interpreted in a Scoped manner, ensuring that a new duplicate of the channel is created so that all consumers see all events (from the moment they are connected).

This should be used in conjunction with subscribe:

interpretEventsChan do
  async $ subscribe do
    putStrLn =<< consume
  publish "hello"

Whenever subscribe creates a new scope, this interpreter calls dupChan and passes the duplicate to interpretConsumeChan.

An effect that catches exceptions.

Provides the exact functionality of fromExceptionSem, but pushes the dependency on Final IO to the interpreter, and makes it optional.

Interpret Critical in terms of Final IO.

Interpret Critical by doing nothing.

The scoped masking effect.

The scoped uninterruptible masking effect.

Mark a region as masked. Uses the Scoped_ pattern.

Mark a region as uninterruptibly masked. Uses the Scoped_ pattern.

Restore the previous masking state. Can only be called inside of an action passed to mask or uninterruptibleMask.

Resource type for the scoped Mask effect, wrapping the restore callback passed in by mask.

Interpret Mask in IO.

Interpret UninterruptibleMask in IO.

Interpret Mask by sequencing the action without masking.

Interpret UninterruptibleMask by sequencing the action without masking.

Mark a region as being subject to intervention by a monitoring program. This can mean that a thread is repeatedly checking a condition and cancelling this region when it is unmet. A use case could be checking whether a remote service is available, or whether the system was suspended and resumed. This should be used in a Scoped_ context, like withMonitor.

Mark a region as being subject to intervention by a monitoring program.

Start a region that can contain monitor-intervention regions.

Variant of withMonitor that uses the Restart strategy.

Marker type for the restarting action for Monitor.

Monitor specialized to the Restart action.

Convenience alias for a Scoped_ Monitor.

Interpret Scoped Monitor with the Restart strategy. This takes a check action that may put an MVar when the scoped region should be restarted. The check is executed in a loop, with an interval given in MonitorCheck.

Run Monitor as a no-op.

Check for Monitor that checks every interval whether the difference between the current time and the time at the last check is larger than interval + tolerance. Can be used to detect that the operating system suspended and resumed.

Config for monitorClockSkew.

Smart constructor for ClockSkewConfig that takes arbitrary TimeUnits.

A default basic stack with Final for _polysemy-conc_.

Interprets UninterruptibleMask, Mask and Race in terms of Final IO and runs the entire rest of the stack.

Convenience wrapper around runAtomicStateTVar that creates a new TVar.

Run the first action asynchronously while the second action executes, then cancel the first action. Passes the handle into the action to allow it to await its result.

When cancelling, this variant will wait indefinitely for the thread to be gone.

Run the first action asynchronously while the second action executes, then cancel the first action. Passes the handle into the sync action to allow it to await the async action's result.

When cancelling, this variant will wait for 500ms for the thread to be gone.

Run the first action asynchronously while the second action executes, then cancel the first action. Discards the handle, expecting the async action to either terminate or be cancelled.

When cancelling, this variant will wait for 500ms for the thread to be gone.

Run an action with async, but don't start it right away, so the thread handle can be processed before the action executes.

Takes a callback function that is invoked after spawning the thread. The callback receives the Async handle and a unit action that starts the computation.

This is helpful if the Async has to be stored in state and the same state is written when the action finishes. In that case, the race condition causes the handle to be written over the finished state.

makeRequest = put Nothing

main = scheduleAsync makeRequest  handle start -> do
  put (Just handle)
  start -- now makeRequest is executed

Variant of scheduleAsync that directly interprets the MVar used for signalling.

Run the first action asynchronously while the second action executes, then cancel the first action.

The second action will only start when the first action calls signal.

Passes the handle into the sync action to allow it to await the async action's result.

This can be used to ensure that the async action has acquired its resources before the main action starts.

Run the first action asynchronously while the second action executes, then cancel the first action.

The second action will only start when the first action calls signal.

This can be used to ensure that the async action has acquired its resources before the main action starts.