blob: 2e813f5688d50213e7fb5072e94eb8a71fbcdab7 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
(** The Make module build the main application loop.contents
The function [run] update the state on each event, and return a new state.
Each event must follow the [event] type, which is composed from the type
[t], and a module with a fonction [update].
This example create an application with the state containing a simple
counter. An even which increment this counter is created and can be used to
update the state.
{[
type state = { value : int }
(** Increment the state. *)
module Incr = struct
type t = unit
let process () state = { value = state.value + 1 }
end
(** Decrement the state. *)
module Incr = struct
type t = unit
let process () state = { value = state.value - 1 }
end
module App = Make(struct type t = state end)
(* Create the event processor *)
let incr_event = App.dispatch (module Incr) ()
and decr_event = App.dispatch (module Decr) () in
let init = { value = 0 } in
(* Run the main loop *)
let state = App.run
init
(E.select
[ incr_event
; decr_event ] ) in …
]} *)
module Make (S : sig
type t
end) : sig
module type Processor = sig
type t
val process : t -> S.t -> S.t
end
module ID : Processor with type t = unit
type event
val dispatch : (module Processor with type t = 's) -> 's -> event
(** [dispatch (module P) v] will create an event holding a value [v] and
associated with the processor [P] *)
val run : ?eq:(S.t -> S.t -> bool) -> S.t -> event Note.E.t -> S.t Note.S.t
(** The function [run state ev] will create a signal continually updated each
time the event [ev] occur *)
end
|
