The Reflex class contains all the primitive functionality needed for Functional Reactive Programming (FRP). The t type parameter indicates which "timeline" is in use. Timelines are fully-independent FRP contexts, and the type of the timeline determines the FRP engine to be used. For most purposes, the Spider implementation is recommended.

Coerce a Behavior between representationally-equivalent value types

Coerce an Event between representationally-equivalent occurrence types

Coerce a Dynamic between representationally-equivalent value types

MonadSample designates monads that can read the current value of a Behavior. This includes both PullM and PushM.

MonadHold designates monads that can create new Behaviors based on Events; usually this will be PushM or a monad based on it. MonadHold is required to create any stateful computations with Reflex.

An EventSelector allows you to efficiently select an Event based on a key. This is much more efficient than filtering for each key with fmapMaybe.

Construct a Dynamic value that never changes

Create an Event from another Event. The provided function can sample Behaviors and hold Events.

Create a new Event that occurs if at least one of the Events in the list occurs. If multiple occur at the same time the value is the value of the leftmost event.

Create a new Event combining the map of Events into an Event that occurs if at least one of them occurs and has a map of values of all Events occurring at that time.

Like mergeMap but for IntMap.

Create a merge whose parents can change over time

Experimental: Create a merge whose parents can change over time; changing the key of an Event is more efficient than with mergeIncremental

Create a merge whose parents can change over time

When the given outer event fires, condense the inner events into the contained patch. Non-firing inner events will be replaced with deletions.

See coincidencePatchMap

See coincidencePatchMap

Create a new Event that occurs if at least one of the Events in the list occurs and has a list of the values of all Events occurring at that time.

Create a new Event that occurs if at least one of the Events in the list occurs. If multiple occur at the same time they are folded from the left with the given function.

Create a new Event that occurs when the first supplied Event occurs unless the second supplied Event occurs simultaneously.

Split the supplied Event into two individual Events occurring at the same time with the respective values from the tuple.

Split the event into separate events for Left and Right values.

Split the event into separate events for This and That values, allowing them to fire simultaneously when the input value is These.

Split the event into an EventSelector that allows efficient selection of the individual Events.

Extract the values of a DMap of EitherTags.

Tag type for Either to use it as a DSum.

Convert Either to a DSum. Inverse of dsumToEither.

Convert DSum to Either. Inverse of eitherToDSum.

Switches to the new event whenever it receives one. Only the old event is considered the moment a new one is switched in; the output event will fire at that moment only if the old event does.

Because the simultaneous firing case is irrelevant, this function imposes laxer "timing requirements" on the overall circuit, avoiding many potential cyclic dependency / metastability failures. It's also more performant. Use this rather than switchHoldPromptly and switchHoldPromptOnly unless you are absolutely sure you need to act on the new event in the coincidental case.

Switches to the new event whenever it receives one. Whenever a new event is provided, if it is firing, its value will be the resulting event's value; if it is not firing, but the old one is, the old one's value will be used.

switchHold, by always forwarding the old event the moment it is switched out, avoids many potential cyclic dependency problems / metastability problems. It's also more performant. Use it instead unless you are sure you cannot.

switches to a new event whenever it receives one. At the moment of switching, the old event will be ignored if it fires, and the new one will be used if it fires; this is the opposite of switch, which will use only the old value.

switchHold, by always forwarding the old event the moment it is switched out, avoids many potential cyclic dependency problems / metastability problems. It's also more performant. Use it instead unless you are sure you cannot.

Replace each occurrence value of the Event with the value of the Behavior at the time of that occurrence.

Replace each occurrence value of the Event with the value of the Behavior at that time; if it is Just, fire with the contained value; if it is Nothing, drop the occurrence.

Create a new Event that combines occurrences of supplied Event with the current value of the Behavior.

Create a new Event that occurs when the supplied Event occurs by combining it with the current value of the Behavior.

Create a new Event by combining each occurrence with the current value of the Behavior. The occurrence is discarded if the combining function returns Nothing

Create a new Event that only occurs if the supplied Event occurs and the Behavior is true at the time of occurrence.

This function converts a DMap whose elements are Dynamics into a Dynamic DMap. Its implementation is more efficient than doing the same through the use of multiple uses of zipDynWith or Applicative operators.

Convert a list of Dynamics into a Dynamic list.

Create a new Dynamic by applying a combining function to a list of Dynamics

Combine two Dynamics. The result will change whenever either (or both) input Dynamic changes. Equivalent to zipDynWith (,).

Combine two Dynamics with a combining function. The result will change whenever either (or both) input Dynamic changes. More efficient than liftA2.

An Accumulator type can be built by accumulating occurrences of an Event.

Accumulate occurrences of an Event, producing an output occurrence each time. Discard the underlying Accumulator.

Accumulate occurrences of an Event, using a PushM action and producing an output occurrence each time. Discard the underlying Accumulator.

