Reflex.Class

Documentation

module Data.Patch

Primitives

class (MonadHold t (PushM t), MonadSample t (PullM t), MonadFix (PushM t), Functor (Dynamic t), Applicative (Dynamic t), Monad (Dynamic t)) => Reflex t where

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.

Associated Types

data Behavior t :: Type -> Type

A container for a value that can change over time. Behaviors can be sampled at will, but it is not possible to be notified when they change

data Event t :: Type -> Type

A stream of occurrences. During any given frame, an Event is either occurring or not occurring; if it is occurring, it will contain a value of the given type (its "occurrence type")

data Dynamic t :: Type -> Type

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.

data Incremental t :: Type -> Type

An Incremental is a more general form of a Dynamic. Instead of always fully replacing the value, only parts of it can be patched. This is only needed for performance critical code via mergeIncremental to make small changes to large values.

type PushM t :: Type -> Type

A monad for doing complex push-based calculations efficiently

type PullM t :: Type -> Type

A monad for doing complex pull-based calculations efficiently

Methods

never :: Event t a

An Event with no occurrences

constant :: a -> Behavior t a

Create a Behavior that always has the given value

push :: (a -> PushM t (Maybe b)) -> Event t a -> Event t b

Create an Event from another Event; the provided function can sample Behaviors and hold Events, and use the results to produce a occurring (Just) or non-occurring (Nothing) result

pushCheap :: (a -> PushM t (Maybe b)) -> Event t a -> Event t b

Like push but intended for functions that the implementation can consider cheap to compute for performance considerations. WARNING: The function passed to pushCheap may be run multiple times without any caching.

pull :: PullM t a -> Behavior t a

Create a Behavior by reading from other Behaviors; the result will be recomputed whenever any of the read Behaviors changes

mergeG :: GCompare k => (forall a. q a -> Event t (v a)) -> DMap k q -> Event t (DMap k v)

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

fanG :: GCompare k => Event t (DMap k v) -> EventSelectorG t k v

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

switch :: Behavior t (Event t a) -> Event t a

Create an Event that will occur whenever the currently-selected input Event occurs

coincidence :: Event t (Event t a) -> Event t a

Create an Event that will occur whenever the input event is occurring -- and its occurrence value, another Event, is also occurring. You maybe looking for 'switchHold never' instead.

current :: Dynamic t a -> Behavior t a

Extract the Behavior of a Dynamic.

updated :: Dynamic t a -> Event t a

Extract the Event of the Dynamic.

unsafeBuildDynamic :: PullM t a -> Event t a -> Dynamic t a

Create a new Dynamic. The given PullM must always return the most recent firing of the given Event, if any.

unsafeBuildIncremental :: Patch p => PullM t (PatchTarget p) -> Event t p -> Incremental t p

Create a new Incremental. The given PullM's value must always change in the same way that the accumulated application of patches would change that value.

mergeIncrementalG :: GCompare k => (forall a. q a -> Event t (v a)) -> Incremental t (PatchDMap k q) -> Event t (DMap k v)

Create a merge whose parents can change over time

mergeIncrementalWithMoveG :: GCompare k => (forall a. q a -> Event t (v a)) -> Incremental t (PatchDMapWithMove k q) -> Event t (DMap k v)

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

currentIncremental :: Patch p => Incremental t p -> Behavior t (PatchTarget p)

Extract the Behavior component of an Incremental

updatedIncremental :: Patch p => Incremental t p -> Event t p

Extract the Event component of an Incremental

incrementalToDynamic :: Patch p => Incremental t p -> Dynamic t (PatchTarget p)

Convert an Incremental to a Dynamic

behaviorCoercion :: Coercion a b -> Coercion (Behavior t a) (Behavior t b)

Construct a Coercion for a Behavior given an Coercion for its occurrence type

eventCoercion :: Coercion a b -> Coercion (Event t a) (Event t b)

Construct a Coercion for an Event given an Coercion for its occurrence type

dynamicCoercion :: Coercion a b -> Coercion (Dynamic t a) (Dynamic t b)

Construct a Coercion for a Dynamic given an Coercion for its occurrence type

incrementalCoercion :: Coercion (PatchTarget a) (PatchTarget b) -> Coercion a b -> Coercion (Incremental t a) (Incremental t b)

Construct a Coercion for an Incremental given Coercions for its patch target and patch types.

mergeIntIncremental :: Incremental t (PatchIntMap (Event t a)) -> Event t (IntMap a)

fanInt :: Event t (IntMap a) -> EventSelectorInt t a

Instances

(Enum t, HasTrie t, Ord t) => Reflex (Pure t :: Type)

The Enum instance of t must be dense: for all x :: t, there must not exist any y :: t such that pred x < y < x. The HasTrie instance will be used exclusively to memoize functions of t, not for any of its other capabilities.

Defined in Reflex.Pure

Associated Types

data Behavior (Pure t) a :: Type

data Event (Pure t) a :: Type

data Dynamic (Pure t) a :: Type

data Incremental (Pure t) a :: Type

type PushM (Pure t) :: Type -> Type

type PullM (Pure t) :: Type -> Type

Methods

never :: Event (Pure t) a

constant :: a -> Behavior (Pure t) a

push :: (a -> PushM (Pure t) (Maybe b)) -> Event (Pure t) a -> Event (Pure t) b

pushCheap :: (a -> PushM (Pure t) (Maybe b)) -> Event (Pure t) a -> Event (Pure t) b

pull :: PullM (Pure t) a -> Behavior (Pure t) a

mergeG :: GCompare k => (forall (a :: k). q a -> Event (Pure t) (v a)) -> DMap k q -> Event (Pure t) (DMap k v)

fanG :: GCompare k => Event (Pure t) (DMap k v) -> EventSelectorG (Pure t) k v

switch :: Behavior (Pure t) (Event (Pure t) a) -> Event (Pure t) a

coincidence :: Event (Pure t) (Event (Pure t) a) -> Event (Pure t) a

current :: Dynamic (Pure t) a -> Behavior (Pure t) a

updated :: Dynamic (Pure t) a -> Event (Pure t) a

unsafeBuildDynamic :: PullM (Pure t) a -> Event (Pure t) a -> Dynamic (Pure t) a

unsafeBuildIncremental :: Patch p => PullM (Pure t) (PatchTarget p) -> Event (Pure t) p -> Incremental (Pure t) p

mergeIncrementalG :: GCompare k => (forall (a :: k). q a -> Event (Pure t) (v a)) -> Incremental (Pure t) (PatchDMap k q) -> Event (Pure t) (DMap k v)

mergeIncrementalWithMoveG :: GCompare k => (forall (a :: k). q a -> Event (Pure t) (v a)) -> Incremental (Pure t) (PatchDMapWithMove k q) -> Event (Pure t) (DMap k v)

currentIncremental :: Patch p => Incremental (Pure t) p -> Behavior (Pure t) (PatchTarget p)

updatedIncremental :: Patch p => Incremental (Pure t) p -> Event (Pure t) p

incrementalToDynamic :: Patch p => Incremental (Pure t) p -> Dynamic (Pure t) (PatchTarget p)

behaviorCoercion :: Coercion a b -> Coercion (Behavior (Pure t) a) (Behavior (Pure t) b)

eventCoercion :: Coercion a b -> Coercion (Event (Pure t) a) (Event (Pure t) b)

dynamicCoercion :: Coercion a b -> Coercion (Dynamic (Pure t) a) (Dynamic (Pure t) b)

incrementalCoercion :: Coercion (PatchTarget a) (PatchTarget b) -> Coercion a b -> Coercion (Incremental (Pure t) a) (Incremental (Pure t) b)

