Module

FRP.Event

Package
purescript-hyrule
Repository
mikesol/purescript-hyrule

#fix Source

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

Compute a fixed point

#keepLatest Source

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

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

#sampleOnRight Source

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.

#Backdoor Source

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 }

#Bus Source

newtype Bus

Constructors

#BusT Source

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

#Create Source

newtype Create

Constructors

#CreateO Source

newtype CreateO

Constructors

#CreateOT Source

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

#CreatePure Source

newtype CreatePure

Constructors

#CreatePureO Source

#CreatePureOT Source

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

#CreatePureT Source

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

#CreateT Source

type CreateT = forall a. Effect (EventIO a)

#Delay Source

newtype Delay

Constructors

#DelayT Source

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

#Event Source

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

#EventIO Source

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

#EventIO' Source

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

#Hot Source

newtype Hot

Constructors

#HotT Source

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

#Mailbox Source

newtype Mailbox

Constructors

#MailboxT Source

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

#Mailboxed Source

newtype Mailboxed

Constructors

#MailboxedT Source

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

#MakeEvent Source

newtype MakeEvent

Constructors

#MakeEventO Source

newtype MakeEventO

Constructors

#MakeEventOT Source

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

#MakeEventT Source

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

#MakeLemmingEvent Source

#MakeLemmingEventOT Source

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

#MakeLemmingEventT Source

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

#MakePureEvent Source

#MakePureEventT Source

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

#Memoize Source

newtype Memoize

Constructors

#MemoizeT Source

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

#PureEventIO Source

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

#PureEventIO' Source

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

#Subscribe Source

newtype Subscribe

Constructors

#SubscribeO Source

newtype SubscribeO

Constructors

#SubscribeOT Source

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

#SubscribePure Source

#SubscribePureO Source

#SubscribePureOT Source

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

#SubscribePureT Source

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

#SubscribeT Source

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

#Subscriber Source

newtype Subscriber

Constructors

#burning Source

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 Source

bus :: BusT

Creates an event bus within a closure.

#merge Source

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 Source

create :: CreateT

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

#createPure Source

createPure :: CreatePureT

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

#hot Source

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.

#mailboxed Source

mailboxed :: MailboxedT

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

#makeEvent Source

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.

#makePureEvent Source

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 Source

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 Source

subscribe :: SubscribeT

Subscribe to an Event by providing a callback.

subscribe returns a canceller function.

#subscribeO Source

subscribeO :: SubscribeOT

Subscribe to an Event by providing a callback.

subscribe returns a canceller function.

Re-exports from FRP.Event.Class

#Filterable Source

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

Instances

#IsEvent Source

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 Source

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

Compute differences between successive event values.

#sampleOnRight_ Source

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 Source

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 Source

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 Source

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 Source

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

Combine subsequent events using a Monoid.

#fold Source

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 Source

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

Count the number of events received.