# FRP.Event.Class

- Package
- purescript-hyrule
- Repository
- mikesol/purescript-hyrule

### #IsEvent Source

`class IsEvent :: (Type -> Type) -> Constraint`

`class (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`

`sampleOnLeft :: forall a b. event a -> event (a -> b) -> event b`

`fix :: forall i. (event i -> event i) -> event i`

### #sampleOnRightOp Source

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

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

### #sampleOnLeftOp Source

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

### #sampleOnLeft_ Source

`sampleOnLeft_ :: forall event a b. IsEvent event => event a -> event b -> event b`

### #applyOp Source

`applyOp :: forall event a b. Applicative event => event a -> event (a -> b) -> event b`

## Re-exports from **Data.**Filterable

### #Filterable Source

`class Filterable :: (Type -> Type) -> Constraint`

`class (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

`Filterable Array`

`Filterable Maybe`

`(Monoid m) => Filterable (Either m)`

`Filterable List`

`(Ord k) => Filterable (Map k)`