mergeIntIncremental :: Incremental (Pure t) (PatchIntMap (Event (Pure t) a)) -> Event (Pure t) (IntMap a)

fanInt :: Event (Pure t) (IntMap a) -> EventSelectorInt (Pure t) a

HasSpiderTimeline x => Reflex (SpiderTimeline x :: Type)

Defined in Reflex.Spider.Internal

Associated Types

data Behavior (SpiderTimeline x) a :: Type

data Event (SpiderTimeline x) a :: Type

data Dynamic (SpiderTimeline x) a :: Type

data Incremental (SpiderTimeline x) a :: Type

type PushM (SpiderTimeline x) :: Type -> Type

type PullM (SpiderTimeline x) :: Type -> Type

Methods

never :: Event (SpiderTimeline x) a

constant :: a -> Behavior (SpiderTimeline x) a

push :: (a -> PushM (SpiderTimeline x) (Maybe b)) -> Event (SpiderTimeline x) a -> Event (SpiderTimeline x) b

pushCheap :: (a -> PushM (SpiderTimeline x) (Maybe b)) -> Event (SpiderTimeline x) a -> Event (SpiderTimeline x) b

pull :: PullM (SpiderTimeline x) a -> Behavior (SpiderTimeline x) a

mergeG :: GCompare k => (forall (a :: k). q a -> Event (SpiderTimeline x) (v a)) -> DMap k q -> Event (SpiderTimeline x) (DMap k v)

fanG :: GCompare k => Event (SpiderTimeline x) (DMap k v) -> EventSelectorG (SpiderTimeline x) k v

switch :: Behavior (SpiderTimeline x) (Event (SpiderTimeline x) a) -> Event (SpiderTimeline x) a

coincidence :: Event (SpiderTimeline x) (Event (SpiderTimeline x) a) -> Event (SpiderTimeline x) a

current :: Dynamic (SpiderTimeline x) a -> Behavior (SpiderTimeline x) a

updated :: Dynamic (SpiderTimeline x) a -> Event (SpiderTimeline x) a

unsafeBuildDynamic :: PullM (SpiderTimeline x) a -> Event (SpiderTimeline x) a -> Dynamic (SpiderTimeline x) a

unsafeBuildIncremental :: Patch p => PullM (SpiderTimeline x) (PatchTarget p) -> Event (SpiderTimeline x) p -> Incremental (SpiderTimeline x) p

mergeIncrementalG :: GCompare k => (forall (a :: k). q a -> Event (SpiderTimeline x) (v a)) -> Incremental (SpiderTimeline x) (PatchDMap k q) -> Event (SpiderTimeline x) (DMap k v)

mergeIncrementalWithMoveG :: GCompare k => (forall (a :: k). q a -> Event (SpiderTimeline x) (v a)) -> Incremental (SpiderTimeline x) (PatchDMapWithMove k q) -> Event (SpiderTimeline x) (DMap k v)

currentIncremental :: Patch p => Incremental (SpiderTimeline x) p -> Behavior (SpiderTimeline x) (PatchTarget p)

updatedIncremental :: Patch p => Incremental (SpiderTimeline x) p -> Event (SpiderTimeline x) p

incrementalToDynamic :: Patch p => Incremental (SpiderTimeline x) p -> Dynamic (SpiderTimeline x) (PatchTarget p)

behaviorCoercion :: Coercion a b -> Coercion (Behavior (SpiderTimeline x) a) (Behavior (SpiderTimeline x) b)

eventCoercion :: Coercion a b -> Coercion (Event (SpiderTimeline x) a) (Event (SpiderTimeline x) b)

dynamicCoercion :: Coercion a b -> Coercion (Dynamic (SpiderTimeline x) a) (Dynamic (SpiderTimeline x) b)

incrementalCoercion :: Coercion (PatchTarget a) (PatchTarget b) -> Coercion a b -> Coercion (Incremental (SpiderTimeline x) a) (Incremental (SpiderTimeline x) b)

mergeIntIncremental :: Incremental (SpiderTimeline x) (PatchIntMap (Event (SpiderTimeline x) a)) -> Event (SpiderTimeline x) (IntMap a)

fanInt :: Event (SpiderTimeline x) (IntMap a) -> EventSelectorInt (SpiderTimeline x) a

Reflex t => Reflex (ProfiledTimeline t :: Type)

Defined in Reflex.Profiled

Associated Types

data Behavior (ProfiledTimeline t) a :: Type

data Event (ProfiledTimeline t) a :: Type

data Dynamic (ProfiledTimeline t) a :: Type

data Incremental (ProfiledTimeline t) a :: Type

type PushM (ProfiledTimeline t) :: Type -> Type

type PullM (ProfiledTimeline t) :: Type -> Type

Methods

never :: Event (ProfiledTimeline t) a

constant :: a -> Behavior (ProfiledTimeline t) a

push :: (a -> PushM (ProfiledTimeline t) (Maybe b)) -> Event (ProfiledTimeline t) a -> Event (ProfiledTimeline t) b

pushCheap :: (a -> PushM (ProfiledTimeline t) (Maybe b)) -> Event (ProfiledTimeline t) a -> Event (ProfiledTimeline t) b

pull :: PullM (ProfiledTimeline t) a -> Behavior (ProfiledTimeline t) a

mergeG :: GCompare k => (forall (a :: k). q a -> Event (ProfiledTimeline t) (v a)) -> DMap k q -> Event (ProfiledTimeline t) (DMap k v)

fanG :: GCompare k => Event (ProfiledTimeline t) (DMap k v) -> EventSelectorG (ProfiledTimeline t) k v

switch :: Behavior (ProfiledTimeline t) (Event (ProfiledTimeline t) a) -> Event (ProfiledTimeline t) a

coincidence :: Event (ProfiledTimeline t) (Event (ProfiledTimeline t) a) -> Event (ProfiledTimeline t) a

current :: Dynamic (ProfiledTimeline t) a -> Behavior (ProfiledTimeline t) a

updated :: Dynamic (ProfiledTimeline t) a -> Event (ProfiledTimeline t) a

unsafeBuildDynamic :: PullM (ProfiledTimeline t) a -> Event (ProfiledTimeline t) a -> Dynamic (ProfiledTimeline t) a

unsafeBuildIncremental :: Patch p => PullM (ProfiledTimeline t) (PatchTarget p) -> Event (ProfiledTimeline t) p -> Incremental (ProfiledTimeline t) p

mergeIncrementalG :: GCompare k => (forall (a :: k). q a -> Event (ProfiledTimeline t) (v a)) -> Incremental (ProfiledTimeline t) (PatchDMap k q) -> Event (ProfiledTimeline t) (DMap k v)

mergeIncrementalWithMoveG :: GCompare k => (forall (a :: k). q a -> Event (ProfiledTimeline t) (v a)) -> Incremental (ProfiledTimeline t) (PatchDMapWithMove k q) -> Event (ProfiledTimeline t) (DMap k v)

currentIncremental :: Patch p => Incremental (ProfiledTimeline t) p -> Behavior (ProfiledTimeline t) (PatchTarget p)

updatedIncremental :: Patch p => Incremental (ProfiledTimeline t) p -> Event (ProfiledTimeline t) p

incrementalToDynamic :: Patch p => Incremental (ProfiledTimeline t) p -> Dynamic (ProfiledTimeline t) (PatchTarget p)

behaviorCoercion :: Coercion a b -> Coercion (Behavior (ProfiledTimeline t) a) (Behavior (ProfiledTimeline t) b)

eventCoercion :: Coercion a b -> Coercion (Event (ProfiledTimeline t) a) (Event (ProfiledTimeline t) b)

