Control.Wire.Core

Wires

data Wire m a b

Wire is a language for defining reactive systems. It is similar to the underlying monad m, but runs continuously.

Instances

Monad m => Arrow (Wire m)

Methods

arr :: (b -> c) -> Wire m b c

first :: Wire m b c -> Wire m (b, d) (c, d)

second :: Wire m b c -> Wire m (d, b) (d, c)

(***) :: Wire m b c -> Wire m b' c' -> Wire m (b, b') (c, c')

(&&&) :: Wire m b c -> Wire m b c' -> Wire m b (c, c')

Monad m => ArrowChoice (Wire m)

Methods

left :: Wire m b c -> Wire m (Either b d) (Either c d)

right :: Wire m b c -> Wire m (Either d b) (Either d c)

(+++) :: Wire m b c -> Wire m b' c' -> Wire m (Either b b') (Either c c')

(|||) :: Wire m b d -> Wire m c d -> Wire m (Either b c) d

MonadFix m => ArrowLoop (Wire m)

Methods

loop :: Wire m (b, d) (c, d) -> Wire m b c

Applicative m => Choice (Wire m)

Methods

left' :: Wire m a b -> Wire m (Either a c) (Either b c)

right' :: Wire m a b -> Wire m (Either c a) (Either c b)

Functor m => Strong (Wire m)

Methods

first' :: Wire m a b -> Wire m (a, c) (b, c)

second' :: Wire m a b -> Wire m (c, a) (c, b)

MonadFix m => Costrong (Wire m)

Methods

unfirst :: Wire m (a, d) (b, d) -> Wire m a b

unsecond :: Wire m (d, a) (d, b) -> Wire m a b

Functor m => Profunctor (Wire m)

Methods

dimap :: (a -> b) -> (c -> d) -> Wire m b c -> Wire m a d

lmap :: (a -> b) -> Wire m b c -> Wire m a c

rmap :: (b -> c) -> Wire m a b -> Wire m a c

(#.) :: Coercible * c b => (b -> c) -> Wire m a b -> Wire m a c

(.#) :: Coercible * b a => Wire m b c -> (a -> b) -> Wire m a c

Monad m => Category * (Wire m)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

Functor m => Functor (Wire m a)

Methods

fmap :: (a -> b) -> Wire m a a -> Wire m a b

(<$) :: a -> Wire m a b -> Wire m a a

Applicative m => Applicative (Wire m a)

Methods

pure :: a -> Wire m a a

(<*>) :: Wire m a (a -> b) -> Wire m a a -> Wire m a b

liftA2 :: (a -> b -> c) -> Wire m a a -> Wire m a b -> Wire m a c

(*>) :: Wire m a a -> Wire m a b -> Wire m a b

(<*) :: Wire m a a -> Wire m a b -> Wire m a a

evalWith :: Applicative m => (forall b. a -> b -> b) -> Wire m a a

Evaluate the input using the given strategy in every frame. Valid arguments include functions like seq.

initial :: Applicative m => Wire m (m a) a

Run the given action once at the beginning.

withM :: Monad m => (s -> Wire m a b) -> (a -> m s) -> Wire m a b

Run the given action to initialise the given wire. Example:

withM (scan f) actionFromInitialInput

Events

data Event a

An event is a timestamped stream of occurrences with payloads of the given type.

Instances

Functor Event

Methods

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

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

Plus Event

Methods

zero :: Event a

Alt Event

Methods

(<!>) :: Event a -> Event a -> Event a

some :: Applicative Event => Event a -> Event [a]

many :: Applicative Event => Event a -> Event [a]

Apply Event

Methods

(<.>) :: Event (a -> b) -> Event a -> Event b

(.>) :: Event a -> Event b -> Event b

(<.) :: Event a -> Event b -> Event a

Bind Event

Methods

(>>-) :: Event a -> (a -> Event b) -> Event b

join :: Event (Event a) -> Event a

Extend Event

Methods

duplicated :: Event a -> Event (Event a)

extended :: (Event a -> b) -> Event a -> Event b

Align Event

Methods

nil :: Event a

align :: Event a -> Event b -> Event (These a b)

alignWith :: (These a b -> c) -> Event a -> Event b -> Event c

Semigroup a => Semigroup (Event a)

Methods

(<>) :: Event a -> Event a -> Event a

sconcat :: NonEmpty (Event a) -> Event a

stimes :: Integral b => b -> Event a -> Event a

Semigroup a => Monoid (Event a)

Methods

mempty :: Event a

mappend :: Event a -> Event a -> Event a

mconcat :: [Event a] -> Event a

NFData a => NFData (Event a)

Methods

rnf :: Event a -> ()

catMapE :: (a -> Maybe b) -> Event a -> Event b

Map and filter event occurrences using the given function.

hold :: Applicative m => a -> Wire m (Event a) a

Hold the latest occurrence of the given event starting with the given initial value. The value switch occurs in the next frame.

hold' :: Applicative m => a -> Wire m (Event a) a

Hold the latest occurrence of the given event starting with the given initial value. The value switch occurs instantly.

never :: Event a

The event that never occurs.

unfoldE :: Applicative m => s -> Wire m (Event (s -> (a, s))) (Event a)

Unfold the given event using the state transition functions it carries.

Switching

newtype Switch f m a b

Functions to be applied to the current set of wires managed by manage.

Constructors

Switch

Fields

• fromSwitch :: forall s. (Wire m a b -> s) -> f s -> f s

manage :: (Traversable f, Applicative m) => f (Wire m a b) -> Wire m (a, Event (Switch f m a b)) (f b)

Sequence each of the given wires and collect their results. Whenever the given event occurs its function is applied to the current set of wires. Changes are applied in the next frame.

manage' :: (Traversable f, Applicative m) => f (Wire m a b) -> Wire m (a, Event (Switch f m a b)) (f b)

Sequence each of the given wires and collect their results. Whenever the given event occurs its function is applied to the current set of wires. Changes are applied immediately.

sequenceW :: (Traversable f, Applicative m) => f (Wire m a b) -> Wire m a (f b)

Sequence each of the given wires and collect their results.

switch :: Functor m => Wire m a (b, Event (Wire m a b)) -> Wire m a b

Acts like the given wire until its event occurs, then switches to the wire the occurrence contained. The switch occurs in the next frame.

switch' :: Monad m => Wire m a (b, Event (Wire m a b)) -> Wire m a b

Acts like the given wire until its event occurs, then switches to the wire the occurrence contained. The switch occurs immediately.

Monad transformers

hoistW :: Functor m => (a -> a') -> (forall x. a -> m' x -> m x) -> Wire m' a' b -> Wire m a b

Map the underlying monad using the given function.