Polysemy.Conc

Introduction

This library provides an assortment of tools for concurrency-related tasks:

• STM queues
• MVars
• Racing
• Signal handling

Queues

data Queue d :: Effect

Abstracts queues like TBQueue.

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

import Polysemy.Conc (Queue, QueueResult)
import Polysemy.Conc.Data.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

Instances

type DefiningModule Queue

Defined in Polysemy.Conc.Data.Queue

type DefiningModule Queue = "Polysemy.Conc.Data.Queue"

data QueueResult d

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

Instances

Functor QueueResult

Defined in Polysemy.Conc.Data.QueueResult

Methods

fmap :: (a -> b) -> QueueResult a -> QueueResult b

(<$) :: a -> QueueResult b -> QueueResult a

Eq d => Eq (QueueResult d)

Defined in Polysemy.Conc.Data.QueueResult

Methods

(==) :: QueueResult d -> QueueResult d -> Bool

(/=) :: QueueResult d -> QueueResult d -> Bool

Ord d => Ord (QueueResult d)

Defined in Polysemy.Conc.Data.QueueResult

Methods

compare :: QueueResult d -> QueueResult d -> Ordering

(<) :: QueueResult d -> QueueResult d -> Bool

(<=) :: QueueResult d -> QueueResult d -> Bool

(>) :: QueueResult d -> QueueResult d -> Bool

(>=) :: QueueResult d -> QueueResult d -> Bool

max :: QueueResult d -> QueueResult d -> QueueResult d

min :: QueueResult d -> QueueResult d -> QueueResult d

Show d => Show (QueueResult d)

Defined in Polysemy.Conc.Data.QueueResult

Methods

showsPrec :: Int -> QueueResult d -> ShowS

show :: QueueResult d -> String

showList :: [QueueResult d] -> ShowS

Generic (QueueResult d)

Defined in Polysemy.Conc.Data.QueueResult

Associated Types

type Rep (QueueResult d) :: Type -> Type

Methods

from :: QueueResult d -> Rep (QueueResult d) x

to :: Rep (QueueResult d) x -> QueueResult d

Semigroup d => Semigroup (QueueResult d)

Defined in Polysemy.Conc.Data.QueueResult

Methods

(<>) :: QueueResult d -> QueueResult d -> QueueResult d

sconcat :: NonEmpty (QueueResult d) -> QueueResult d

stimes :: Integral b => b -> QueueResult d -> QueueResult d

Monoid d => Monoid (QueueResult d)

Defined in Polysemy.Conc.Data.QueueResult

Methods

mempty :: QueueResult d

mappend :: QueueResult d -> QueueResult d -> QueueResult d

mconcat :: [QueueResult d] -> QueueResult d

type Rep (QueueResult d)

Defined in Polysemy.Conc.Data.QueueResult

type Rep (QueueResult d) = D1 ('MetaData "QueueResult" "Polysemy.Conc.Data.QueueResult" "polysemy-conc-0.1.0.2-inplace" 'False) (C1 ('MetaCons "Success" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 d)) :+: (C1 ('MetaCons "NotAvailable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Closed" 'PrefixI 'False) (U1 :: Type -> Type)))

resultToMaybe :: QueueResult d -> Maybe d

Turn a Success into Just.

Interpreters

interpretQueueTBM

Arguments

:: forall d r. Members [Resource, Race, Embed IO] r

=> Int

Buffer size

-> InterpreterFor (Queue d) r

Interpret Queue with a TBMQueue.

interpretQueueTB

Arguments

:: forall d r. Members [Race, Embed IO] r

=> Natural

Buffer size

-> InterpreterFor (Queue d) r

Interpret Queue with a TBQueue.

interpretQueueListReadOnlyAtomic :: forall d r. Member (Embed IO) r => [d] -> InterpreterFor (Queue d) r

Variant of interpretQueueListReadOnlyAtomicWith that interprets the AtomicState.

interpretQueueListReadOnlyAtomicWith :: forall d r. Member (AtomicState [d]) r => InterpreterFor (Queue d) r

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

interpretQueueListReadOnlyState :: forall d r. Member (Embed IO) r => [d] -> InterpreterFor (Queue d) r

Variant of interpretQueueListReadOnlyAtomicWith that interprets the State.

interpretQueueListReadOnlyStateWith :: forall d r. Member (State [d]) r => InterpreterFor (Queue d) r

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

MVars

An MVar is abstracted as Sync since it can be used to synchronize threads.

data Sync d :: Effect

Abstracts an MVar.

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

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

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

Instances

type DefiningModule Sync

Defined in Polysemy.Conc.Data.Sync

type DefiningModule Sync = "Polysemy.Conc.Data.Sync"

Interpreters

interpretSync :: forall d r. Members [Race, Embed IO] r => InterpreterFor (Sync d) r

Interpret Sync with an empty MVar.

Racing

Racing works like this:

prog =
 Polysemy.Conc.race (httpRequest "hackage.haskell.org") (readFile "/path/to/file") >>= \case
   Left _ -> putStrLn "hackage was faster"
   Right _ -> putStrLn "file was faster"

When the first thunk finishes, the other will be killed.

data Race :: Effect

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.

Instances

type DefiningModule Race

Defined in Polysemy.Conc.Data.Race

type DefiningModule Race = "Polysemy.Conc.Data.Race"

race :: forall a b r. Member Race r => Sem r a -> Sem r b -> Sem r (Either a b)

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

race_ :: Member Race r => Sem r a -> Sem r a -> Sem r a

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

timeout :: forall a b u r. TimeUnit u => Member Race r => a -> u -> Sem r b -> Sem r (Either a b)

Return the fallback value if the given program doesn't finish within the specified interval.

timeout_ :: TimeUnit u => Member Race r => a -> u -> Sem r a -> Sem r a

Specialization of timeout for the case where the thunk return the same type as the fallback, obviating the need for Either.

Interpreters

interpretRace :: Member (Final IO) r => InterpreterFor Race r

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'.

Signal Handling

data Interrupt :: Effect

The interrupt handler effect allows three kinds of interaction for interrupt signals:

• Execute a callback when a signal is received
• Block a thread until a signal is received
• Kill a thread when a signal is received

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

import qualified Polysemy.Conc.Data.Interrupt as Interrupt

prog = do
  Interrupt.register "task 1" (putStrLn "interrupted")
  Interrupt.killOnQuit $ forever do
   doSomeWork

Instances

type DefiningModule Interrupt

Defined in Polysemy.Conc.Data.Interrupt

type DefiningModule Interrupt = "Polysemy.Conc.Data.Interrupt"

Interpreters

interpretInterrupt :: Members [Critical, Race, Async, Embed IO] r => InterpreterFor Interrupt r

Interpret Interrupt by installing a signal handler.