dynamicCoercion :: Coercion a b -> Coercion (Dynamic (ProfiledTimeline t) a) (Dynamic (ProfiledTimeline t) b)

incrementalCoercion :: Coercion (PatchTarget a) (PatchTarget b) -> Coercion a b -> Coercion (Incremental (ProfiledTimeline t) a) (Incremental (ProfiledTimeline t) b)

mergeIntIncremental :: Incremental (ProfiledTimeline t) (PatchIntMap (Event (ProfiledTimeline t) a)) -> Event (ProfiledTimeline t) (IntMap a)

fanInt :: Event (ProfiledTimeline t) (IntMap a) -> EventSelectorInt (ProfiledTimeline t) a

mergeInt :: Reflex t => IntMap (Event t a) -> Event t (IntMap a)

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

coerceBehavior :: (Reflex t, Coercible a b) => Behavior t a -> Behavior t b

Coerce a Behavior between representationally-equivalent value types

coerceEvent :: (Reflex t, Coercible a b) => Event t a -> Event t b

Coerce an Event between representationally-equivalent occurrence types

coerceDynamic :: (Reflex t, Coercible a b) => Dynamic t a -> Dynamic t b

Coerce a Dynamic between representationally-equivalent value types

coerceIncremental :: (Reflex t, Coercible a b, Coercible (PatchTarget a) (PatchTarget b)) => Incremental t a -> Incremental t b

Coerce an Incremental between representationally-equivalent value types

class (Applicative m, Monad m) => MonadSample t m | m -> t where

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

Methods

sample :: Behavior t a -> m a

Get the current value in the Behavior

Instances

MonadSample t m => MonadSample (t :: k) (ExceptT e m)

Defined in Reflex.Class

Methods

sample :: Behavior t a -> ExceptT e m a

MonadSample t m => MonadSample (t :: k) (StateT s m)

Defined in Reflex.Class

Methods

sample :: Behavior t a -> StateT s m a

(MonadSample t m, Monoid r) => MonadSample (t :: k) (WriterT r m)

Defined in Reflex.Class

Methods

sample :: Behavior t a -> WriterT r m a

MonadSample t m => MonadSample (t :: k) (ReaderT r m)

Defined in Reflex.Class

Methods

sample :: Behavior t a -> ReaderT r m a

MonadSample t m => MonadSample (t :: k) (ContT r m)

Defined in Reflex.Class

Methods

sample :: Behavior t a -> ContT r m a

(MonadSample t m, Monoid w) => MonadSample (t :: k) (RWST r w s m)

Defined in Reflex.Class

Methods

sample :: Behavior t a -> RWST r w s m a

MonadSample t m => MonadSample (t :: Type) (TriggerEventT t m)

Defined in Reflex.TriggerEvent.Base

Methods

sample :: Behavior t a -> TriggerEventT t m a

MonadSample t m => MonadSample (t :: Type) (PostBuildT t m)

Defined in Reflex.PostBuild.Base

Methods

sample :: Behavior t a -> PostBuildT t m a

ReflexHost t => MonadSample (t :: Type) (PerformEventT t m)

Defined in Reflex.PerformEvent.Base

Methods

sample :: Behavior t a -> PerformEventT t m a

MonadSample t m => MonadSample (t :: Type) (EventWriterT t w m)

Defined in Reflex.EventWriter.Base

Methods

sample :: Behavior t a -> EventWriterT t w m a

MonadSample t m => MonadSample (t :: Type) (QueryT t q m)

Defined in Reflex.Query.Base

Methods

sample :: Behavior t a -> QueryT t q m a

MonadSample t m => MonadSample (t :: Type) (DynamicWriterT t w m)

Defined in Reflex.DynamicWriter.Base

Methods

sample :: Behavior t a -> DynamicWriterT t w m a

MonadSample t m => MonadSample (t :: Type) (BehaviorWriterT t w m)

Defined in Reflex.BehaviorWriter.Base

Methods

sample :: Behavior t a -> BehaviorWriterT t w m a

MonadSample t m => MonadSample (t :: Type) (RequesterT t request response m)

Defined in Reflex.Requester.Base

Methods

sample :: Behavior t a -> RequesterT t request response m a

MonadSample (Pure t :: Type) ((->) t :: Type -> Type)

Defined in Reflex.Pure

Methods

sample :: Behavior (Pure t) a -> t -> a

HasSpiderTimeline x => MonadSample (SpiderTimeline x :: Type) (SpiderHost x)

Defined in Reflex.Spider.Internal

Methods

sample :: Behavior (SpiderTimeline x) a -> SpiderHost x a

HasSpiderTimeline x => MonadSample (SpiderTimeline x :: Type) (SpiderHostFrame x)

Defined in Reflex.Spider.Internal

Methods

sample :: Behavior (SpiderTimeline x) a -> SpiderHostFrame x a

HasSpiderTimeline x => MonadSample (SpiderTimeline x :: Type) (SpiderPushM x)

Defined in Reflex.Spider.Internal

Methods

sample :: Behavior (SpiderTimeline x) a -> SpiderPushM x a

MonadSample (SpiderTimeline x :: Type) (SpiderPullM x)

Defined in Reflex.Spider.Internal

Methods

sample :: Behavior (SpiderTimeline x) a -> SpiderPullM x a

HasSpiderTimeline x => MonadSample (SpiderTimeline x :: Type) (ReadPhase x)

Defined in Reflex.Spider.Internal

Methods

sample :: Behavior (SpiderTimeline x) a -> ReadPhase x a

HasSpiderTimeline x => MonadSample (SpiderTimeline x :: Type) (EventM x)

Defined in Reflex.Spider.Internal

Methods

sample :: Behavior (SpiderTimeline x) a -> EventM x a

MonadSample t m => MonadSample (ProfiledTimeline t :: Type) (ProfiledM m)

Defined in Reflex.Profiled

Methods

sample :: Behavior (ProfiledTimeline t) a -> ProfiledM m a

class MonadSample t m => MonadHold t m where

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.

Minimal complete definition

buildDynamic, headE

Methods

hold :: a -> Event t a -> m (Behavior t a)

Create a new Behavior whose value will initially be equal to the given value and will be updated whenever the given Event occurs. The update takes effect immediately after the Event occurs; if the occurrence that sets the Behavior (or one that is simultaneous with it) is used to sample the Behavior, it will see the old value of the Behavior, not the new one.

hold :: (m ~ f m', MonadTrans f, MonadHold t m') => a -> Event t a -> m (Behavior t a)

Create a new Behavior whose value will initially be equal to the given value and will be updated whenever the given Event occurs. The update takes effect immediately after the Event occurs; if the occurrence that sets the Behavior (or one that is simultaneous with it) is used to sample the Behavior, it will see the old value of the Behavior, not the new one.

holdDyn :: a -> Event t a -> m (Dynamic t a)

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

holdDyn :: (m ~ f m', MonadTrans f, MonadHold t m') => a -> Event t a -> m (Dynamic t a)

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

holdIncremental :: Patch p => PatchTarget p -> Event t p -> m (Incremental t p)

Create an Incremental value using the given initial value that changes every time the Event occurs.

holdIncremental :: (Patch p, m ~ f m', MonadTrans f, MonadHold t m') => PatchTarget p -> Event t p -> m (Incremental t p)

Create an Incremental value using the given initial value that changes every time the Event occurs.

buildDynamic :: PushM t a -> Event t a -> m (Dynamic t a)

headE :: Event t a -> m (Event t a)

Create a new Event that only occurs only once, on the first occurrence of the supplied Event.

now :: m (Event t ())

An event which only occurs at the current moment in time, such that:

coincidence (pushAlways (\a -> (a <$) <$> now) e) = e