Accumulate occurrences of an Event, possibly producing an output occurrence each time. Discard the underlying Accumulator.

Accumulate occurrences of an Event, using a PushM action and possibly producing an output occurrence each time. Discard the underlying Accumulator.

Create a new Event by combining each occurrence with the next value of the list using the supplied function. If the list runs out of items, all subsequent Event occurrences will be ignored.

Assign a number to each occurrence of the given Event, starting from 0

Assign a number to each occurrence of the given Event

Assign a number to each occurrence of the given Event; discard the occurrences' values

This is used to sample the value of a Behavior using an Event.

The <@> operator is intended to be used in conjunction with the Applicative instance for Behavior.

This is useful when we want to combine the values of one Event and the value of several Behaviors at the time the Event is firing.

If we have:

f  :: a -> b -> c -> d
b1 :: Behavior t a
b2 :: Behavior t b
e  :: Event t c

then we can do:

f <$> b1 <*> b2 <@> e :: Event t d

in order to apply the function f to the relevant values.

The alternative would be something like:

attachWith (\(x1, x2) y -> f x1 x2 y) ((,) <$> b1 <*> b2) e :: Event t d

or a variation involing a custom data type to hold the combination of Behaviors even when that combination might only ever be used by f.

A more suggestive example might be:

handleMouse <$> bPlayerState <*> bMousePosition <@> eMouseClick :: Event t (GameState -> GameState)

An version of <@> that does not use the value of the Event.

Alternatively, it is tag in operator form.

This is useful when we want to combine the values of several Behaviors at particular points in time using an Applicative style syntax.

If we have:

g  :: a -> b -> d
b1 :: Behavior t a
b2 :: Behavior t b
e  :: Event t c

where e is firing at the points in time of interest.

Then we can use <@:

g <$> b1 <*> b2 <@  e :: Event t d

to combine the values of b1 and b2 at each of those points of time, with the function g being used to combine the values.

This is the same as <@> except that the Event is being used only to act as a trigger.

Create a new Event that occurs on all but the first occurrence of the supplied Event.

Create a tuple of two Events with the first one occurring only the first time the supplied Event occurs and the second occurring on all but the first occurrence.

Take the streak of occurrences starting at the current time for which the event returns True.

Starting at the current time, fire all the occurrences of the Event for which the given predicate returns True. When first False is returned, do not fire, and permanently stop firing, even if True values would have been encountered later.

Take the streak of occurrences starting at the current time for which the event returns 'Just b'.

Starting at the current time, fire all the occurrences of the Event for which the given predicate returns 'Just b'. When first Nothing is returned, do not fire, and permanently stop firing, even if 'Just b' values would have been encountered later.

Drop the streak of occurrences starting at the current time for which the event returns True.

Starting at the current time, do not fire all the occurrences of the Event for which the given predicate returns True. When False is first returned, do fire, and permanently continue firing, even if True values would have been encountered later.

Both take and drop the streak of occurrences starting at the current time for which the event returns 'Just b'.

For the left event, starting at the current time, fire all the occurrences of the Event for which the given function returns 'Just b'. When Nothing is returned, do not fire, and permanently stop firing, even if 'Just b' values would have been encountered later.

For the right event, do not fire until the first occurrence where the given function returns Nothing, and fire that one and all subsequent occurrences. Even if the function would have again returned 'Just b', keep on firing.

Create a new behavior given a starting behavior and switch to the behavior carried by the event when it fires.

Print the supplied String and the value of the Event on each occurrence. This should only be used for debugging.

Note: As with Debug.Trace.trace, the message will only be printed if the Event is actually used.

Print the output of the supplied function on each occurrence of the Event. This should only be used for debugging.

Note: As with Debug.Trace.trace, the message will only be printed if the Event is actually used.

Construct a Dynamic from a Behavior and an Event. The Behavior must change when and only when the Event fires, such that the Behavior's value is always equal to the most recent firing of the Event; if this is not the case, the resulting Dynamic will behave nondeterministically.

A class for values that combines filtering and mapping using Maybe. Morally, FunctorMaybe ~ KleisliFunctor Maybe. Also similar is the Witherable typeclass, but it requires Foldable f and Traverable f, and e.g. Event is instance of neither.

A definition of fmapMaybe must satisfy the following laws:

identity

fmapMaybe Just ≡ id

composition

fmapMaybe (f <=< g) ≡ fmapMaybe f . fmapMaybe g

Flipped version of fmapMaybe.

Filter 'f a' using the provided predicate. Relies on fforMaybe.

Filter Lefts from 'f (Either a b)' into a.

Filter Rights from 'f (Either a b)' into b.

Flipped version of fmap.

Rotated version of liftA2.

Rotated version of liftA3.

Create a new Event that occurs if at least one of the supplied Events occurs. If both occur at the same time they are combined using mappend.

Alias for headE

Run both sides of a These monadically, combining the results.