Util.Sink

Very primitive concurrency, this implements a sink, which passes messages along until the receiver is no longer interested.

Documentation

class HasInvalidate source where

The HasInvalidate class represents information sources which can be told "No more, I'm not interested."

Minimal complete definition

invalidate

Methods

invalidate :: source -> IO ()

Instances

HasInvalidate SinkID

Defined in Util.Sink

Methods

invalidate :: SinkID -> IO ()

HasInvalidate (Sink x)

Or we can do so with HasInvalidate

Defined in Util.Sink

Methods

invalidate :: Sink x -> IO ()

data SinkID

Instances

Eq SinkID

Defined in Util.Sink

Methods

(==) :: SinkID -> SinkID -> Bool

(/=) :: SinkID -> SinkID -> Bool

Ord SinkID

Defined in Util.Sink

Methods

compare :: SinkID -> SinkID -> Ordering

(<) :: SinkID -> SinkID -> Bool

(<=) :: SinkID -> SinkID -> Bool

(>) :: SinkID -> SinkID -> Bool

(>=) :: SinkID -> SinkID -> Bool

max :: SinkID -> SinkID -> SinkID

min :: SinkID -> SinkID -> SinkID

HasInvalidate SinkID

Defined in Util.Sink

Methods

invalidate :: SinkID -> IO ()

newSinkID :: IO SinkID

data Sink x

Instances

HasInvalidate (Sink x)

Or we can do so with HasInvalidate

Defined in Util.Sink

Methods

invalidate :: Sink x -> IO ()

newSink :: (x -> IO ()) -> IO (Sink x)

Creates a new sink with its own SinkID

newSinkGeneral :: SinkID -> (x -> IO ()) -> IO (Sink x)

Creates a new sink with a given SinkID. This allows us to invalidate lots of sinks just by invalidating one sinkID.

newParallelSink :: (x -> IO ()) -> IO (Sink x)

Creates a new sink which executes actions in a parallelExec thread.

newParallelDelayedSink :: IO (Sink x, (x -> IO ()) -> IO ())

Creates a new sink which executes actions in a parallelExec thread, but allow the function generating these actions to be specified later, via the returned command.

putSink :: Sink x -> x -> IO Bool

Put a value into the sink, returning False if the sink id has been invalidated.

putSinkMultiple :: Sink x -> [x] -> IO Bool

Put a list of values into the sink, returning False if the sink id has been invalidated

coMapSink :: (y -> x) -> Sink x -> Sink y

Convert a sink from one type to another

coMapSink' :: (y -> Maybe x) -> Sink x -> Sink y

Another version which allows a transformation function to filter certain elements

coMapIOSink' :: (y -> IO (Maybe x)) -> Sink x -> Sink y

A version which allows an IO action, which had better not take too long.

class CanAddSinks sinkSource x delta | sinkSource -> x, sinkSource -> delta where

A class for things (in particular Source and SimpleSource) that can output via sinks. Each sink source is supposed to have a unique x, containing a representation of the current value, and delta, containing the (incremental) updates which are put in the sink. Only the addOrdSink function must be defined by instances.

Minimal complete definition

addOldSink

Methods

addNewSink :: sinkSource -> (delta -> IO ()) -> IO (x, Sink delta)

addNewSinkGeneral :: sinkSource -> (delta -> IO ()) -> SinkID -> IO (x, Sink delta)

addNewSinkVeryGeneral :: sinkSource -> (delta -> IO ()) -> SinkID -> ParallelExec -> IO (x, Sink delta)

addNewSinkWithInitial :: sinkSource -> (x -> IO ()) -> (delta -> IO ()) -> SinkID -> ParallelExec -> IO (x, Sink delta)

addNewQuickSink :: sinkSource -> (delta -> IO ()) -> IO (x, Sink delta)

addNewQuickSinkGeneral :: sinkSource -> (delta -> IO ()) -> SinkID -> IO (x, Sink delta)

addOldSink :: sinkSource -> Sink delta -> IO x

Instances

HasSource hasSource x d => CanAddSinks hasSource x d

Defined in Util.Sources

Methods

addNewSink :: hasSource -> (d -> IO ()) -> IO (x, Sink d)

addNewSinkGeneral :: hasSource -> (d -> IO ()) -> SinkID -> IO (x, Sink d)

addNewSinkVeryGeneral :: hasSource -> (d -> IO ()) -> SinkID -> ParallelExec -> IO (x, Sink d)

addNewSinkWithInitial :: hasSource -> (x -> IO ()) -> (d -> IO ()) -> SinkID -> ParallelExec -> IO (x, Sink d)

addNewQuickSink :: hasSource -> (d -> IO ()) -> IO (x, Sink d)

addNewQuickSinkGeneral :: hasSource -> (d -> IO ()) -> SinkID -> IO (x, Sink d)

addOldSink :: hasSource -> Sink d -> IO x

addNewAction :: CanAddSinks sinkSource x delta => sinkSource -> (delta -> IO Bool) -> IO x

Add an action to a sinkSource which is performed until the action returns False.

data ParallelExec

newParallelExec :: IO ParallelExec

parallelExec :: ParallelExec -> IO () -> IO ()

parallelExecVSem :: VSem