now :: (m ~ f m', MonadTrans f, MonadHold t m') => m (Event t ())

An event which only occurs at the current moment in time, such that:

coincidence (pushAlways (\a -> (a <$) <$> now) e) = e

Instances

MonadHold t m => MonadHold (t :: k) (ExceptT e m)

Defined in Reflex.Class

Methods

hold :: a -> Event t a -> ExceptT e m (Behavior t a)

holdDyn :: a -> Event t a -> ExceptT e m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> ExceptT e m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> ExceptT e m (Dynamic t a)

headE :: Event t a -> ExceptT e m (Event t a)

now :: ExceptT e m (Event t ())

MonadHold t m => MonadHold (t :: k) (StateT s m)

Defined in Reflex.Class

Methods

hold :: a -> Event t a -> StateT s m (Behavior t a)

holdDyn :: a -> Event t a -> StateT s m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> StateT s m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> StateT s m (Dynamic t a)

headE :: Event t a -> StateT s m (Event t a)

now :: StateT s m (Event t ())

(MonadHold t m, Monoid r) => MonadHold (t :: k) (WriterT r m)

Defined in Reflex.Class

Methods

hold :: a -> Event t a -> WriterT r m (Behavior t a)

holdDyn :: a -> Event t a -> WriterT r m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> WriterT r m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> WriterT r m (Dynamic t a)

headE :: Event t a -> WriterT r m (Event t a)

now :: WriterT r m (Event t ())

MonadHold t m => MonadHold (t :: k) (ReaderT r m)

Defined in Reflex.Class

Methods

hold :: a -> Event t a -> ReaderT r m (Behavior t a)

holdDyn :: a -> Event t a -> ReaderT r m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> ReaderT r m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> ReaderT r m (Dynamic t a)

headE :: Event t a -> ReaderT r m (Event t a)

now :: ReaderT r m (Event t ())

MonadHold t m => MonadHold (t :: k) (ContT r m)

Defined in Reflex.Class

Methods

hold :: a -> Event t a -> ContT r m (Behavior t a)

holdDyn :: a -> Event t a -> ContT r m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> ContT r m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> ContT r m (Dynamic t a)

headE :: Event t a -> ContT r m (Event t a)

now :: ContT r m (Event t ())

(MonadHold t m, Monoid w) => MonadHold (t :: k) (RWST r w s m)

Defined in Reflex.Class

Methods

hold :: a -> Event t a -> RWST r w s m (Behavior t a)

holdDyn :: a -> Event t a -> RWST r w s m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> RWST r w s m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> RWST r w s m (Dynamic t a)

headE :: Event t a -> RWST r w s m (Event t a)

now :: RWST r w s m (Event t ())

MonadHold t m => MonadHold (t :: Type) (TriggerEventT t m)

Defined in Reflex.TriggerEvent.Base

Methods

hold :: a -> Event t a -> TriggerEventT t m (Behavior t a)

holdDyn :: a -> Event t a -> TriggerEventT t m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> TriggerEventT t m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> TriggerEventT t m (Dynamic t a)

headE :: Event t a -> TriggerEventT t m (Event t a)

now :: TriggerEventT t m (Event t ())

MonadHold t m => MonadHold (t :: Type) (PostBuildT t m)

Defined in Reflex.PostBuild.Base

Methods

hold :: a -> Event t a -> PostBuildT t m (Behavior t a)

holdDyn :: a -> Event t a -> PostBuildT t m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> PostBuildT t m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> PostBuildT t m (Dynamic t a)

headE :: Event t a -> PostBuildT t m (Event t a)

now :: PostBuildT t m (Event t ())

(ReflexHost t, MonadHold t m) => MonadHold (t :: Type) (PerformEventT t m)

Defined in Reflex.PerformEvent.Base

Methods

hold :: a -> Event t a -> PerformEventT t m (Behavior t a)

holdDyn :: a -> Event t a -> PerformEventT t m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> PerformEventT t m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> PerformEventT t m (Dynamic t a)

headE :: Event t a -> PerformEventT t m (Event t a)

now :: PerformEventT t m (Event t ())

MonadHold t m => MonadHold (t :: Type) (EventWriterT t w m)

Defined in Reflex.EventWriter.Base

Methods

hold :: a -> Event t a -> EventWriterT t w m (Behavior t a)

holdDyn :: a -> Event t a -> EventWriterT t w m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> EventWriterT t w m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> EventWriterT t w m (Dynamic t a)

headE :: Event t a -> EventWriterT t w m (Event t a)

now :: EventWriterT t w m (Event t ())

MonadHold t m => MonadHold (t :: Type) (QueryT t q m)

Defined in Reflex.Query.Base

Methods

hold :: a -> Event t a -> QueryT t q m (Behavior t a)

holdDyn :: a -> Event t a -> QueryT t q m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> QueryT t q m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> QueryT t q m (Dynamic t a)

headE :: Event t a -> QueryT t q m (Event t a)

now :: QueryT t q m (Event t ())

MonadHold t m => MonadHold (t :: Type) (DynamicWriterT t w m)

Defined in Reflex.DynamicWriter.Base

Methods

hold :: a -> Event t a -> DynamicWriterT t w m (Behavior t a)

holdDyn :: a -> Event t a -> DynamicWriterT t w m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> DynamicWriterT t w m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> DynamicWriterT t w m (Dynamic t a)

headE :: Event t a -> DynamicWriterT t w m (Event t a)

now :: DynamicWriterT t w m (Event t ())

MonadHold t m => MonadHold (t :: Type) (BehaviorWriterT t w m)

Defined in Reflex.BehaviorWriter.Base

Methods

hold :: a -> Event t a -> BehaviorWriterT t w m (Behavior t a)

holdDyn :: a -> Event t a -> BehaviorWriterT t w m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> BehaviorWriterT t w m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> BehaviorWriterT t w m (Dynamic t a)

headE :: Event t a -> BehaviorWriterT t w m (Event t a)

now :: BehaviorWriterT t w m (Event t ())

MonadHold t m => MonadHold (t :: Type) (RequesterT t request response m)

Defined in Reflex.Requester.Base

Methods

hold :: a -> Event t a -> RequesterT t request response m (Behavior t a)

holdDyn :: a -> Event t a -> RequesterT t request response m (Dynamic t a)

holdIncremental :: Patch p => PatchTarget p -> Event t p -> RequesterT t request response m (Incremental t p)

buildDynamic :: PushM t a -> Event t a -> RequesterT t request response m (Dynamic t a)

headE :: Event t a -> RequesterT t request response m (Event t a)

now :: RequesterT t request response m (Event t ())

(Enum t, HasTrie t, Ord t) => MonadHold (Pure t :: Type) ((->) t :: Type -> Type)

Defined in Reflex.Pure

Methods

hold :: a -> Event (Pure t) a -> t -> Behavior (Pure t) a

holdDyn :: a -> Event (Pure t) a -> t -> Dynamic (Pure t) a

holdIncremental :: Patch p => PatchTarget p -> Event (Pure t) p -> t -> Incremental (Pure t) p

buildDynamic :: PushM (Pure t) a -> Event (Pure t) a -> t -> Dynamic (Pure t) a

headE :: Event (Pure t) a -> t -> Event (Pure t) a

now :: t -> Event (Pure t) ()

HasSpiderTimeline x => MonadHold (SpiderTimeline x :: Type) (SpiderHostFrame x)

Defined in Reflex.Spider.Internal

Methods

hold :: a -> Event (SpiderTimeline x) a -> SpiderHostFrame x (Behavior (SpiderTimeline x) a)

