Control.MonadicFRP

Monadic FRP basic definitions and composition functions.

See the paper Monadic Functional Reactive Programming by Atze van der Ploeg. Haskell Symposium '13. http://homepages.cwi.nl/~ploeg/papers/monfrp.pdf.

An example can be found at https://github.com/cwi-swat/monadic-frp.

Notice that currently Monadic FRP relies on a closed union (ADT) of basic events, which has the following downsides:

• Reactive level sharing requires an explicit call to a memoization function.
• Reactive level recursion is problematic.

A function preprended with i indices a initialized signal variant of an signal computation function.

Basic definitions

data Event a

Constructors

Request

Occurred a

Instances

Ord a => Eq (Event a)

Ord a => Ord (Event a)

Show a => Show (Event a)

type EvReqs e = Set e

An alias for a set of event requests

type EvOccs e = Set e

An alias for a set of event occurances

data React e alpha

A reactive computation

Constructors

Done alpha

Await (EvReqs e) (EvOccs e -> React e alpha)

Instances

Monad (React e)

Functor (React e)

exper :: e -> React e e

Request a single event

interpret :: Monad m => (EvReqs e -> m (EvOccs e)) -> React e a -> m a

The interpreter for reactive computations. The first argument is a function that answers event requests in the monad m, the second is the reactive computation.

newtype Sig e a b

A signal computation is a reactive computation of an initialized signal

Constructors

Sig (React e (ISig e a b))

Instances

Monad (Sig e a)

Functor (Sig e a)

data ISig e a b

An initialized signal

Constructors

a :| (Sig e a b)

End b

Instances

Monad (ISig e a)

interpretSig :: Monad m => (EvReqs e -> m (EvOccs e)) -> (a -> m r) -> Sig e a b -> m b

The interpreter for signal computations taking three arguments:

• a function that answers event requests in the monad m
• a function that processes the emitted values in the monad m
• the signal computation.

first :: Ord e => React e a -> React e b -> React e (React e a, React e b)

Run two reactive computations in parallel until either completes, and return the new state of both.

Notice that flip first == first

parR :: Ord e => React e a -> React e b -> React e (React e a, React e b)

Alias for first

update :: Ord e => React e a -> EvOccs e -> React e a

Call the continuation function of a reactive computation if it awaits at least one of the event occurences.

Repetition

repeat :: React e a -> Sig e a b

Repeat the given reactive computation indefinitely, each time emitting its result.

spawn :: Sig e t t1 -> Sig e (ISig e t t1) b

Repeat the given signal computation indefinitely, each time emitting its initialized signal result.

Transformation

map :: (t -> a) -> Sig e t b -> Sig e a b

Transform the emmited values of a signal computation by applying the function to each of them.

imap :: (t -> a) -> ISig e t b -> ISig e a b

Transform the emmited values of an initialized signal computation by applying the function to each of them.

scanl :: (a -> t -> a) -> a -> Sig e t t1 -> Sig e a t1

The list function scanl is similar to foldl, but returns a list of successive reduced values instead of a single value. the signal variant works analogously.

iscanl :: (a -> t -> a) -> a -> Sig e t t1 -> ISig e a t1

break :: (a -> Bool) -> Sig e a b -> Sig e a (ISig e a b)

Run the signal computation as long as the given predicate does not hold on the emitted values. Once a value is emmited on which the predicate holds, the rest of the signal computation is returned.

ibreak :: (a -> Bool) -> ISig e a b -> ISig e a (ISig e a b)

foldl :: (a -> b -> a) -> a -> Sig e b r -> React e a

|foldl| on signal computations behaves the same as waiting for the signal computation to end and then applying the fold on the list of emitted values.

ifoldl :: (a -> b -> a) -> a -> ISig e b r -> React e a

find :: (a -> Bool) -> Sig t a t1 -> React t (Maybe a)

Find the first emmited value on which the predicate hold.

at :: Ord t => Sig t a t1 -> React t b -> React t (Maybe a)

Sample the form of the signal computation at the time the reactive computation completes

until :: Ord e => Sig e a t -> React e b -> Sig e a (Sig e a t, React e b)

Run the signal computation until the reactive computation completes, and return the new state of both computations.

iuntil :: Ord t => ISig t a b -> React t alpha -> ISig t a (ISig t a b, React t alpha)

(<^>) :: Ord e => Sig e (t -> a) b -> Sig e t t1 -> Sig e a (ISig e (t -> a) b, ISig e t t1)

Apply the values from the second signal computation to the values from the first signal computation over time. When one ends, the new state of both is returned.

pairs :: Ord e => ISig e t1 b -> ISig e t2 t -> ISig e (t1, t2) (ISig e t1 b, ISig e t2 t)

Emitted the pairs of the emitted values from both signal computations over time. When one ends, the new state of both is returned.

bothStart :: Ord t4 => Sig t4 t t1 -> Sig t4 t2 t3 -> React t4 (ISig t4 t t1, ISig t4 t2 t3)

Wait for both signal computation to become initialized, and then return both their initizialized signals.

indexBy :: (Show a, Ord e) => Sig e a l -> Sig e b r -> Sig e a ()

Sample the former signal computation each time the later emits a value.

iindexBy :: Ord e => ISig e a b -> Sig e t t1 -> Sig e a ()

Conversion

emitAll :: ISig e a b -> Sig e a b

Convert a initialized signal to a signal computation

emit :: a -> Sig e a ()

Emit a single value in the signal computation mondad

always :: a -> Sig e a b

A signal that alway has the given form.

waitFor :: React e b -> Sig e a b

Convert a reactive computation to a signal computation.

hold :: Sig e a b

The reactive computation that never completes.

res :: Sig t t1 b -> React t b

Convert the result of a signal computation to a reactive computation.

ires :: ISig t t1 b -> React t b

Convert the result of an initialized signal a reactive computation.

cur :: Sig t a t1 -> Maybe a

Give the current value of a signal computation, if any.

icur :: ISig t a t1 -> Maybe a

the head of an initalized signal, if any.

done :: React t a -> Maybe a

Return the result of a reactive computation if it is done

done' :: React t c -> c

Version of done that throws an error if it the result is not done.

Dynamic lists

cons :: Ord e => ISig e a l -> ISig e [a] r -> ISig e [a] ()

Cons the values from the first signal computation to the values form the latter signal computation over time.

parList :: Ord e => Sig e (ISig e a l) r -> Sig e [a] ()

Run the initialized signals from the given signal computation in parallel, and emit the lists of the current form of all alive initialized signals.

iparList :: Ord e => Sig e (ISig e a l) r -> ISig e [a] ()

Memoization

memo :: Ord e => React e a -> React e a

Memoize the continuation function of the reactive computation, and the continuation function of all next states.

memoSig :: Ord e => Sig e a b -> Sig e a b

Memoize the reactive computation of the initialized signal, and memoize the signal computation of the tail (if any).

imemoSig :: Ord e => ISig e a b -> ISig e a b