2 files changed, 80 insertions, 66 deletions
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