holdDyn :: a -> Event (SpiderTimeline x) a -> SpiderHostFrame x (Dynamic (SpiderTimeline x) a)

holdIncremental :: Patch p => PatchTarget p -> Event (SpiderTimeline x) p -> SpiderHostFrame x (Incremental (SpiderTimeline x) p)

buildDynamic :: PushM (SpiderTimeline x) a -> Event (SpiderTimeline x) a -> SpiderHostFrame x (Dynamic (SpiderTimeline x) a)

headE :: Event (SpiderTimeline x) a -> SpiderHostFrame x (Event (SpiderTimeline x) a)

now :: SpiderHostFrame x (Event (SpiderTimeline x) ())

HasSpiderTimeline x => MonadHold (SpiderTimeline x :: Type) (SpiderHost x)

Defined in Reflex.Spider.Internal

Methods

hold :: a -> Event (SpiderTimeline x) a -> SpiderHost x (Behavior (SpiderTimeline x) a)

holdDyn :: a -> Event (SpiderTimeline x) a -> SpiderHost x (Dynamic (SpiderTimeline x) a)

holdIncremental :: Patch p => PatchTarget p -> Event (SpiderTimeline x) p -> SpiderHost x (Incremental (SpiderTimeline x) p)

buildDynamic :: PushM (SpiderTimeline x) a -> Event (SpiderTimeline x) a -> SpiderHost x (Dynamic (SpiderTimeline x) a)

headE :: Event (SpiderTimeline x) a -> SpiderHost x (Event (SpiderTimeline x) a)

now :: SpiderHost x (Event (SpiderTimeline x) ())

HasSpiderTimeline x => MonadHold (SpiderTimeline x :: Type) (SpiderPushM x)

Defined in Reflex.Spider.Internal

Methods

hold :: a -> Event (SpiderTimeline x) a -> SpiderPushM x (Behavior (SpiderTimeline x) a)

holdDyn :: a -> Event (SpiderTimeline x) a -> SpiderPushM x (Dynamic (SpiderTimeline x) a)

holdIncremental :: Patch p => PatchTarget p -> Event (SpiderTimeline x) p -> SpiderPushM x (Incremental (SpiderTimeline x) p)

buildDynamic :: PushM (SpiderTimeline x) a -> Event (SpiderTimeline x) a -> SpiderPushM x (Dynamic (SpiderTimeline x) a)

headE :: Event (SpiderTimeline x) a -> SpiderPushM x (Event (SpiderTimeline x) a)

now :: SpiderPushM x (Event (SpiderTimeline x) ())

HasSpiderTimeline x => MonadHold (SpiderTimeline x :: Type) (ReadPhase x)

Defined in Reflex.Spider.Internal

Methods

hold :: a -> Event (SpiderTimeline x) a -> ReadPhase x (Behavior (SpiderTimeline x) a)

holdDyn :: a -> Event (SpiderTimeline x) a -> ReadPhase x (Dynamic (SpiderTimeline x) a)

holdIncremental :: Patch p => PatchTarget p -> Event (SpiderTimeline x) p -> ReadPhase x (Incremental (SpiderTimeline x) p)

buildDynamic :: PushM (SpiderTimeline x) a -> Event (SpiderTimeline x) a -> ReadPhase x (Dynamic (SpiderTimeline x) a)

headE :: Event (SpiderTimeline x) a -> ReadPhase x (Event (SpiderTimeline x) a)

now :: ReadPhase x (Event (SpiderTimeline x) ())

HasSpiderTimeline x => MonadHold (SpiderTimeline x :: Type) (EventM x)

Defined in Reflex.Spider.Internal

Methods

hold :: a -> Event (SpiderTimeline x) a -> EventM x (Behavior (SpiderTimeline x) a)

holdDyn :: a -> Event (SpiderTimeline x) a -> EventM x (Dynamic (SpiderTimeline x) a)

holdIncremental :: Patch p => PatchTarget p -> Event (SpiderTimeline x) p -> EventM x (Incremental (SpiderTimeline x) p)

buildDynamic :: PushM (SpiderTimeline x) a -> Event (SpiderTimeline x) a -> EventM x (Dynamic (SpiderTimeline x) a)

headE :: Event (SpiderTimeline x) a -> EventM x (Event (SpiderTimeline x) a)

now :: EventM x (Event (SpiderTimeline x) ())

MonadHold t m => MonadHold (ProfiledTimeline t :: Type) (ProfiledM m)

Defined in Reflex.Profiled

Methods

hold :: a -> Event (ProfiledTimeline t) a -> ProfiledM m (Behavior (ProfiledTimeline t) a)

holdDyn :: a -> Event (ProfiledTimeline t) a -> ProfiledM m (Dynamic (ProfiledTimeline t) a)

holdIncremental :: Patch p => PatchTarget p -> Event (ProfiledTimeline t) p -> ProfiledM m (Incremental (ProfiledTimeline t) p)

buildDynamic :: PushM (ProfiledTimeline t) a -> Event (ProfiledTimeline t) a -> ProfiledM m (Dynamic (ProfiledTimeline t) a)

headE :: Event (ProfiledTimeline t) a -> ProfiledM m (Event (ProfiledTimeline t) a)

now :: ProfiledM m (Event (ProfiledTimeline t) ())

fan related types

newtype EventSelector t k

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.

Constructors

EventSelector

Fields

• select :: forall a. k a -> Event t a

  Retrieve the Event for the given key. The type of the Event is determined by the type of the key, so this can be used to fan-out Events whose sub-Events have different types.

  Using EventSelectors and the fan primitive is far more efficient than (but equivalent to) using mapMaybe to select only the relevant occurrences of an Event.

newtype EventSelectorG t k v

Constructors

EventSelectorG

Fields

• selectG :: forall a. k a -> Event t (v a)

  Retrieve the Event for the given key. The type of the Event is determined by the type of the key, so this can be used to fan-out Events whose sub-Events have different types.

  Using EventSelectors and the fan primitive is far more efficient than (but equivalent to) using mapMaybe to select only the relevant occurrences of an Event.

newtype EventSelectorInt t a

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

Constructors

EventSelectorInt

Fields

• selectInt :: Int -> Event t a

Convenience functions

constDyn :: Reflex t => a -> Dynamic t a

Construct a Dynamic value that never changes

pushAlways :: Reflex t => (a -> PushM t b) -> Event t a -> Event t b

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

Combining Events

leftmost :: Reflex t => [Event t a] -> Event t a

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 :: (Reflex t, GCompare k) => DMap k (Event t) -> Event t (DMap k Identity)

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

mergeIncremental :: (Reflex t, GCompare k) => Incremental t (PatchDMap k (Event t)) -> Event t (DMap k Identity)

Create a merge whose parents can change over time

mergeIncrementalWithMove :: (Reflex t, GCompare k) => Incremental t (PatchDMapWithMove k (Event t)) -> Event t (DMap k Identity)

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

mergeMap :: (Reflex t, Ord k) => Map k (Event t a) -> Event t (Map k a)

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.

mergeIntMap :: Reflex t => IntMap (Event t a) -> Event t (IntMap a)

Like mergeMap but for IntMap.

mergeMapIncremental :: (Reflex t, Ord k) => Incremental t (PatchMap k (Event t a)) -> Event t (Map k a)

Create a merge whose parents can change over time

mergeMapIncrementalWithMove :: (Reflex t, Ord k) => Incremental t (PatchMapWithMove k (Event t a)) -> Event t (Map k a)

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

mergeIntMapIncremental :: Reflex t => Incremental t (PatchIntMap (Event t a)) -> Event t (IntMap a)

Create a merge whose parents can change over time

