1 files changed, 16 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
-
-