Control.Reactive

Primitives:

• Event: mempty, mappend, fmap
• Reactive: fmap, return, join, <
• scatterE
• accumE or accumR
• stepper, apply (or sample, or snapshotWith)
• readChanE, writeChanE, getE, pollE, putE, runLoopUntil

Types

data Event a

A stream of values.

 type Event a = [(Time, a)]

Instances

Functor Event

Event is a functor: fmap transforms each value.

Monoid (Event a)

Event is a monoid: mempty is the event that never occurs, mappend interleaves values.

data Reactive a

A time-varying value.

 type Reactive a = Time -> a

Instances

Functor Reactive

Reactive is a functor: fmap transforms the value at each point in time.

Applicative Reactive

Reactive is an applicative functor: pure is a constant value and fr <*> xr applies the function fr t to the value xr t.

Enum a => Enum (Reactive a)

Eq (Reactive b)

Floating b => Floating (Reactive b)

Fractional b => Fractional (Reactive b)

Integral a => Integral (Reactive a)

Num a => Num (Reactive a)

Ord b => Ord (Reactive b)

(Num a, Ord a) => Real (Reactive a)

IsString a => IsString (Reactive a)

Monoid a => Monoid (Reactive a)

Reactive has a lifted is a monoid: mempty is the constant empty value and mappend combines values according to mappend on values.

VectorSpace v => VectorSpace (Reactive v)

AdditiveGroup v => AdditiveGroup (Reactive v)

Basic combinators

Event to reactive

stepper :: a -> Event a -> Reactive a

Step between values.

maybeStepper :: Event a -> Reactive (Maybe a)

Switch between time-varying values.

switcher :: Reactive a -> Event (Reactive a) -> Reactive a r switcher e = RJoin (r stepper e) r switcher e = join (r stepper e)

Step between values without initial.

sampleAndHold2 :: b -> Reactive b -> Event a -> Reactive b

Switch between the values of a time-varying value when an event occurs.

sampleAndHold :: Reactive b -> Event a -> Reactive b sampleAndHold r e = r switcher (pure $ r sample e) sampleAndHold r e = (liftA2 change) r (maybeStepper $ sample r e) where change a Nothing = a change a (Just b) = b

Reactive to event

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

Apply the values of an event to a time-varying function.

 r `apply` e = r `snapshotWith ($)` e

filter' :: Reactive (a -> Bool) -> Event a -> Event a

Filter an event based on a time-varying predicate.

 r `filter'` e = justE $ (partial <$> r) `apply` e

gate :: Reactive Bool -> Event a -> Event a

Filter an event based on a time-varying toggle.

 r `gate` e = (const <$> r) `filter'` e

sample :: Reactive b -> Event a -> Event b

Sample a time-varying value.

 r `snapshot` e = snapshotWith const

snapshot :: Reactive a -> Event b -> Event (a, b)

Sample a time-varying value with the value of the trigger.

 r `snapshot` e = snapshotWith (,)

snapshotWith :: (a -> b -> c) -> Reactive a -> Event b -> Event c

Sample a time-varying value with the value of the trigger, using the given function to combine.

 r `snapshotWith f` e = (f <$> r) `apply` e

Merging and splitting values

justE :: Event (Maybe a) -> Event a

Discard empty values.

splitE :: Event (Either a b) -> (Event a, Event b)

Partition values of different types. See also partitionE.

 let (x, y) in eitherE x y = splitE e  ≡  e

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

Interleave values of different types.

Past-dependent values

Buffering events

lastE :: Event a -> Event a

Delay by one value.

delayE :: Int -> Event a -> Event a

Delay by n values.

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

Pack with last value. Similar to withPrevEWith in reactive but flipped.

diffE :: Num a => Event a -> Event a

Difference of successive values.

bufferE :: Int -> Event a -> Event [a]

Buffer up to n values. When the buffer is full, old elements will be rotated out.

 bufferE n e = [[e1],[e1,e2]..[e1..en],[e2..en+1]..]

gatherE :: Int -> Event a -> Event [a]

Gather event values into chunks of regular size.

 gatherE n e = [[e1..en],[en+1..e2n]..]

scatterE :: Event [a] -> Event a

Separate chunks of values.

 scatterE [e1,e2..] = [e1] <> [e2] ..

Accumulating values

accumE :: a -> Event (a -> a) -> Event a

Event accumulator.

 a `accumE` e = (a `accumR` e) `sample` e
 a `accumR` e = a `stepper` (a `accumE` e)

accumR :: a -> Event (a -> a) -> Reactive a

Reactive accumulator.

 a `accumE` e = (a `accumR` e) `sample` e
 a `accumR` e = a `stepper` (a `accumE` e)

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

Create a past-dependent event.

 scanlE f z x = foldpE (flip f) f z x

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

Create a past-dependent reactive. This combinator corresponds to scanl on streams.

 scanlR f z x = foldpR (flip f) f z x

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

