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.

Constructs a single Event out of a map of events. The output event may fire with multiple keys simultaneously.

Coerce a Behavior between representationally-equivalent value types

Coerce an Event between representationally-equivalent occurrence types

Coerce a Dynamic between representationally-equivalent value types

Coerce an Incremental 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 mapMaybe.

Efficiently select an Event keyed on Int. This is more efficient than manually filtering by key.

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.

Merge a collection of events; the resulting Event will only occur if at least one input event is occurring, and will contain all of the input keys that are occurring simultaneously

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 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.

Zips two values by taking the union of their shapes and combining with the provided function. Nothing values are dropped.

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

Efficiently fan-out an event to many destinations. You should save the result in a let-binding, and then repeatedly select on the result to create child events

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.

Factor the input DSum Event to produce an Event which fires when the DSum key changes and contains both the value of the DSum at switchover and an Event of values produced by subsequent firings of the input Event that do not change the DSum key.

Produces an Event that fires only when the input event fires with a DSum key that matches the provided key.

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.

Given a PatchTarget of events (e.g., a Map with Event values) and an event of Patches (e.g., a PatchMap with Event values), produce an Event of the PatchTarget type that fires with the patched value.

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.

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 a Dynamic by folding occurrences of an Event with the provided function. See foldDyn.

Accumulate a Dynamic by folding occurrences of an Event with the provided PushM action.

Accumulate a Dynamic by folding occurrences of an Event with the provided function, discarding Nothing results.

Accumulate a Dynamic by folding occurrences of an Event with the provided PushM action, discarding Nothing results.

Accumulate a Dynamic by folding occurrences of an Event with a function that both accumulates and produces a value to fire as an Event. Returns both the accumulated value and an Event.

Similar to mapAccumDyn except that the combining function is a PushM action.

Accumulate a Dynamic by folding occurrences of an Event with a function that both optionally accumulates and optionally produces a value to fire as a separate output Event. Note that because Nothings are discarded in both cases, the output Event may fire even though the output Dynamic has not changed, and the output Dynamic may update even when the output Event is not firing.

Like mapAccumMaybeDyn except that the combining function is a PushM action.

Accumulate a Behavior by folding occurrences of an Event with the provided function.

Like accumB except that the combining function is a PushM action.

Accumulate a Behavior by folding occurrences of an Event with the provided function, discarding Nothing results.

Like accumMaybeB except that the combining function is a PushM action.

Accumulate a Behavior by folding occurrences of an Event with a function that both accumulates and produces a value to fire as an Event. Returns both the accumulated value and an Event.

Like mapAccumB except that the combining function is a PushM action.

Accumulate a Behavior by folding occurrences of an Event with a function that both optionally accumulates and optionally produces a value to fire as a separate output Event. Nothings are discarded.

Like mapAccumMaybeB except that the combining function is a PushM action.

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.

Accumulate an Incremental with the supplied initial value and the firings of the provided Event, using the combining function to produce a patch.

Similar to accumIncremental but the combining function runs in PushM

Similar to accumIncremental but allows filtering of updates (by dropping updates when the combining function produces Nothing)

Similar to accumMaybeMIncremental but the combining function runs in PushM

Accumulate an Incremental by folding occurrences of an Event with a function that both accumulates and produces a value to fire as an Event. Returns both the accumulated value and the constructed Event.

Like mapAccumIncremental but the combining function runs in PushM

Accumulate an Incremental by folding occurrences of an Event with a function that both optionally accumulates and optionally produces a value to fire as a separate output Event. Note that because Nothings are discarded in both cases, the output Event may fire even though the output Incremental has not changed, and the output Incremental may update even when the output Event is not firing.

Like mapAccumMaybeIncremental but the combining function is a PushM action

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.

Like mapMaybe.

Alias for mapMaybe

Flipped version of mapMaybe.

Filter 'f a' using the provided predicate.

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.

See switchHoldPromptly

See switchHoldPromptOnly

An alias for mapMaybeCheap

A "cheap" version of mapMaybe. See the performance note on pushCheap.

A "cheap" version of fmap. See the performance note on pushCheap.

A "cheap" version of ffor. See the performance note on pushCheap.

A "cheap" version of fforMaybe. See the performance note on pushCheap.

A "cheap" version of pushAlways. See the performance note on pushCheap.

A "cheap" version of tag. See the performance note on pushCheap.

A "cheap" version of mergeWithCheap. See the performance note on pushCheap.

A "cheap" version of mergeWithCheap'. See the performance note on pushCheap.

A somewhat slow implementation of headE