viewcvs.cgi/types/boolean.mli

(* Implementation of boolean combination in disjunctive normal form (dnf).
   A dnf is a disjunction of lines, each line consisting of a 
   conjunction of atoms and negations of atoms.

   A line is coded as a pair (p,n) where p collects atoms and n
   the negated atoms. p and n are disjoint and sorted lists without duplicates
   (w.r.t Pervasives.compare).

   A dnf is coded as a sorted list of lines without duplicated
   (w.r.t Pervasives.compare).
*)

module Make(X : Custom.T) :
sig
  include Custom.T
  type elem = X.t

  external get: t -> (X.t list * X.t list) list = "%identity"

  val empty : t
  val full  : t
  val cup   : t -> t -> t
  val cap   : t -> t -> t
  val diff  : t -> t -> t
  val atom  : X.t -> t

  val map : (X.t -> X.t) -> t -> t
  val iter: (X.t -> unit) -> t -> unit
  val compute: empty:'d -> full:'c -> cup:('d -> 'c -> 'd) 
    -> cap:('c -> 'b -> 'c) -> diff:('c -> 'b -> 'c) ->
    atom:(X.t -> 'b) -> t -> 'd
  val compute_bool: (X.t -> t) -> t -> t
    
  val print: string -> (Format.formatter -> X.t -> unit) -> t ->
    (Format.formatter -> unit) list
    
    
  val trivially_disjoint : t -> t -> bool    
end
1	(* Implementation of boolean combination in disjunctive normal form (dnf).
2	A dnf is a disjunction of lines, each line consisting of a
3	conjunction of atoms and negations of atoms.
4
5	A line is coded as a pair (p,n) where p collects atoms and n
6	the negated atoms. p and n are disjoint and sorted lists without duplicates
7	(w.r.t Pervasives.compare).
8
9	A dnf is coded as a sorted list of lines without duplicated
10	(w.r.t Pervasives.compare).
11	*)
12
13	module Make(X : Custom.T) :
14	sig
15	include Custom.T
16	type elem = X.t
17
18	external get: t -> (X.t list * X.t list) list = "%identity"
19
20	val empty : t
21	val full : t
22	val cup : t -> t -> t
23	val cap : t -> t -> t
24	val diff : t -> t -> t
25	val atom : X.t -> t
26
27	val map : (X.t -> X.t) -> t -> t
28	val iter: (X.t -> unit) -> t -> unit
29	val compute: empty:'d -> full:'c -> cup:('d -> 'c -> 'd)
30	-> cap:('c -> 'b -> 'c) -> diff:('c -> 'b -> 'c) ->
31	atom:(X.t -> 'b) -> t -> 'd
32	val compute_bool: (X.t -> t) -> t -> t
33
34	val print: string -> (Format.formatter -> X.t -> unit) -> t ->
35	(Format.formatter -> unit) list
36
37
38	val trivially_disjoint : t -> t -> bool
39	end