A container for a value that can change over time and allows notifications on changes. Basically a combination of a Behavior and an Event, with a rule that the Behavior will change if and only if the Event fires.

Extract the Behavior of a Dynamic.

Extract the Event of the Dynamic.

Create a Dynamic value using the given initial value that changes every time the Event occurs.

Map a sampling function over a Dynamic.

Flipped version of mapDynM

Construct a Dynamic value that never changes

Create a new Dynamic that counts the occurrences of the Event.

Create a new Dynamic using the initial value that flips its value every time the Event occurs.

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 if only if the old event does.

Prefer this to switchPromptlyDyn where possible. The lack of doing double work when the outer and (new) inner fires means this imposes fewer "timing requirements" and thus is far more easy to use without introducing fresh failure cases. switchDyn is also more performant.

Switches to the new Event whenever it receives one. Switching occurs before the inner Event fires - so if the Dynamic changes and both the old and new inner Events fire simultaneously, the output will fire with the value of the new Event.

Prefer switchDyn to this where possible. The timing requirements that switching before imposes are likely to bring down your app unless you are very careful. switchDyn is also more performant.

Replace the value of the Event with the current value of the Dynamic each time the Event occurs.

Note: tagPromptlyDyn d e differs from tag (current d) e in the case that e is firing at the same time that d is changing. With tagPromptlyDyn d e, the new value of d will replace the value of e, whereas with tag (current d) e, the old value will be used, since the Behavior won't be updated until the end of the frame. Additionally, this means that the output Event may not be used to directly change the input Dynamic, because that would mean its value depends on itself. When creating cyclic data flows, generally tag (current d) e is preferred.

Attach the current value of the Dynamic to the value of the Event each time it occurs.

Note: attachPromptlyDyn d is not the same as attach (current d). See tagPromptlyDyn for details.

Combine the current value of the Dynamic with the value of the Event each time it occurs.

Note: attachPromptlyDynWith f d is not the same as attachWith f (current d). See tagPromptlyDyn for details.

Create a new Event by combining the value at each occurrence with the current value of the Dynamic value and possibly filtering if the combining function returns Nothing.

Note: attachPromptlyDynWithMaybe f d is not the same as attachWithMaybe f (current d). See tagPromptlyDyn for details.

Factor a Dynamic t (Maybe a) into a Dynamic t (Maybe (Dynamic t a)), such that the outer Dynamic is updated only when the Maybe's constructor chages from Nothing to Just or vice-versa. Whenever the constructor becomes Just, an inner Dynamic will be provided, whose value will track the a inside the Just; when the constructor becomes Nothing, the existing inner Dynamic will become constant, and will not change when the outer constructor changes back to Nothing.

Create a Dynamic that accumulates values from another Dynamic. This function does not force its input Dynamic until the output Dynamic is forced.

Like scanDyn, but the the accumulator function may decline to update the result Dynamic's value.

Create a new Dynamic that only signals changes if the values actually changed.

Create a new Dynamic that changes only when the underlying Dynamic changes and the given function returns False when given both the old and the new values.

Dynamic Maybe that can only update from Nothing to Just or Just to Just (i.e., cannot revert to Nothing)

Create a Dynamic using the initial value and change it each time the Event occurs using a folding function on the previous value and the value of the Event.

Like foldDyn, but the combining function is a PushM action, so it can sample existing Behaviors and hold new ones.

Create a Dynamic using the provided initial value and change it each time the provided Event occurs, using a function to combine the old value with the Event's value. If the function returns Nothing, the value is not changed; this is distinct from returning Just the old value, since the Dynamic's updated Event will fire in the Just case, and will not fire in the Nothing case.

Like foldDynMaybe, but the combining function is a PushM action, so it can sample existing Behaviors and hold new ones.

Combine a Dynamic of a Map of Dynamics into a Dynamic with the current values of the Dynamics in a map.

Print the value of the Dynamic when it is first read and on each subsequent change that is observed (as traceEvent), prefixed with the provided string. This should only be used for debugging.

Note: Just like Debug.Trace.trace, the value will only be shown if something else in the system is depending on it.

Print the result of applying the provided function to the value of the Dynamic when it is first read and on each subsequent change that is observed (as traceEvent). This should only be used for debugging.

Note: Just like Debug.Trace.trace, the value will only be shown if something else in the system is depending on it.

Split a Dynamic pair into a pair of Dynamics

Convert a Map with Dynamic elements into a Dynamic of a Map with non-Dynamic elements.

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 with Dynamic elements into a Dynamic of a list with non-Dynamic elements, preserving the order of the elements.

Represents a time changing value together with an EventSelector that can efficiently detect when the underlying Dynamic has a particular value. This is useful for representing data like the current selection of a long list.

Semantically,

demuxed (demux d) k === fmap (== k) d

However, the when getDemuxed is used multiple times, the complexity is only O(log(n)), rather than O(n) for fmap.

Demultiplex an input value to a Demux with many outputs. At any given time, whichever output is indicated by the given Dynamic will be True.

Select a particular output of the Demux; this is equivalent to (but much faster than) mapping over the original Dynamic and checking whether it is equal to the given key.

A heterogeneous list whose type and length are fixed statically. This is reproduced from the HList package due to integration issues, and because very little other functionality from that library is needed.

Like HList, but with a functor wrapping each element.

Convert a datastructure whose constituent parts are all Dynamics into a single Dynamic whose value represents all the current values of the input's consitutent Dynamics.

This class allows HLists and FHlists to be built from regular lists; they must be contiguous and sorted.

Poor man's Generics for product types only.

Indicates that all elements in a type-level list are applications of the same functor.

A typed index into a typed heterogeneous list.

Collect a hetereogeneous list whose elements are all Dynamics into a single Dynamic whose value represents the current values of all of the input Dynamics.

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 psuedo applicative version of ap for Dynamic. Example useage:

do
   person <- Person `mapDyn` dynFirstName
                    `apDyn` dynListName
                    `apDyn` dynAge
                    `apDyn` dynAddress

This function has been renamed to attachPromptlyDyn to clarify its semantics.

This function has been renamed to attachPromptlyDynWith to clarify its semantics.

This function has been renamed to attachPromptlyDynWithMaybe to clarify its semantics.

This function no longer needs to be monadic, so it has been replaced by collectDynPure, which is pure.

Merge two Dynamics into a new one using the provided function. The new Dynamic changes its value each time one of the original Dynamics changes its value.

This function no longer needs to be monadic; see distributeMapOverDynPure.

This function no longer needs to be monadic, so it has been replaced by distributeFHListOverDynPure, which is pure.

Flipped version of mapDyn.

This function no longer needs to be monadic, so it has been replaced by demuxed, which is pure.

Combine an inner and outer Dynamic such that the resulting Dynamic's current value will always be equal to the current value's current value, and will change whenever either the inner or the outer (or both) values change.

Map a function over a Dynamic.

Merge the Dynamic values using their Monoid instance.

WARNING: This function is only pure if a's Eq instance tests representational equality. Use holdUniqDyn instead, which is pure in all circumstances. Also, note that, unlike nub, this function does not prevent all recurrences of a value, only consecutive recurrences.

Split the Dynamic into two Dynamics, each taking the respective value of the tuple.

This function has been renamed to tagPromptlyDyn to clarify its semantics.

WARNING: This function is only pure if a's Eq instance tests representational equality. Use holdUniqDyn instead, which is pure in all circumstances.

WARNING: This function is impure. Use holdUniqDynBy instead.