module DT: sig .. end
type ('t, 'ty) t = private
| |
Yield of 't |
| |
Cases of ('t, 'ty) cases |
type ('t, 'ty) cases = {
|
var : 'ty Var.t; |
|
tests : ('t, 'ty) case list; |
|
default : ('t, 'ty) t option; |
}
type ('t, 'ty) case = 't * ('t, 'ty) t
val yield : 't -> ('t, 'a) t
DT on 0 variables, that returns its argument
val const : 'ty Var.t list -> ('t, 'ty) t -> ('t, 'ty) t
const vars ret is the constant function over vars, that
always return ret
val cases : 'ty Var.t ->
tests:('t, 'ty) case list ->
default:('t, 'ty) t option -> ('t, 'ty) t
Raises Invalid_argument if tests= [] && default = None
val map : term:('t1 -> 't2) ->
ty:('ty1 -> 'ty2) -> ('t1, 'ty1) t -> ('t2, 'ty2) t
val filter_map : test:('ty Var.t -> 't1 -> 't2 option) ->
yield:('t1 -> 't2) -> ('t1, 'ty) t -> ('t2, 'ty) t
filter_map ~test ~yield dt filters the branches of dt
using test v lhs on every test v=lhs, and maps the
leaves using yield
val ty_args : ('a, 'ty) t -> 'ty list
Type of the discrimination tree arguments, seen as a function
val vars : ('a, 'ty) t -> 'ty Var.t list
List of variables decided upon
val num_vars : ('a, 'b) t -> int
val add_default : 't -> ('t, 'ty) t -> ('t, 'ty) t
add_default term dt adds term as a default case for every
sub-case of dt that does not already have a default value
type ('t, 'ty) flat_test = {
|
ft_var : 'ty Var.t; |
|
ft_term : 't; |
}
A test for the flat model
type ('t, 'ty) flat_dt = {
|
fdt_vars : 'ty Var.t list; |
|
fdt_cases : (('t, 'ty) flat_test list * 't) list; |
|
fdt_default : 't option; |
}
A flat model
val mk_flat_test : 'ty Var.t -> 't -> ('t, 'ty) flat_test
val of_flat : equal:('t -> 't -> bool) ->
hash:('t -> int) -> ('t, 'ty) flat_dt -> ('t, 'ty) t
of_flat vars ~tests ~default builds a decision tree on vars, in
that order, asssuming tests only range over vars.
val flatten : ('t, 'ty) t -> ('t, 'ty) flat_dt
Flatten as an old style flat decision tree
val check_ : ('a, 'b) t -> unit
check some invariants
val print : 't Model.prec_printer ->
'ty Model.printer -> ('t, 'ty) t Model.printer
val print_flat_test : 't Model.prec_printer -> ('t, 'a) flat_test Model.printer
val print_flat : 't Model.prec_printer -> ('t, 'a) flat_dt Model.printer
val to_sexp : 't Model.to_sexp -> 'ty Model.to_sexp -> ('t, 'ty) t Model.to_sexp
for model display