coincidencePatchMap :: (Reflex t, Ord k) => Event t (PatchMap k (Event t v)) -> Event t (PatchMap k v)

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

coincidencePatchMapWithMove :: (Reflex t, Ord k) => Event t (PatchMapWithMove k (Event t v)) -> Event t (PatchMapWithMove k v)

See coincidencePatchMap

coincidencePatchIntMap :: Reflex t => Event t (PatchIntMap (Event t v)) -> Event t (PatchIntMap v)

See coincidencePatchMap

mergeList :: Reflex t => [Event t a] -> Event t (NonEmpty a)

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.

mergeWith :: Reflex t => (a -> a -> a) -> [Event t a] -> Event t a

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.

difference :: Reflex t => Event t a -> Event t b -> Event t a

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

alignEventWithMaybe :: Reflex t => (These a b -> Maybe c) -> Event t a -> Event t b -> Event t c

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

Breaking up Events

splitE :: Reflex t => Event t (a, b) -> (Event t a, Event t b)

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

fan :: forall t k. (Reflex t, GCompare k) => Event t (DMap k Identity) -> EventSelector t k

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

fanEither :: Reflex t => Event t (Either a b) -> (Event t a, Event t b)

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

fanThese :: Reflex t => Event t (These a b) -> (Event t a, Event t b)

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

fanMap :: (Reflex t, Ord k) => Event t (Map k a) -> EventSelector t (Const2 k a)

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

dmapToThese :: DMap (EitherTag a b) Identity -> Maybe (These a b)

Extract the values of a DMap of EitherTags.

data EitherTag (l :: k) (r :: k) (a :: k) :: forall k. k -> k -> k -> Type where

Tag type for Either to use it as a DSum.

Constructors

LeftTag :: forall k (l :: k) (r :: k) (a :: k). EitherTag l r l

RightTag :: forall k (l :: k) (r :: k) (a :: k). EitherTag l r r

Instances

GCompare (EitherTag l r :: k -> Type)

Defined in Data.Functor.Misc

Methods

gcompare :: EitherTag l r a -> EitherTag l r b -> GOrdering a b

GEq (EitherTag l r :: k -> Type)

Defined in Data.Functor.Misc

Methods

geq :: EitherTag l r a -> EitherTag l r b -> Maybe (a :~: b)

GShow (EitherTag l r :: k -> Type)

Defined in Data.Functor.Misc

Methods

gshowsPrec :: Int -> EitherTag l r a -> ShowS

Eq (EitherTag l r a)

Defined in Data.Functor.Misc

Methods

(==) :: EitherTag l r a -> EitherTag l r a -> Bool

(/=) :: EitherTag l r a -> EitherTag l r a -> Bool

Ord (EitherTag l r a)

Defined in Data.Functor.Misc

Methods

compare :: EitherTag l r a -> EitherTag l r a -> Ordering

(<) :: EitherTag l r a -> EitherTag l r a -> Bool

(<=) :: EitherTag l r a -> EitherTag l r a -> Bool

(>) :: EitherTag l r a -> EitherTag l r a -> Bool

(>=) :: EitherTag l r a -> EitherTag l r a -> Bool

max :: EitherTag l r a -> EitherTag l r a -> EitherTag l r a

min :: EitherTag l r a -> EitherTag l r a -> EitherTag l r a

Show (EitherTag l r a)

Defined in Data.Functor.Misc

Methods

showsPrec :: Int -> EitherTag l r a -> ShowS

show :: EitherTag l r a -> String

showList :: [EitherTag l r a] -> ShowS

eitherToDSum :: Either a b -> DSum (EitherTag a b) Identity

Convert Either to a DSum. Inverse of dsumToEither.

dsumToEither :: DSum (EitherTag a b) Identity -> Either a b

Convert DSum to Either. Inverse of eitherToDSum.

factorEvent :: forall t m k v a. (Reflex t, MonadFix m, MonadHold t m, GEq k) => k a -> Event t (DSum k v) -> m (Event t (v a), Event t (DSum k (Product v (Compose (Event t) v))))

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.

filterEventKey :: forall t m k v a. (Reflex t, MonadFix m, MonadHold t m, GEq k) => k a -> Event t (DSum k v) -> m (Event t (v a))

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

Collapsing 'Event . Event'

switchHold :: (Reflex t, MonadHold t m) => Event t a -> Event t (Event t a) -> m (Event t a)

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.

switchHoldPromptly :: (Reflex t, MonadHold t m) => Event t a -> Event t (Event t a) -> m (Event t a)

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.

switchHoldPromptOnly :: (Reflex t, MonadHold t m) => Event t a -> Event t (Event t a) -> m (Event t a)

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.

switchHoldPromptOnlyIncremental :: forall t m p pt w. (Reflex t, MonadHold t m, Patch (p (Event t w)), PatchTarget (p (Event t w)) ~ pt (Event t w), Patch (p w), PatchTarget (p w) ~ pt w, Monoid (pt w)) => (Incremental t (p (Event t w)) -> Event t (pt w)) -> (Event t (p (Event t w)) -> Event t (p w)) -> pt (Event t w) -> Event t (p (Event t w)) -> m (Event t (pt w))

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.

Using Events to sample Behaviors

tag :: Reflex t => Behavior t b -> Event t a -> Event t b

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

tagMaybe :: Reflex t => Behavior t (Maybe b) -> Event t a -> Event t b

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.

attach :: Reflex t => Behavior t a -> Event t b -> Event t (a, b)

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

attachWith :: Reflex t => (a -> b -> c) -> Behavior t a -> Event t b -> Event t c

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

attachWithMaybe :: Reflex t => (a -> b -> Maybe c) -> Behavior t a -> Event t b -> Event t c

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

Blocking an Event based on a Behavior

gate :: Reflex t => Behavior t Bool -> Event t a -> Event t a

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

Combining Dynamics

distributeDMapOverDynPure :: forall t k. (Reflex t, GCompare k) => DMap k (Dynamic t) -> Dynamic t (DMap k Identity)

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.

distributeDMapOverDynPureG :: forall t k q v. (Reflex t, GCompare k) => (forall a. q a -> Dynamic t (v a)) -> DMap k q -> Dynamic t (DMap k v)

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.

distributeListOverDyn :: Reflex t => [Dynamic t a] -> Dynamic t [a]

Convert a list of Dynamics into a Dynamic list.

distributeListOverDynWith :: Reflex t => ([a] -> b) -> [Dynamic t a] -> Dynamic t b

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

zipDyn :: Reflex t => Dynamic t a -> Dynamic t b -> Dynamic t (a, b)

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

zipDynWith :: Reflex t => (a -> b -> c) -> Dynamic t a -> Dynamic t b -> Dynamic t c

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

Accumulating state

class Reflex t => Accumulator t f | f -> t where

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

Minimal complete definition

accumMaybeM, mapAccumMaybeM

Methods

accum :: (MonadHold t m, MonadFix m) => (a -> b -> a) -> a -> Event t b -> m (f a)

accumM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t a) -> a -> Event t b -> m (f a)

accumMaybe :: (MonadHold t m, MonadFix m) => (a -> b -> Maybe a) -> a -> Event t b -> m (f a)

accumMaybeM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a)) -> a -> Event t b -> m (f a)

mapAccum :: (MonadHold t m, MonadFix m) => (a -> b -> (a, c)) -> a -> Event t b -> m (f a, Event t c)

mapAccumM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (a, c)) -> a -> Event t b -> m (f a, Event t c)

mapAccumMaybe :: (MonadHold t m, MonadFix m) => (a -> b -> (Maybe a, Maybe c)) -> a -> Event t b -> m (f a, Event t c)

