blob: 01724ac8c2e8f9849d8d687f0bf6483071098932 (
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
|
(** 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 update () state = { value = state.value + 1 }
end
module App = Make(struct type t = state end)
(* Create the event itself *)
let incr_event = App.E ((), (module Incr:App.Event with type t = Incr.t))
]
*)
module Make(S:sig type t end) = struct
module type Event = sig
type t
val update: t -> S.t -> S.t
end
type event = E : 'a * (module Event with type t = 'a) -> event
(** Simple helper for the main event loop *)
let run
: ?eq:(S.t -> S.t -> bool) -> S.t -> event Note.E.t -> S.t Note.S.t
= fun ?eq init event ->
let action = Note.E.map (fun (E (t, (module Event))) st -> Event.update t st) event in
Note.S.accum ?eq init action
end
|
