[Caml-list] a push style event combinator

[Caml-list] a push style event combinator

[Satoshi Ogasawara]

Hello,

I'd like to announce the release of PEC, a push style event combinator.

  PEC : https://github.com/osiire/Pec

This small module(about 350 LOC) provides

- a composable event.
- map, choose, never, join and several useful functions.
- immediate reactions corresponds sending data to events.
- no memory leaks.

I think PEC is useful to write event driven systems. The signature is as follows.

type 'a event

(** [make ()] makes a new event and sender function.*)
val make : unit -> 'a event * ('a -> unit)
val map : ('a -> 'b) -> 'a event -> 'b event

(** [choose l] is a event which will be raised when one of specified events occurred. *)
val choose : 'a event list -> 'a event
val never : 'a event
(** [join ee] is a event which will be raised when a inner event occurred.
    "Inner event" is a event comes from outer event [ee]. *)
val join : 'a event event -> 'a event
(** [bind e f] is [join (map f e)] *)
val bind : 'a event -> ('a -> 'b event) -> 'b event
val scan : ('a -> 'b -> 'a) -> 'a -> 'b event -> 'a event
val filter : ('a -> bool) -> 'a event -> 'a event
val filter_map : ('a -> 'b option) -> 'a event -> 'b event
val zip : 'a event -> 'b event -> ('a * 'b) event
val take_while : ('a -> bool) -> 'a event -> 'a event
val take_while_in : ('a -> bool) -> 'a event -> 'a event
val take_n : int -> 'a event -> 'a event
val once : 'a event -> 'a event
val drop_while : ('a -> bool) -> 'a event -> 'a event
val drop_n : int -> 'a event -> 'a event
val delay : int -> 'a event -> 'a event
val pairwise : 'a event -> ('a * 'a) event

(** [subscribe f e] attaches the [f] to the specified event.
    The [f] will be called when the [e] will occurred. *)
val subscribe : ('a -> unit) -> 'a event -> unit

(** [value e] returns a reference cell which store a latest value *)
val value : 'a -> 'a event -> 'a ref

(** [run ()] runs PEC event system and returns a number of queuing size of sended data. *)
val run : unit -> int


e.g.
 Using PEC, you can write a drag event from mouse events like this.

let (+>) f g = g f
(* E is PEC module *)
let dragging mouse_down mouse_up mouse_move =
  E.bind mouse_down (fun dloc -> E.choose [
    E.map (fun uloc -> `Drop (dloc, uloc)) mouse_up;
    E.map (fun mloc -> `Drag (dloc, mloc)) mouse_move;
  ]
  +> E.take_while_in (function `Drop _ -> false | _ -> true))


Regards,
 ogasawara

Re: [Caml-list] a push style event combinator

[Philippe Veber]

[-- Attachment #1: Type: text/plain, Size: 3158 bytes --]

Thank you for releasing your library, it looks really interesting !
How would you compare it with react (http://erratique.ch/software/react)
which, AFAIU, can be used for similar purposes ? At least I can see there is
no notion of signal (continuous function of time) in PEC (or maybe signals
can be emulated somehow ?). Also could you comment on the 'no memory leaks'
feature ?

cheers,
  Philippe.


2011/9/15 Satoshi Ogasawara <ogasawara@itpl.co.jp>

> Hello,
>
> I'd like to announce the release of PEC, a push style event combinator.
>
>  PEC : https://github.com/osiire/Pec
>
> This small module(about 350 LOC) provides
>
> - a composable event.
> - map, choose, never, join and several useful functions.
> - immediate reactions corresponds sending data to events.
> - no memory leaks.
>
> I think PEC is useful to write event driven systems. The signature is as
> follows.
>
> type 'a event
>
> (** [make ()] makes a new event and sender function.*)
> val make : unit -> 'a event * ('a -> unit)
> val map : ('a -> 'b) -> 'a event -> 'b event
>
> (** [choose l] is a event which will be raised when one of specified events
> occurred. *)
> val choose : 'a event list -> 'a event
> val never : 'a event
> (** [join ee] is a event which will be raised when a inner event occurred.
>    "Inner event" is a event comes from outer event [ee]. *)
> val join : 'a event event -> 'a event
> (** [bind e f] is [join (map f e)] *)
> val bind : 'a event -> ('a -> 'b event) -> 'b event
> val scan : ('a -> 'b -> 'a) -> 'a -> 'b event -> 'a event
> val filter : ('a -> bool) -> 'a event -> 'a event
> val filter_map : ('a -> 'b option) -> 'a event -> 'b event
> val zip : 'a event -> 'b event -> ('a * 'b) event
> val take_while : ('a -> bool) -> 'a event -> 'a event
> val take_while_in : ('a -> bool) -> 'a event -> 'a event
> val take_n : int -> 'a event -> 'a event
> val once : 'a event -> 'a event
> val drop_while : ('a -> bool) -> 'a event -> 'a event
> val drop_n : int -> 'a event -> 'a event
> val delay : int -> 'a event -> 'a event
> val pairwise : 'a event -> ('a * 'a) event
>
> (** [subscribe f e] attaches the [f] to the specified event.
>    The [f] will be called when the [e] will occurred. *)
> val subscribe : ('a -> unit) -> 'a event -> unit
>
> (** [value e] returns a reference cell which store a latest value *)
> val value : 'a -> 'a event -> 'a ref
>
> (** [run ()] runs PEC event system and returns a number of queuing size of
> sended data. *)
> val run : unit -> int
>
>
> e.g.
>  Using PEC, you can write a drag event from mouse events like this.
>
> let (+>) f g = g f
> (* E is PEC module *)
> let dragging mouse_down mouse_up mouse_move =
>  E.bind mouse_down (fun dloc -> E.choose [
>    E.map (fun uloc -> `Drop (dloc, uloc)) mouse_up;
>    E.map (fun mloc -> `Drag (dloc, mloc)) mouse_move;
>  ]
>  +> E.take_while_in (function `Drop _ -> false | _ -> true))
>
>
> Regards,
>  ogasawara
>
> --
> Caml-list mailing list.  Subscription management and archives:
> https://sympa-roc.inria.fr/wws/info/caml-list
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs
>
>

[-- Attachment #2: Type: text/html, Size: 4454 bytes --]

Re: [Caml-list] a push style event combinator

[Satoshi Ogasawara]

(2011/09/15 23:45), Philippe Veber wrote:
> Thank you for releasing your library, it looks really interesting !

Thank you for your reply.

> How would you compare it with react (http://erratique.ch/software/react) which, AFAIU, can
> be used for similar purposes ? At least I can see there is no notion of signal (continuous
> function of time) in PEC (or maybe signals can be emulated somehow ?). Also could you
> comment on the 'no memory leaks' feature ?

Yes, both the react and PEC can be used for similar purpose. But there are some
different points between the two libraries.

  - PEC is "subscribe" centered. If you leave a event alone without subscribing,
    no actions will be occurred even if you send data to the event.
    The react library's system always runs update cycle at sending data to events.

  - Instead of signal, PEC have "value" function. "value" function attaches a event and
    returns a reference cell which contains latest occurrence data of the event.
    I think it's enough because signal is only terminal point of reactive events.

  - PEC's inside representation of event is not dependency graph but just nested variants.
    Let me assume a event A depends on other event B. In case of using dependency graph,
    event B has pointer of event A. This caused difficulty about memory leaks because
    there is no good timing to free the event A.
    PEC's event is just a nested variants. It means that event A has pointer of event B.
    So the event A will be garbage-collected automatically when the reference to the
    event A from application layer disappeared. That is the reason why "no memory leaks".


Regards,
  ogasawara

>
> cheers,
>    Philippe.
>
>
> 2011/9/15 Satoshi Ogasawara <ogasawara@itpl.co.jp <mailto:ogasawara@itpl.co.jp>>
>
>     Hello,
>
>     I'd like to announce the release of PEC, a push style event combinator.
>
>       PEC : https://github.com/osiire/Pec
>
>     This small module(about 350 LOC) provides
>
>     - a composable event.
>     - map, choose, never, join and several useful functions.
>     - immediate reactions corresponds sending data to events.
>     - no memory leaks.
>
>     I think PEC is useful to write event driven systems. The signature is as follows.
>
>     type 'a event
>
>     (** [make ()] makes a new event and sender function.*)
>     val make : unit -> 'a event * ('a -> unit)
>     val map : ('a -> 'b) -> 'a event -> 'b event
>
>     (** [choose l] is a event which will be raised when one of specified events occurred. *)
>     val choose : 'a event list -> 'a event
>     val never : 'a event
>     (** [join ee] is a event which will be raised when a inner event occurred.
>     "Inner event" is a event comes from outer event [ee]. *)
>     val join : 'a event event -> 'a event
>     (** [bind e f] is [join (map f e)] *)
>     val bind : 'a event -> ('a -> 'b event) -> 'b event
>     val scan : ('a -> 'b -> 'a) -> 'a -> 'b event -> 'a event
>     val filter : ('a -> bool) -> 'a event -> 'a event
>     val filter_map : ('a -> 'b option) -> 'a event -> 'b event
>     val zip : 'a event -> 'b event -> ('a * 'b) event
>     val take_while : ('a -> bool) -> 'a event -> 'a event
>     val take_while_in : ('a -> bool) -> 'a event -> 'a event
>     val take_n : int -> 'a event -> 'a event
>     val once : 'a event -> 'a event
>     val drop_while : ('a -> bool) -> 'a event -> 'a event
>     val drop_n : int -> 'a event -> 'a event
>     val delay : int -> 'a event -> 'a event
>     val pairwise : 'a event -> ('a * 'a) event
>
>     (** [subscribe f e] attaches the [f] to the specified event.
>         The [f] will be called when the [e] will occurred. *)
>     val subscribe : ('a -> unit) -> 'a event -> unit
>
>     (** [value e] returns a reference cell which store a latest value *)
>     val value : 'a -> 'a event -> 'a ref
>
>     (** [run ()] runs PEC event system and returns a number of queuing size of sended data. *)
>     val run : unit -> int
>
>
>     e.g.
>       Using PEC, you can write a drag event from mouse events like this.
>
>     let (+>) f g = g f
>     (* E is PEC module *)
>     let dragging mouse_down mouse_up mouse_move =
>       E.bind mouse_down (fun dloc -> E.choose [
>         E.map (fun uloc -> `Drop (dloc, uloc)) mouse_up;
>         E.map (fun mloc -> `Drag (dloc, mloc)) mouse_move;
>       ]
>       +> E.take_while_in (function `Drop _ -> false | _ -> true))
>
>
>     Regards,
>       ogasawara
>
>     --
>     Caml-list mailing list.  Subscription management and archives:
>     https://sympa-roc.inria.fr/wws/info/caml-list
>     Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
>     Bug reports: http://caml.inria.fr/bin/caml-bugs
>
>