mapAccumMaybeM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a, Maybe c)) -> a -> Event t b -> m (f a, Event t c)

Instances

Reflex t => Accumulator (t :: k) (Event t)

Defined in Reflex.Class

Methods

accum :: (MonadHold t m, MonadFix m) => (a -> b -> a) -> a -> Event t b -> m (Event t a)

accumM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t a) -> a -> Event t b -> m (Event t a)

accumMaybe :: (MonadHold t m, MonadFix m) => (a -> b -> Maybe a) -> a -> Event t b -> m (Event t a)

accumMaybeM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a)) -> a -> Event t b -> m (Event t a)

mapAccum :: (MonadHold t m, MonadFix m) => (a -> b -> (a, c)) -> a -> Event t b -> m (Event t a, Event t c)

mapAccumM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (a, c)) -> a -> Event t b -> m (Event t a, Event t c)

mapAccumMaybe :: (MonadHold t m, MonadFix m) => (a -> b -> (Maybe a, Maybe c)) -> a -> Event t b -> m (Event t a, Event t c)

mapAccumMaybeM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a, Maybe c)) -> a -> Event t b -> m (Event t a, Event t c)

Reflex t => Accumulator (t :: k) (Behavior t)

Defined in Reflex.Class

Methods

accum :: (MonadHold t m, MonadFix m) => (a -> b -> a) -> a -> Event t b -> m (Behavior t a)

accumM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t a) -> a -> Event t b -> m (Behavior t a)

accumMaybe :: (MonadHold t m, MonadFix m) => (a -> b -> Maybe a) -> a -> Event t b -> m (Behavior t a)

accumMaybeM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a)) -> a -> Event t b -> m (Behavior t a)

mapAccum :: (MonadHold t m, MonadFix m) => (a -> b -> (a, c)) -> a -> Event t b -> m (Behavior t a, Event t c)

mapAccumM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (a, c)) -> a -> Event t b -> m (Behavior t a, Event t c)

mapAccumMaybe :: (MonadHold t m, MonadFix m) => (a -> b -> (Maybe a, Maybe c)) -> a -> Event t b -> m (Behavior t a, Event t c)

mapAccumMaybeM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a, Maybe c)) -> a -> Event t b -> m (Behavior t a, Event t c)

Reflex t => Accumulator (t :: k) (Dynamic t)

Defined in Reflex.Class

Methods

accum :: (MonadHold t m, MonadFix m) => (a -> b -> a) -> a -> Event t b -> m (Dynamic t a)

accumM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t a) -> a -> Event t b -> m (Dynamic t a)

accumMaybe :: (MonadHold t m, MonadFix m) => (a -> b -> Maybe a) -> a -> Event t b -> m (Dynamic t a)

accumMaybeM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a)) -> a -> Event t b -> m (Dynamic t a)

mapAccum :: (MonadHold t m, MonadFix m) => (a -> b -> (a, c)) -> a -> Event t b -> m (Dynamic t a, Event t c)

mapAccumM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (a, c)) -> a -> Event t b -> m (Dynamic t a, Event t c)

mapAccumMaybe :: (MonadHold t m, MonadFix m) => (a -> b -> (Maybe a, Maybe c)) -> a -> Event t b -> m (Dynamic t a, Event t c)

mapAccumMaybeM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a, Maybe c)) -> a -> Event t b -> m (Dynamic t a, Event t c)

Reflex t => Accumulator (t :: Type) (UniqDynamic t)

Defined in Reflex.Dynamic.Uniq

Methods

accum :: (MonadHold t m, MonadFix m) => (a -> b -> a) -> a -> Event t b -> m (UniqDynamic t a)

accumM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t a) -> a -> Event t b -> m (UniqDynamic t a)

accumMaybe :: (MonadHold t m, MonadFix m) => (a -> b -> Maybe a) -> a -> Event t b -> m (UniqDynamic t a)

accumMaybeM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a)) -> a -> Event t b -> m (UniqDynamic t a)

mapAccum :: (MonadHold t m, MonadFix m) => (a -> b -> (a, c)) -> a -> Event t b -> m (UniqDynamic t a, Event t c)

mapAccumM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (a, c)) -> a -> Event t b -> m (UniqDynamic t a, Event t c)

mapAccumMaybe :: (MonadHold t m, MonadFix m) => (a -> b -> (Maybe a, Maybe c)) -> a -> Event t b -> m (UniqDynamic t a, Event t c)

mapAccumMaybeM :: (MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a, Maybe c)) -> a -> Event t b -> m (UniqDynamic t a, Event t c)

accumDyn :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> a) -> a -> Event t b -> m (Dynamic t a)

Accumulate a Dynamic by folding occurrences of an Event with the provided function. See foldDyn.

accumMDyn :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> PushM t a) -> a -> Event t b -> m (Dynamic t a)

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

accumMaybeDyn :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> Maybe a) -> a -> Event t b -> m (Dynamic t a)

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

accumMaybeMDyn :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a)) -> a -> Event t b -> m (Dynamic t a)

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

mapAccumDyn :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> (a, c)) -> a -> Event t b -> m (Dynamic t a, Event t c)

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.

mapAccumMDyn :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> PushM t (a, c)) -> a -> Event t b -> m (Dynamic t a, Event t c)

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

mapAccumMaybeDyn :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> (Maybe a, Maybe c)) -> a -> Event t b -> m (Dynamic t a, Event t c)

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.

mapAccumMaybeMDyn :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a, Maybe c)) -> a -> Event t b -> m (Dynamic t a, Event t c)

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

accumB :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> a) -> a -> Event t b -> m (Behavior t a)

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

accumMB :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> PushM t a) -> a -> Event t b -> m (Behavior t a)

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

accumMaybeB :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> Maybe a) -> a -> Event t b -> m (Behavior t a)

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

accumMaybeMB :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a)) -> a -> Event t b -> m (Behavior t a)

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

mapAccumB :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> (a, c)) -> a -> Event t b -> m (Behavior t a, Event t c)

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.

mapAccumMB :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> PushM t (a, c)) -> a -> Event t b -> m (Behavior t a, Event t c)

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

mapAccumMaybeB :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> (Maybe a, Maybe c)) -> a -> Event t b -> m (Behavior t a, Event t c)

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.

mapAccumMaybeMB :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a, Maybe c)) -> a -> Event t b -> m (Behavior t a, Event t c)

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

mapAccum_ :: forall t m a b c. (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> (a, c)) -> a -> Event t b -> m (Event t c)

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

mapAccumM_ :: forall t m a b c. (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> PushM t (a, c)) -> a -> Event t b -> m (Event t c)

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

mapAccumMaybe_ :: forall t m a b c. (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> (Maybe a, Maybe c)) -> a -> Event t b -> m (Event t c)

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

mapAccumMaybeM_ :: forall t m a b c. (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> PushM t (Maybe a, Maybe c)) -> a -> Event t b -> m (Event t c)

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

accumIncremental :: (Reflex t, Patch p, MonadHold t m, MonadFix m) => (PatchTarget p -> b -> p) -> PatchTarget p -> Event t b -> m (Incremental t p)

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

accumMIncremental :: (Reflex t, Patch p, MonadHold t m, MonadFix m) => (PatchTarget p -> b -> PushM t p) -> PatchTarget p -> Event t b -> m (Incremental t p)

Similar to accumIncremental but the combining function runs in PushM

accumMaybeIncremental :: (Reflex t, Patch p, MonadHold t m, MonadFix m) => (PatchTarget p -> b -> Maybe p) -> PatchTarget p -> Event t b -> m (Incremental t p)

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

accumMaybeMIncremental :: (Reflex t, Patch p, MonadHold t m, MonadFix m) => (PatchTarget p -> b -> PushM t (Maybe p)) -> PatchTarget p -> Event t b -> m (Incremental t p)

