Library

Module

Module type

Parameter

Class

Class type

sectionYPositions = computeSectionYPositions($el), 10)" x-init="setTimeout(() => sectionYPositions = computeSectionYPositions($el), 10)">

On This Page

Legend:

Library

Module

Module type

Parameter

Class

Class type

Library

Module

Module type

Parameter

Class

Class type

Events.

An event is a value with discrete occurrences over time. Consult the semantics and notations of events.

`type 'a t = 'a event`

The type for events with occurrences of type `'a`

.

`type 'a send = ?step:Step.t -> 'a -> unit`

The type for functions sending event occurrences of type `'a`

. See `create`

.

`log ?now e f`

is `Some (Logr.(create ?now (const f $ obs e)))`

if `e`

is not `never`

and `None`

otherwise.

`create ()`

is a primitive event `e`

and a `send`

function. The function `send`

is such that:

`send v`

generates an occurrence`v`

of`e`

at the time it is called .`send ~step v`

generates an occurrence`v`

of`e`

at the time`step`

. The function should not be called again before`step`

is executed.

**Warning.** `send`

must not be used in the definition of signals or events.

`val value : 'a event -> 'a option`

`value e`

is the value of event `e`

at call time. If this is `None`

the event has no occurrence, if this is `Some v`

, the event occurs with `v`

.

`val never : 'a event`

`never`

is a never occuring event, [`never`

]_{t} `= None`

.

`bind e f`

is the event that results from applying `f`

to the last event of `e`

:

- [
`bind e f`

]_{t}`=`

[`f v`

]_{t}if [`e`

]_{≤t}`= Some v`

. - [
`bind e f`

]_{t}`=`

`never`

_{t}if [`e`

]_{≤t}`= None`

.

`swap es`

is the current event of `es`

, [`swap es`

]_{t} `=`

[[`es`

]_{t}]_{t}.

`map f e`

applies `f`

to `e`

's occurrences.

- [
`map f e`

]_{t}`= Some (f v)`

if [`e`

]_{t}`= Some v`

. - [
`map f e`

]_{t}`= None`

otherwise.

`filter p e`

are the occurrences of `e`

that satisfy `p`

.

- [
`filter p e`

]_{t}`= Some v`

if [`e`

]_{t}`= Some v`

and`p v = true`

- [
`filter p e`

]_{t}`= None`

otherwise.

`filter_map fm e`

are `e`

's occurrences filtered and mapped by `fm`

.

- [
`filter_map fm e`

]_{t}`= Some v`

if`fm`

[`e`

]_{t}`= Some v`

- [
`filter_map fm e`

]_{t}`= None`

otherwise.

`select el`

is the occurrences of every event in `el`

. If more than one event occurs simlutanously, the leftmost is taken and the other are lost:

- [
`select el`

]_{t}`=`

[`List.find (fun e ->`

[`e`

]_{t}`<> None) el`

]_{t}. - [
`select el`

]_{t}`= None`

otherwise.

`accum i e`

accumulates a value, starting with `i`

, using `e`

's functional occurrences.

- [
`accum i e`

]_{t}`= Some (f i)`

if [`e`

]_{t}`= Some f`

and [`e`

]_{<t}`= None`

. - [
`accum i e`

]_{t}`= Some (f acc)`

if [`e`

]_{t}`= Some f`

and [`accum i e`

]_{<t}`= Some acc`

. - [
`accum i e`

]`= None`

otherwise.

`until ~limit ~next e`

is `e`

's occurrences until `next`

occurs. At that point if `e`

occurs simultaneously the occurrence is discarded (`limit`

is `false`

, default) or kept (`limit`

is `true`

) and after this the event never occurs again.

- [
`until ~limit ~next e`

]_{t}`=`

[`e`

]_{t}if [`next`

]_{≤t}`= None`

- [
`until ~limit:false ~next e`

]_{t}`= None`

if [`next`

]_{t}`= Some _`

and [`next`

]_{<t}`= None`

. - [
`until ~limit:true ~next e`

]_{t}`=`

[`e`

]_{t}if [`next`

]_{t}`= Some _`

and [`next`

]_{<t}`= None`

. - [
`until ~limit ~next e`

]_{t}`= None`

otherwise.

`follow e ~on`

is `e`

's occurrences whenever `on`

is `true`

.

- [
`follow e ~on`

]_{t}`=`

[`e`

]_{t}if [`on`

]_{t}`= true`

- [
`follow e ~on`

]_{t}`= None`

if [`on`

]_{t}`= false`

`defer s`

is `s`

delayed by an infinitesimal amount of time. At creation time `init`

is used (defaults to `S.value s`

).

- [
`defer e`

]_{t}`=`

`None`

for t = 0. - [
`defer e`

]_{t}`=`

[`e`

]_{t-dt}otherwise.

`fix ef`

allows to refer to the value an event had an infinitesimal amount of time before.

In `fix ef`

, `ef`

is called with an event `e`

that represents the event returned by `ef`

delayed by an infinitesimal amount of time. If `e', r = ef e`

then `r`

is returned by `fix`

and `e`

is such that :

- [
`e`

]_{t}`=`

`None`

if t = 0 - [
`e`

]_{t}`=`

[`e'`

]_{t-dt}otherwise

**Raises.** `Invalid_argument`

if `e'`

is directly a delayed event (i.e. an event given to a fixing function).

`module Option : sig ... end`

Option events

`module Pair : sig ... end`

Pair events.

On This Page