Library
Module
Module type
Parameter
Class
Class type
Events.
An event is a value with discrete occurences over time.
type 'a t = 'a event
The type for events with occurences of type 'a
.
type 'a send = ?step:Step.t -> 'a -> unit
The type for functions sending event occurences 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 occurence v
of e
at the time it is called .send ~step v
generates an occurence 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 occurence, 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
if [e
]<=t = None
.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 occurences 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 occurences 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 occurences until next
occurs. At that point if e
occurs simultaneously the occurence 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 occurences 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 = 0e
]t =
[e'
]t-dt otherwiseRaises. 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.