Similar to accumMaybeMIncremental but the combining function runs in PushM

mapAccumIncremental :: (Reflex t, Patch p, MonadHold t m, MonadFix m) => (PatchTarget p -> b -> (p, c)) -> PatchTarget p -> Event t b -> m (Incremental t p, Event t c)

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.

mapAccumMIncremental :: (Reflex t, Patch p, MonadHold t m, MonadFix m) => (PatchTarget p -> b -> PushM t (p, c)) -> PatchTarget p -> Event t b -> m (Incremental t p, Event t c)

Like mapAccumIncremental but the combining function runs in PushM

mapAccumMaybeIncremental :: (Reflex t, Patch p, MonadHold t m, MonadFix m) => (PatchTarget p -> b -> (Maybe p, Maybe c)) -> PatchTarget p -> Event t b -> m (Incremental t p, Event t c)

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.

mapAccumMaybeMIncremental :: (Reflex t, Patch p, MonadHold t m, MonadFix m) => (PatchTarget p -> b -> PushM t (Maybe p, Maybe c)) -> PatchTarget p -> Event t b -> m (Incremental t p, Event t c)

Like mapAccumMaybeIncremental but the combining function is a PushM action

zipListWithEvent :: (Reflex t, MonadHold t m, MonadFix m) => (a -> b -> c) -> [a] -> Event t b -> m (Event t c)

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.

numberOccurrences :: (Reflex t, MonadHold t m, MonadFix m, Num b) => Event t a -> m (Event t (b, a))

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

numberOccurrencesFrom :: (Reflex t, MonadHold t m, MonadFix m, Num b) => b -> Event t a -> m (Event t (b, a))

Assign a number to each occurrence of the given Event

numberOccurrencesFrom_ :: (Reflex t, MonadHold t m, MonadFix m, Num b) => b -> Event t a -> m (Event t b)

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

(<@>) :: Reflex t => Behavior t (a -> b) -> Event t a -> Event t b infixl 4

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)

(<@) :: Reflex t => Behavior t b -> Event t a -> Event t b infixl 4

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.

tailE :: (Reflex t, MonadHold t m) => Event t a -> m (Event t a)

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

headTailE :: (Reflex t, MonadHold t m) => Event t a -> m (Event t a, Event t a)

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.

takeWhileE :: forall t m a. (Reflex t, MonadFix m, MonadHold t m) => (a -> Bool) -> Event t a -> m (Event t a)

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.

takeWhileJustE :: forall t m a b. (Reflex t, MonadFix m, MonadHold t m) => (a -> Maybe b) -> Event t a -> m (Event t b)

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.

dropWhileE :: forall t m a. (Reflex t, MonadFix m, MonadHold t m) => (a -> Bool) -> Event t a -> m (Event t a)

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.

takeDropWhileJustE :: forall t m a b. (Reflex t, MonadFix m, MonadHold t m) => (a -> Maybe b) -> Event t a -> m (Event t b, Event t a)

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.

switcher :: (Reflex t, MonadHold t m) => Behavior t a -> Event t (Behavior t a) -> m (Behavior t a)

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

Debugging functions

traceEvent :: (Reflex t, Show a) => String -> Event t a -> Event t a

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.

traceEventWith :: Reflex t => (a -> String) -> Event t a -> Event t a

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.

Unsafe functions

unsafeDynamic :: Reflex t => Behavior t a -> Event t a -> Dynamic t a

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.

unsafeMapIncremental :: (Reflex t, Patch p, Patch p') => (PatchTarget p -> PatchTarget p') -> (p -> p') -> Incremental t p -> Incremental t p'

Filterable convenience functions

class FunctorMaybe f

Deprecated: Use Filterable from Data.Witherable instead

A class for values that combines filtering and mapping using Maybe. Morally, FunctorMaybe ~ KleisliFunctor Maybe.

Minimal complete definition

fmapMaybe

Instances

FunctorMaybe []

Defined in Reflex.FunctorMaybe

Methods

fmapMaybe :: (a -> Maybe b) -> [a] -> [b]

FunctorMaybe Maybe

Defined in Reflex.FunctorMaybe

Methods

fmapMaybe :: (a -> Maybe b) -> Maybe a -> Maybe b

FunctorMaybe Option

Defined in Reflex.FunctorMaybe

Methods

fmapMaybe :: (a -> Maybe b) -> Option a -> Option b

FunctorMaybe IntMap

Defined in Reflex.FunctorMaybe

Methods

fmapMaybe :: (a -> Maybe b) -> IntMap a -> IntMap b

FunctorMaybe (Map k)

Defined in Reflex.FunctorMaybe

Methods

fmapMaybe :: (a -> Maybe b) -> Map k a -> Map k b

Reflex t => FunctorMaybe (Event t)

Defined in Reflex.Class

Methods

fmapMaybe :: (a -> Maybe b) -> Event t a -> Event t b

mapMaybe :: Filterable f => (a -> Maybe b) -> f a -> f b

Like mapMaybe.

fmapMaybe :: Filterable f => (a -> Maybe b) -> f a -> f b

Alias for mapMaybe

fforMaybe :: Filterable f => f a -> (a -> Maybe b) -> f b

Flipped version of mapMaybe.

ffilter :: Filterable f => (a -> Bool) -> f a -> f a

Filter 'f a' using the provided predicate.

filterLeft :: Filterable f => f (Either a b) -> f a

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

filterRight :: Filterable f => f (Either a b) -> f b

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

Miscellaneous convenience functions

ffor :: Functor f => f a -> (a -> b) -> f b

Flipped version of fmap.

ffor2 :: Applicative f => f a -> f b -> (a -> b -> c) -> f c

Rotated version of liftA2.

ffor3 :: Applicative f => f a -> f b -> f c -> (a -> b -> c -> d) -> f d

Rotated version of liftA3.

Deprecated functions

switchPromptly :: (Reflex t, MonadHold t m) => Event t a -> Event t (Event t a) -> m (Event t a)

Deprecated: Use switchHoldPromptly instead. The 'switchHold*' naming convention was chosen because those functions are more closely related to each other than they are to switch.

See switchHoldPromptly

switchPromptOnly :: (Reflex t, MonadHold t m) => Event t a -> Event t (Event t a) -> m (Event t a)

Deprecated: Use switchHoldPromptOnly instead. The 'switchHold*' naming convention was chosen because those functions are more closely related to each other than they are to switch.

See switchHoldPromptOnly

Cheap functions

fmapMaybeCheap :: Reflex t => (a -> Maybe b) -> Event t a -> Event t b

An alias for mapMaybeCheap

mapMaybeCheap :: Reflex t => (a -> Maybe b) -> Event t a -> Event t b

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

fmapCheap :: Reflex t => (a -> b) -> Event t a -> Event t b

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

fforCheap :: Reflex t => Event t a -> (a -> b) -> Event t b

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

fforMaybeCheap :: Reflex t => Event t a -> (a -> Maybe b) -> Event t b

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

pushAlwaysCheap :: Reflex t => (a -> PushM t b) -> Event t a -> Event t b

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

tagCheap :: Reflex t => Behavior t b -> Event t a -> Event t b

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

mergeWithCheap :: Reflex t => (a -> a -> a) -> [Event t a] -> Event t a

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

mergeWithCheap' :: Reflex t => (a -> b) -> (b -> b -> b) -> [Event t a] -> Event t b

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

Slow, but general, implementations

slowHeadE :: (Reflex t, MonadHold t m, MonadFix m) => Event t a -> m (Event t a)

A somewhat slow implementation of headE