event.ml

type t = {
  name : string;
  tags : Tag.S.t;
}

let mk name tags = { name; tags; }

let tags t = t.tags

event.mli

type t
(** the type of events *)

val mk : string -> Tag.S.t -> t
(** create a new event. *)

val tags : t -> Tag.S.t
(** Return the set of tags for the event. *)

other.ml

(* check whether the event has at least one of the tags in tag_set *)
let is_interested tag_set event =
  not (Tag.S.is_empty (Tag.S.inter tag_set (Event.tags event)))

tag.ml

type t = string

let print fmt t =
  Format.fprintf fmt "%s" t

let hash x = Hashtbl.hash x
let compare = String.compare
let equal x y = compare x y = 0

end

(* use S here instead of Set to avoid potential name clashed *)
module S = Set.Make(struct
  type nonrec t = t
  let compare = compare
end)

tag.mli

type t
(** Type for tags *)

val print : Format.formatter -> t -> unit

val hash  : t -> int
val equal : t -> t -> bool
val compare : t -> t -> int

module S : Set.S with type elt = t