increasing/decreasing order of keys).
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val fold_left : (elt -> 'a -> 'a) -> t -> 'a -> 'a
+ val fold_right : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
| Finite s -> E.fold f s a
| CoFinite _ -> raise exn
+ let fold_left f t a = match t.node with
+ | Finite s -> E.fold_left f s a
+ | CoFinite _ -> raise exn
+
+ let fold_right f t a = match t.node with
+ | Finite s -> E.fold_right f s a
+ | CoFinite _ -> raise exn
+
let iter f t = match t.node with
| Finite t -> E.iter f t
| CoFinite _ -> raise exn
| CoFinite _ -> raise exn
let positive t = match t.node with
- | Finite x -> x
- | CoFinite _ -> E.empty
+ | Finite x -> x
+ | CoFinite _ -> E.empty
let negative t = match t.node with
- | CoFinite x -> x
- | Finite _ -> E.empty
+ | CoFinite x -> x
+ | Finite _ -> E.empty
let inj_positive t = finite t
let inj_negative t = cofinite t
| Leaf k -> f k
| Branch (_,_,t0,t1) -> iter f t0; iter f t1
- let rec fold f s accu = match s.Node.node with
+ let rec fold_left f s accu = match s.Node.node with
| Empty -> accu
| Leaf k -> f k accu
- | Branch (_,_,t0,t1) -> fold f t1 (fold f t0 accu)
+ | Branch (_,_,t0,t1) -> fold_left f t1 (fold_left f t0 accu)
+ let rec fold_right f s accu = match s.Node.node with
+ | Empty -> accu
+ | Leaf k -> f k accu
+ | Branch (_,_,t0,t1) -> fold_right f t0 (fold_right f t1 accu)
+
+ let fold f s accu = fold_left f s accu
let rec for_all p n = match n.Node.node with
| Empty -> true
cache.(T.preorder tree node).NodeStatus.node.sat
in
loop (T.root tree);
- List.rev (StateSet.fold
- (fun q acc -> (q, Cache.N1.find res_mapper (q :> int))::acc)
- (Ata.get_selecting_states auto) [])
+ (StateSet.fold_right
+ (fun q acc -> (q, Cache.N1.find res_mapper (q :> int))::acc)
+ (Ata.get_selecting_states auto) [])
let prepare_run run list =
let tree = run.tree in