From c0c82a7bfe8300b1bd50fee11074837ff32d3da0 Mon Sep 17 00:00:00 2001
From: Sébastien Dailly <sebastien@dailly.me>
Date: Mon, 7 Feb 2022 13:40:36 +0100
Subject: Renamed fonctions in application framework, updated doc
---
lib/application/application.ml | 82 ++++++++---------------------------------
lib/application/application.mli | 64 ++++++++++++++++++++++++++++++++
2 files changed, 80 insertions(+), 66 deletions(-)
create mode 100644 lib/application/application.mli
(limited to 'lib')
diff --git a/lib/application/application.ml b/lib/application/application.ml
index 422aa4f..b6ece93 100755
--- a/lib/application/application.ml
+++ b/lib/application/application.ml
@@ -1,73 +1,23 @@
-(** 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
-
- (** Decrement 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 events *)
- let incr_event = App.E ((), (module Incr:App.Event with type t = Incr.t))
- let decr_event = App.E ((), (module Decr:App.Event with type t = Decr.t))
-
- 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) = struct
- module type Event = sig
-
+module Make (S : sig
+ type t
+end) =
+struct
+ module type Procesor = sig
type t
- val process: t -> S.t -> S.t
-
+ val process : t -> S.t -> S.t
end
- type event = E : 'a * (module Event with type t = 'a) -> event
+ type event = E : 'a * (module Procesor 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.process t st) event in
- Note.S.accum ?eq init action
-
- let dispatch
- : (module Event with type t = 's) -> 's -> event
- = fun (type s) (module M: Event with type t = s) v ->
- E
- ( v
- , (module M : Event with type t = M.t ))
-
+ 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 P))) st -> P.process t st) event
+ in
+ Note.S.accum ?eq init action
+
+ let dispatch : (module Procesor with type t = 's) -> 's -> event =
+ fun (type s) (module P : Procesor with type t = s) v -> E (v, (module P))
end
-
-
diff --git a/lib/application/application.mli b/lib/application/application.mli
new file mode 100644
index 0000000..5bf0556
--- /dev/null
+++ b/lib/application/application.mli
@@ -0,0 +1,64 @@
+(** 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 Procesor = sig
+ type t
+
+ val process : t -> S.t -> S.t
+ end
+
+ type event
+
+ val dispatch : (module Procesor 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
--
cgit v1.2.3