FRP.Event

fix :: forall i. (Event i -> Event i) -> Event i

Compute a fixed point

keepLatest :: forall a. Event (Event a) -> Event a

Flatten a nested Event, reporting values only from the most recent inner Event.

sampleOnRight :: forall a b. Event a -> Event (a -> b) -> Event b

Create an Event which samples the latest values from the first event at the times when the second event fires.

type Backdoor = { bus :: Bus, create :: Create, createO :: CreateO, createPure :: CreatePure, createPureO :: CreatePureO, delay :: Delay, hot :: Hot, mailbox :: Mailbox, mailboxed :: Mailboxed, makeEvent :: MakeEvent, makeEventO :: MakeEventO, makeLemmingEvent :: MakeLemmingEvent, makeLemmingEventO :: MakeLemmingEventO, makePureEvent :: MakePureEvent, memoize :: Memoize, subscribe :: Subscribe, subscribeO :: SubscribeO, subscribePure :: SubscribePure, subscribePureO :: SubscribePureO }

newtype Bus

Constructors

• Bus BusT

type BusT = forall r a. ((a -> Effect Unit) -> Event a -> r) -> Event r

newtype Create

Constructors

• Create CreateT

newtype CreateO

Constructors

• CreateO CreateOT

type CreateOT = forall a. Effect (EventIO' a)

newtype CreatePure

Constructors

• CreatePure CreatePureT

newtype CreatePureO

Constructors

• CreatePureO CreatePureOT

type CreatePureOT = forall a r. ST r (PureEventIO' r a)

type CreatePureT = forall a r. ST r (PureEventIO r a)

type CreateT = forall a. Effect (EventIO a)

newtype Delay

Constructors

• Delay DelayT

type DelayT = forall a. Int -> Event a -> Event a

newtype Event a

An Event represents a collection of discrete occurrences with associated times. Conceptually, an Event is a (possibly-infinite) list of values-and-times:

type Event a = List { value :: a, time :: Time }

Events are created from real events like timers or mouse clicks, and then combined using the various functions and instances provided in this module.

Events are consumed by providing a callback using the subscribe function.

Instances

• Functor Event
• Compactable Event
• Filterable Event
• Alt Event
• Plus Event
• Apply Event
• Applicative Event
• Alternative Event
• IsEvent Event
• (Semigroup a) => Semigroup (Event a)
• (Monoid a) => Monoid (Event a)
• (HeytingAlgebra a) => HeytingAlgebra (Event a)
• (Semiring a) => Semiring (Event a)
• (Ring a) => Ring (Event a)

type EventIO a = { event :: Event a, push :: a -> Effect Unit }

type EventIO' a = { event :: Event a, push :: EffectFn1 a Unit }

newtype Hot

Constructors

• Hot HotT

type HotT = forall a. Event a -> Effect { event :: Event a, unsubscribe :: Effect Unit }

newtype Mailbox

Constructors

• Mailbox MailboxT

type MailboxT = forall a b. Ord a => Effect { event :: a -> Event b, push :: { address :: a, payload :: b } -> Effect Unit }

newtype Mailboxed

Constructors

• Mailboxed MailboxedT

type MailboxedT = forall r a b. Ord a => Event { address :: a, payload :: b } -> ((a -> Event b) -> r) -> Event r

newtype MakeEvent

Constructors

• MakeEvent MakeEventT

newtype MakeEventO

Constructors

• MakeEventO MakeEventOT

type MakeEventOT = forall a. EffectFn1 (EffectFn1 a Unit) (Effect Unit) -> Event a

type MakeEventT = forall a. ((a -> Effect Unit) -> Effect (Effect Unit)) -> Event a

newtype MakeLemmingEvent

Constructors

• MakeLemmingEvent MakeLemmingEventT

newtype MakeLemmingEventO

Constructors

• MakeLemmingEventO MakeLemmingEventOT

type MakeLemmingEventOT = forall a r. STFn2 Subscriber (STFn1 a r Unit) r (ST r Unit) -> Event a

type MakeLemmingEventT = forall a r. ((forall b. Event b -> (b -> ST r Unit) -> ST r (ST r Unit)) -> (a -> ST r Unit) -> ST r (ST r Unit)) -> Event a

newtype MakePureEvent

Constructors

• MakePureEvent MakePureEventT

type MakePureEventT = forall a r. ((a -> ST r Unit) -> ST r (ST r Unit)) -> Event a

newtype Memoize

Constructors

• Memoize MemoizeT

type MemoizeT = forall r a. Event a -> (Event a -> r) -> Event r

type PureEventIO :: Region -> Type -> Typetype PureEventIO r a = { event :: Event a, push :: a -> ST r Unit }

type PureEventIO' :: Region -> Type -> Typetype PureEventIO' r a = { event :: Event a, push :: STFn1 a r Unit }

newtype Subscribe

Constructors

• Subscribe SubscribeT

newtype SubscribeO

Constructors

• SubscribeO SubscribeOT

type SubscribeOT = forall a. EffectFn2 (Event a) (EffectFn1 a Unit) (Effect Unit)

newtype SubscribePure

Constructors

• SubscribePure SubscribePureT

newtype SubscribePureO

Constructors

• SubscribePureO SubscribePureOT

type SubscribePureOT = forall a r. STFn2 (Event a) (STFn1 a r Unit) r (ST r Unit)

type SubscribePureT = forall r a. Event a -> (a -> ST r Unit) -> ST r (ST r Unit)

type SubscribeT = forall a. Event a -> (a -> Effect Unit) -> Effect (Effect Unit)

newtype Subscriber

Constructors

• Subscriber (forall b r. STFn2 (Event b) (STFn1 b r Unit) r (ST r Unit))

backdoor :: Backdoor

burning :: forall a. a -> Event a -> Effect { event :: Event a, unsubscribe :: Effect Unit }

Makes an event burning hot. Like hot, it will start firing immediately on left bind. In addition, it always fires immediately upon subscription with the most recent value.

bus :: BusT

Creates an event bus within a closure.

merge :: forall f a. Foldable f => f (Event a) -> Event a

Merge together several events. This has the same functionality as oneOf, but it is faster and less prone to stack explosions.

create :: CreateT

Create an event and a function which supplies a value to that event.

createO :: CreateOT

createPure :: CreatePureT

Create an event and a function which supplies a value to that event in ST.

createPureO :: CreatePureOT

delay :: DelayT

hot :: HotT

Makes an event hot, meaning that it will start firing on left-bind. This means that pure should never be used with hot as it will be lost. Use this for loops, for example.

mailbox :: MailboxT

mailboxed :: MailboxedT

Takes the entire domain of a and allows for ad-hoc specialization.

makeEvent :: MakeEventT

Make an Event from a function which accepts a callback and returns an unsubscription function.

Note: you probably want to use create instead, unless you need explicit control over unsubscription.

makeEventO :: MakeEventOT

makeLemmingEvent :: MakeLemmingEventT

makeLemmingEventO :: MakeLemmingEventOT

makePureEvent :: MakePureEventT

Make a pure Event from a function which accepts a callback and returns an unsubscription function.

Note: you probably want to use create instead, unless you need explicit control over unsubscription.

memoize :: MemoizeT

Takes an event and memoizes it within a closure. All interactions with the event in the closure will not trigger a fresh subscription. Outside the closure does, however, trigger a fresh subscription.

subscribe :: SubscribeT

Subscribe to an Event by providing a callback.

subscribe returns a canceller function.

subscribeO :: SubscribeOT

Subscribe to an Event by providing a callback.

subscribe returns a canceller function.

subscribePure :: SubscribePureT

subscribePureO :: SubscribePureOT

class Filterable :: (Type -> Type) -> Constraintclass (Compactable f, Functor f) <= Filterable f  where

Filterable represents data structures which can be partitioned/filtered.

• partitionMap - partition a data structure based on an either predicate.
• partition - partition a data structure based on boolean predicate.
• filterMap - map over a data structure and filter based on a maybe.
• filter - filter a data structure based on a boolean.

Laws:

• Functor Relation: filterMap identity ≡ compact

• Functor Identity: filterMap Just ≡ identity

• Kleisli Composition: filterMap (l <=< r) ≡ filterMap l <<< filterMap r

• filter ≡ filterMap <<< maybeBool

• filterMap p ≡ filter (isJust <<< p)

• Functor Relation: partitionMap identity ≡ separate

• Functor Identity 1: _.right <<< partitionMap Right ≡ identity

• Functor Identity 2: _.left <<< partitionMap Left ≡ identity

• f <<< partition ≡ partitionMap <<< eitherBool where f = \{ no, yes } -> { left: no, right: yes }

• f <<< partitionMap p ≡ partition (isRight <<< p) where f = \{ left, right } -> { no: left, yes: right}

Default implementations are provided by the following functions:

• partitionDefault
• partitionDefaultFilter
• partitionDefaultFilterMap
• partitionMapDefault
• filterDefault
• filterDefaultPartition
• filterDefaultPartitionMap
• filterMapDefault

Members

• filterMap :: forall a b. (a -> Maybe b) -> f a -> f b

Instances

• Filterable Array
• Filterable Maybe
• (Monoid m) => Filterable (Either m)
• Filterable List
• (Ord k) => Filterable (Map k)

class IsEvent :: (Type -> Type) -> Constraintclass (Alternative event, Filterable event) <= IsEvent event  where

Functions which an Event type should implement:

• fold: combines incoming values using the specified function, starting with the specific initial value.
• keepLatest flattens a nested event, reporting values only from the most recent inner event.
• sampleOn: samples an event at the times when a second event fires.
• fix: compute a fixed point, by feeding output events back in as inputs.
• bang: A one-shot event that happens NOW.

Members

• keepLatest :: forall a. event (event a) -> event a
• sampleOnRight :: forall a b. event a -> event (a -> b) -> event b
• fix :: forall i. (event i -> event i) -> event i

withLast :: forall event a. IsEvent event => event a -> event { last :: Maybe a, now :: a }

Compute differences between successive event values.

sampleOnRight_ :: forall event a b. IsEvent event => event a -> event b -> event a

Create an Event which samples the latest values from the first event at the times when the second event fires, ignoring the values produced by the second event.

mapAccum :: forall event a b c. IsEvent event => (a -> b -> Tuple a c) -> a -> event b -> event c

Map over an event with an accumulator.

For example, to keep the index of the current event:

mapAccum (\x i -> Tuple (i + 1) (Tuple x i)) 0`.

gateBy :: forall a b event. IsEvent event => (Maybe a -> b -> Boolean) -> event a -> event b -> event b

Generalised form of gateBy, allowing for any predicate between the two events. The predicate will not be evaluated until a value from the first event is received.

gate :: forall a event. IsEvent event => event Boolean -> event a -> event a

Sample the events that are fired while a boolean event is true. Note that, until the boolean event fires, it will be assumed to be false, and events will be blocked.

folded :: forall event a. IsEvent event => Monoid a => event a -> event a

Combine subsequent events using a Monoid.

fold :: forall event a b. IsEvent event => (b -> a -> b) -> b -> event a -> event b

Fold over values received from some Event, creating a new Event.

count :: forall event a. IsEvent event => event a -> event Int

Count the number of events received.