Box.Connectors

various ways to connect things up

Documentation

fromListE :: MonadConc m => [a] -> Cont m (Emitter m a)

Turn a list into an Emitter continuation via a Queue

fromList_ :: Monad m => [a] -> Committer m a -> m ()

fromList_ directly supplies to a committer action

FIXME: fromList_ combined with cRef is failing dejavu concurrency testing...

toList_ :: Monad m => Emitter m a -> m [a]

toList_ directly receives from an emitter

TODO: check isomorphism

toList_ == toListE

fromToList_ :: Monad m => [a] -> (Box (StateT ([b], [a]) m) b a -> StateT ([b], [a]) m r) -> m [b]

take a list, emit it through a box, and output the committed result.

The pure nature of this computation is highly useful for testing, especially where parts of the box under investigation has non-deterministic attributes.

emitQ :: MonadConc m => (Committer m a -> m r) -> Cont m (Emitter m a)

hook a committer action to a queue, creating an emitter continuation

commitQ :: MonadConc m => (Emitter m a -> m r) -> Cont m (Committer m a)

hook a committer action to a queue, creating an emitter continuation

sink :: MonadConc m => Int -> (a -> m ()) -> Cont m (Committer m a)

finite sink

source :: MonadConc m => Int -> m a -> Cont m (Emitter m a)

finite source

forkEmit :: Monad m => Emitter m a -> Committer m a -> Emitter m a

glues an emitter to a committer, then resupplies the emitter

feedback :: MonadConc m => (a -> m (Maybe b)) -> Cont m (Box m b a) -> Cont m (Box m b a)

a box modifier that feeds commits back to the emitter

queueCommitter :: MonadConc m => Committer m a -> Cont m (Committer m a)

fuse a committer to a buffer

queueEmitter :: MonadConc m => Emitter m a -> Cont m (Emitter m a)

fuse an emitter to a buffer

concurrentE :: MonadConc m => Emitter m a -> Emitter m a -> Cont m (Emitter m a)

concurrently run two emitters

This differs from mappend in that the monoidal (and alternative) instance of an Emitter is left-biased (The left emitter exhausts before the right one is begun). This is non-deterministically concurrent.

concurrentC :: MonadConc m => Committer m a -> Committer m a -> Cont m (Committer m a)

run two committers concurrently

glueN :: Monad m => Int -> Committer m a -> Emitter m a -> m ()

Glues a committer and emitter, taking n emits

>>> glueN 4 <$> pure (contramap show toStdout) <*.> fromListE [1..]
1
2
3
4