Create a past-dependent event. This combinator corresponds to scanl on streams.

 scanlE f z x = foldpE (flip f) f z x

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

Create a past-dependent reactive. This combinator corresponds to scanl on streams.

 scanlR f z x = foldpR (flip f) f z x

mapAccum :: a -> Event (a -> (b, a)) -> (Event b, Reactive a)

Efficient combination of accumE and accumR.

Special accumulators

firstE :: Event a -> Event a

Get just the first value.

restE :: Event a -> Event a

Get all but the first value.

countE :: Enum b => Event a -> Event b

Count values.

countR :: Enum b => Event a -> Reactive b

Count values.

monoidE :: Monoid a => Event a -> Event a

Create a past-dependent event using a Monoid instance.

monoidR :: Monoid a => Event a -> Reactive a

Create a past-dependent event using a Monoid instance.

Lifted monoids

sumE :: Num a => Event a -> Event a

productE :: Num a => Event a -> Event a

allE :: Event Bool -> Event Bool

anyE :: Event Bool -> Event Bool

sumR :: Num a => Event a -> Reactive a

productR :: Num a => Event a -> Reactive a

allR :: Event Bool -> Reactive Bool

anyR :: Event Bool -> Reactive Bool

Toggles and switches

tickE :: Event a -> Event ()

Throw away values of the event.

This is of course just () <$ x but it is useful to fix the type in some cases.

onR :: Event a -> Reactive Bool

offR :: Event a -> Reactive Bool

toggleR :: Event a -> Reactive Bool

Time

pulse :: DiffTime -> Event ()

  An event occuring at the specified interval.

time :: Fractional a => Reactive a

A generalized time behaviour.

integral :: Fractional b => Event a -> Reactive b -> Reactive b

Integrates a behaviour.

 integral pulse behavior

Record and playback

data TransportControl t

Constructors

Play

Play from the current position.

Reverse

Play in reverse from the current position.

Pause

Stop playing, and retain current position.

Stop

Stop and reset position.

Instances

Eq (TransportControl t)

Ord (TransportControl t)

Show (TransportControl t)

transport :: (Ord t, Fractional t) => Event (TransportControl t) -> Event a -> Reactive t -> Reactive t

Generates a cursor that moves forward or backward continuously.

The cursor may be started, stopped, moved by sending a TransportControl event.

 transport control pulse speed

record :: Ord t => Reactive t -> Event a -> Reactive [(t, a)]

Record a list of values.

playback :: Ord t => Reactive t -> Reactive [(t, a)] -> Event a

Play back a list of values.

This function will sample the time behaviour at an arbitrary small interval. To get precise control of how time is sampled, use playback' instead.

playback' :: Ord t => Event b -> Reactive t -> Reactive [(t, a)] -> Event [(t, a)]

Play back a list of values.

Special functions

seqE :: Event a -> Event b -> Event b

Run both and behave as the second event.

oftenE :: Event ()

Creating events and reactives

From standard library

getCharE :: Event Char

Event version of getChar.

putCharE :: Event Char -> Event Char

Event version of putChar.

getLineE :: Event String

Event version of getLine.

putLineE :: Event String -> Event String

Event version of putStrLn.

systemTimeR :: Reactive UTCTime

systemTimeSecondsR :: Reactive DiffTime

systemTimeDayR :: Reactive Day

From channels

readChanE :: Chan a -> Event a

Event reading from a channel.

writeChanE :: Chan a -> Event a -> Event a

Event writing to a channel.

From IO

getE :: IO a -> Event a

Event reading from external world. The computation should be blocking and is polled exactly once per value.

This function can be used with standard I/O functions.

pollE :: IO (Maybe a) -> Event a

Event reading from external world. The computation should be non-blocking and may be polled repeatedly for each value.

This function should be used with non-effectful functions, typically functions that observe the current value of some external property. You should not use this function with standard I/O functions as this may lead to non-deterministic reads (i.e. loss of data).

putE :: (a -> IO ()) -> Event a -> Event a

Event writing to the external world.

This function can be used with standard I/O functions.

Run events

run :: Event a -> IO ()

Run the given event once.

runLoop :: Event a -> IO ()

Run the given event for ever.

runLoopUntil :: Event (Maybe a) -> IO a

Run the given event until the first Just x value, then return x.

Utility

type Source a = Event a

type Sink a = Event a -> Event ()

newSource :: IO (a -> IO (), Source a)

Creates a new source and a computation that writes it.

newSink :: IO (IO (Maybe a), Sink a)

Creates a new sink and a computation that reads from it.

notify :: String -> Event a -> Event a

Behaves like the original event but writes a given message to the standard output for each value.

showing :: Show a => String -> Event a -> Event a

Behaves like the original event but writes its value, prepended by the given message, for each value.

runEvent :: Show a => Event a -> IO ()

runReactive :: Show a => Reactive a -> IO ()

unsafeGetReactive :: Reactive a -> a