# FRP.Event

- Package
- purescript-event
- Repository
- paf31/purescript-event

### #keepLatest Source

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

Flatten a nested `Event`

, reporting values only from the most recent
inner `Event`

.

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

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

### #Filterable Source

`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)`

## Re-exports from **FRP.**Event.Class

### #IsEvent Source

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

#### Members

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

`keepLatest :: forall a. event (event a) -> event a`

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

`fix :: forall o i. (event i -> { input :: event i, output :: event o }) -> event o`

- Modules
- FRP.
Event - FRP.
Event. Class - FRP.
Event. Time