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

Methods

invalidate :: source -> IO ()

Instances

HasInvalidate SinkID

HasInvalidate (Sink x)

Or we can do so with HasInvalidate

data SinkID

Instances

Eq SinkID

Ord SinkID

HasInvalidate SinkID

newSinkID :: IO SinkID

data Sink x

Instances

HasInvalidate (Sink x)

Or we can do so with HasInvalidate

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.

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

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