[m-rev.] diff: change argument ordering in rbtree and tree234 modules
Julien Fischer
juliensf at csse.unimelb.edu.au
Thu May 19 01:36:27 AEST 2011
Branches: main
Change the argument order of predicates in the rbtree and tree234 modules
to make them more conducive to the use of state variable notation.
(This change will break existing code that uses these modules but such
modules should be quite rare; most existing code uses the map module.)
library/rbtree.m:
Change argument orderings as above.
Add further modes for the foldl predicates that have
(mostly-)unique accumulators.
library/tree234.m:
Change argument orderings as above.
library/map.m:
profiler/generate_output.m:
tests/debugger/declarative/mapinit.m:
tests/hard_coded/transform_value.m:
Conform to the above changes.
NEWS:
Announce the above changes.
Julien.
Index: NEWS
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/NEWS,v
retrieving revision 1.571
diff -u -r1.571 NEWS
--- NEWS 18 May 2011 11:23:04 -0000 1.571
+++ NEWS 18 May 2011 15:24:14 -0000
@@ -51,8 +51,12 @@
multi_map.remove_smallest/4, queue.put/3, queue.put_list/3,
queue.get/3, queue.delete_all/3, queue.put_on_front/3,
queue.get_from_back/3, queue.put_list_on_front/3,
- queue.get_from_back/3, set.insert/3, set.insert_list/3, set.delete/3,
- set.delete_list/3, set.remove/3, set.remove_list/3 and set.remove_least/3
+ queue.get_from_back/3, rbtree.insert/4, rbtree.update/4, rbtree.set/4,
+ rbtree.delete/3, rbtree.remove_smallest/4, rbtree.remove_largest/4,
+ set.insert/3, set.insert_list/3, set.delete/3, set.delete_list/3,
+ set.remove/3, set.remove_list/3, set.remove_least/3, tree234.insert/4,
+ tree234.set/4, tree234.remove/4, tree234.remove_smallest/4 and
+ tree234.update/4.
* We have add the following new functions for creating singleton
maps: bimap.singleton/2, injection.singleton/2, map.singleton/2,
@@ -125,6 +129,9 @@
way for an eventual change of the predicate argument ordering in the
stack and pqueue modules.)
+* We have added additional modes with unique and mostly-unique accumulators
+ to rbtree.foldl/4 and rbtree.foldl2/6.
+
NEWS for Mercury 11.01
----------------------
Index: library/map.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/library/map.m,v
retrieving revision 1.124
diff -u -r1.124 map.m
--- library/map.m 5 May 2011 04:35:34 -0000 1.124
+++ library/map.m 18 May 2011 15:06:20 -0000
@@ -715,6 +715,9 @@
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
+map.init = M :-
+ map.init(M).
+
map.init(M) :-
tree234.init(M).
@@ -730,9 +733,15 @@
map.member(Map, K, V) :-
tree234.member(Map, K, V).
+map.search(M, K) = V :-
+ map.search(M, K, V).
+
map.search(Map, K, V) :-
tree234.search(Map, K, V).
+map.lookup(M, K) = V :-
+ map.lookup(M, K, V).
+
map.lookup(Map, K, V) :-
( tree234.search(Map, K, VPrime) ->
V = VPrime
@@ -768,16 +777,25 @@
map.min_key(M) = tree234.min_key(M).
+map.insert(M1, K, V) = M2 :-
+ map.insert(K, V, M1, M2).
+
map.insert(K, V, !Map) :-
- tree234.insert(!.Map, K, V, !:Map).
+ tree234.insert(K, V, !Map).
+
+map.det_insert(M1, K, V) = M2 :-
+ map.det_insert(K, V, M1, M2).
map.det_insert(K, V, !Map) :-
- ( tree234.insert(!.Map, K, V, NewMap) ->
+ ( tree234.insert(K, V, !.Map, NewMap) ->
!:Map = NewMap
;
report_lookup_error("map.det_insert: key already present", K, V)
).
+map.det_insert_from_corresponding_lists(M1, Ks, Vs) = M2 :-
+ map.det_insert_from_corresponding_lists(Ks, Vs, M1, M2).
+
map.det_insert_from_corresponding_lists([], [], !Map).
map.det_insert_from_corresponding_lists([], [_ | _], _, _) :-
error("map.det_insert_from_corresponding_lists - lists do not correspond").
@@ -787,11 +805,17 @@
map.det_insert(K, V, !Map),
map.det_insert_from_corresponding_lists(Ks, Vs, !Map).
+map.det_insert_from_assoc_list(M1, AL) = M2 :-
+ map.det_insert_from_assoc_list(AL, M1, M2).
+
map.det_insert_from_assoc_list([], !Map).
map.det_insert_from_assoc_list([K - V | KVs], !Map) :-
map.det_insert(K, V, !Map),
map.det_insert_from_assoc_list(KVs, !Map).
+map.set_from_corresponding_lists(M1, Ks, Vs) = M2 :-
+ map.set_from_corresponding_lists(Ks, Vs, M1, M2).
+
map.set_from_corresponding_lists([], [], !Map).
map.set_from_corresponding_lists([], [_ | _], _, _) :-
error("map.set_from_corresponding_lists - lists do not correspond").
@@ -801,16 +825,25 @@
map.set(K, V, !Map),
map.set_from_corresponding_lists(Ks, Vs, !Map).
+map.set_from_assoc_list(M1, AL) = M2 :-
+ map.set_from_assoc_list(AL, M1, M2).
+
map.set_from_assoc_list([], !Map).
map.set_from_assoc_list([K - V | KVs], !Map) :-
map.set(K, V, !Map),
map.set_from_assoc_list(KVs, !Map).
+map.update(M1, K, V) = M2 :-
+ map.update(K, V, M1, M2).
+
map.update(K, V, !Map) :-
- tree234.update(!.Map, K, V, !:Map).
+ tree234.update(K, V, !Map).
+
+map.det_update(M1, K, V) = M2 :-
+ map.det_update(K, V, M1, M2).
map.det_update(K, V, !Map) :-
- ( tree234.update(!.Map, K, V, NewMap) ->
+ ( tree234.update(K, V, !.Map, NewMap) ->
!:Map = NewMap
;
report_lookup_error("map.det_update: key not found", K, V)
@@ -826,41 +859,74 @@
report_lookup_error("map.det_transform_value: key not found", K)
).
-map.det_transform_value(F, K, Map0) = Map :-
+map.det_transform_value(F, K, !.Map) = !:Map :-
map.det_transform_value(pred(V0::in, V::out) is det :- V = F(V0), K,
- Map0, Map).
+ !Map).
+
+map.set(M1, K, V) = M2 :-
+ map.set(K, V, M1, M2).
map.set(K, V, !Map) :-
- tree234.set(!.Map, K, V, !:Map).
+ tree234.set(K, V, !Map).
+
+map.keys(M) = Ks :-
+ map.keys(M, Ks).
map.keys(Map, KeyList) :-
tree234.keys(Map, KeyList).
+map.sorted_keys(M) = Ks :-
+ map.sorted_keys(M, Ks).
+
map.sorted_keys(Map, KeyList) :-
% Guaranteed to yield sorted lists.
tree234.keys(Map, KeyList).
+map.values(M) = Vs :-
+ map.values(M, Vs).
+
map.values(Map, KeyList) :-
tree234.values(Map, KeyList).
+map.to_assoc_list(M) = AL :-
+ map.to_assoc_list(M, AL).
+
map.to_assoc_list(M, L) :-
tree234.tree234_to_assoc_list(M, L).
+map.to_sorted_assoc_list(M) = AL :-
+ map.to_sorted_assoc_list(M, AL).
+
map.to_sorted_assoc_list(M, L) :-
% Guaranteed to yield sorted lists.
tree234.tree234_to_assoc_list(M, L).
+map.from_assoc_list(AL) = M :-
+ map.from_assoc_list(AL, M).
+
map.from_assoc_list(L, M) :-
tree234.assoc_list_to_tree234(L, M).
+map.from_sorted_assoc_list(AL) = M :-
+ map.from_sorted_assoc_list(AL, M).
+
map.from_sorted_assoc_list(L, M) :-
tree234.from_sorted_assoc_list(L, M).
+map.from_rev_sorted_assoc_list(AL) = M :-
+ map.from_rev_sorted_assoc_list(AL, M).
+
map.from_rev_sorted_assoc_list(L, M) :-
tree234.from_rev_sorted_assoc_list(L, M).
+map.delete(M1, K) = M2 :-
+ map.delete(K, M1, M2).
+
map.delete(Key, !Map) :-
- tree234.delete(!.Map, Key, !:Map).
+ tree234.delete(Key, !Map).
+
+map.delete_list(M1, Ks) = M2 :-
+ map.delete_list(Ks, M1, M2).
map.delete_list([], !Map).
map.delete_list([Key | Keys], !Map) :-
@@ -868,16 +934,19 @@
map.delete_list(Keys, !Map).
map.remove(Key, Value, !Map) :-
- tree234.remove(!.Map, Key, Value, !:Map).
+ tree234.remove(Key, Value, !Map).
map.det_remove(Key, Value, !Map) :-
- ( tree234.remove(!.Map, Key, ValuePrime, MapPrime) ->
+ ( tree234.remove(Key, ValuePrime, !.Map, MapPrime) ->
Value = ValuePrime,
!:Map = MapPrime
;
report_lookup_error("map.det_remove: key not found", Key, Value)
).
+map.count(M) = N :-
+ map.count(M, N).
+
map.count(Map, Count) :-
tree234.count(Map, Count).
@@ -888,18 +957,27 @@
%-----------------------------------------------------------------------------%
+map.from_corresponding_lists(Ks, Vs) = M :-
+ map.from_corresponding_lists(Ks, Vs, M).
+
map.from_corresponding_lists(Keys, Values, Map) :-
assoc_list.from_corresponding_lists(Keys, Values, AssocList),
tree234.assoc_list_to_tree234(AssocList, Map).
%-----------------------------------------------------------------------------%
+map.merge(M1, M2) = M3 :-
+ map.merge(M1, M2, M3).
+
map.merge(MA, MB, M) :-
map.to_assoc_list(MB, MBList),
map.det_insert_from_assoc_list(MBList, MA, M).
%-----------------------------------------------------------------------------%
+map.old_merge(M1, M2) = M3 :-
+ map.old_merge(M1, M2, M3).
+
map.old_merge(M0, M1, M) :-
map.to_assoc_list(M0, ML0),
map.to_assoc_list(M1, ML1),
@@ -909,10 +987,16 @@
%-----------------------------------------------------------------------------%
+map.optimize(M1) = M2 :-
+ map.optimize(M1, M2).
+
map.optimize(Map, Map).
%-----------------------------------------------------------------------------%
+map.overlay(M1, M2) = M3 :-
+ map.overlay(M1, M2, M3).
+
map.overlay(Map0, Map1, Map) :-
map.to_assoc_list(Map1, AssocList),
map.overlay_2(AssocList, Map0, Map).
@@ -926,6 +1010,9 @@
map.set(K, V, !Map),
map.overlay_2(AssocList, !Map).
+map.overlay_large_map(M1, M2) = M3 :-
+ map.overlay_large_map(M1, M2, M3).
+
map.overlay_large_map(Map0, Map1, Map) :-
map.to_assoc_list(Map0, AssocList),
map.overlay_large_map_2(AssocList, Map1, Map).
@@ -945,6 +1032,9 @@
%-----------------------------------------------------------------------------%
+map.select(M1, S) = M2 :-
+ map.select(M1, S, M2).
+
map.select(Original, KeySet, NewMap) :-
set.to_sorted_list(KeySet, KeyList),
map.init(NewMap0),
@@ -965,6 +1055,9 @@
%-----------------------------------------------------------------------------%
+map.apply_to_list(Ks, M) = Vs :-
+ map.apply_to_list(Ks, M, Vs).
+
map.apply_to_list([], _, []).
map.apply_to_list([K | Ks], Map, [V | Vs]) :-
map.lookup(Map, K, V),
@@ -973,10 +1066,14 @@
%-----------------------------------------------------------------------------%
map.remove_smallest(K, V, !Map) :-
- tree234.remove_smallest(!.Map, K, V, !:Map).
+ tree234.remove_smallest(K, V, !Map).
%-----------------------------------------------------------------------------%
+map.foldl(F, M, A) = B :-
+ P = (pred(W::in, X::in, Y::in, Z::out) is det :- Z = F(W, X, Y) ),
+ map.foldl(P, M, A, B).
+
map.foldl(Pred, Map, !A) :-
tree234.foldl(Pred, Map, !A).
@@ -992,6 +1089,10 @@
map.foldl_values(Pred, Map, !A) :-
tree234.foldl_values(Pred, Map, !A).
+map.foldr(F, M, A) = B :-
+ P = (pred(W::in, X::in, Y::in, Z::out) is det :- Z = F(W, X, Y) ),
+ map.foldr(P, M, A, B).
+
map.foldr(Pred, Map, !A) :-
tree234.foldr(Pred, Map, !A).
@@ -1006,9 +1107,17 @@
%-----------------------------------------------------------------------------%
+map.map_values(F, M1) = M2 :-
+ P = (pred(X::in, Y::in, Z::out) is det :- Z = F(X, Y) ),
+ map.map_values(P, M1, M2).
+
map.map_values(Pred, Map0, Map) :-
tree234.map_values(Pred, Map0, Map).
+map.map_values_only(F, M1) = M2 :-
+ P = (pred(Y::in, Z::out) is det :- Z = F(Y) ),
+ map.map_values_only(P, M1, M2).
+
map.map_values_only(Pred, Map0, Map) :-
tree234.map_values_only(Pred, Map0, Map).
@@ -1032,6 +1141,14 @@
%-----------------------------------------------------------------------------%
+map.intersect(F, M1, M2) = M3 :-
+ P = (pred(X::in, Y::in, Z::out) is det :- Z = F(X, Y) ),
+ map.intersect(P, M1, M2, M3).
+
+map.det_intersect(PF, M1, M2) = M3 :-
+ P = (pred(X::in, Y::in, Z::out) is semidet :- Z = PF(X, Y) ),
+ map.det_intersect(P, M1, M2, M3).
+
map.intersect(CommonPred, Map1, Map2, Common) :-
map.to_sorted_assoc_list(Map1, AssocList1),
map.to_sorted_assoc_list(Map2, AssocList2),
@@ -1124,6 +1241,14 @@
%-----------------------------------------------------------------------------%
+map.union(F, M1, M2) = M3 :-
+ P = (pred(X::in, Y::in, Z::out) is det :- Z = F(X, Y) ),
+ map.union(P, M1, M2, M3).
+
+map.det_union(F, M1, M2) = M3 :-
+ P = (pred(X::in, Y::in, Z::out) is semidet :- Z = F(X, Y) ),
+ map.det_union(P, M1, M2, M3).
+
map.union(CommonPred, Map1, Map2, Common) :-
map.to_sorted_assoc_list(Map1, AssocList1),
map.to_sorted_assoc_list(Map2, AssocList2),
@@ -1174,136 +1299,6 @@
error("map.det_union: map.union failed")
).
-%-----------------------------------------------------------------------------%
-%-----------------------------------------------------------------------------%
-% Ralph Becket <rwab1 at cl.cam.ac.uk> 27/04/99
-% Functional forms added.
-
-map.init = M :-
- map.init(M).
-
-map.search(M, K) = V :-
- map.search(M, K, V).
-
-map.lookup(M, K) = V :-
- map.lookup(M, K, V).
-
-map.insert(M1, K, V) = M2 :-
- map.insert(K, V, M1, M2).
-
-map.det_insert(M1, K, V) = M2 :-
- map.det_insert(K, V, M1, M2).
-
-map.det_insert_from_corresponding_lists(M1, Ks, Vs) = M2 :-
- map.det_insert_from_corresponding_lists(Ks, Vs, M1, M2).
-
-map.det_insert_from_assoc_list(M1, AL) = M2 :-
- map.det_insert_from_assoc_list(AL, M1, M2).
-
-map.set_from_corresponding_lists(M1, Ks, Vs) = M2 :-
- map.set_from_corresponding_lists(Ks, Vs, M1, M2).
-
-map.set_from_assoc_list(M1, AL) = M2 :-
- map.set_from_assoc_list(AL, M1, M2).
-
-map.update(M1, K, V) = M2 :-
- map.update(K, V, M1, M2).
-
-map.det_update(M1, K, V) = M2 :-
- map.det_update(K, V, M1, M2).
-
-map.set(M1, K, V) = M2 :-
- map.set(K, V, M1, M2).
-
-map.keys(M) = Ks :-
- map.keys(M, Ks).
-
-map.sorted_keys(M) = Ks :-
- map.sorted_keys(M, Ks).
-
-map.values(M) = Vs :-
- map.values(M, Vs).
-
-map.to_assoc_list(M) = AL :-
- map.to_assoc_list(M, AL).
-
-map.to_sorted_assoc_list(M) = AL :-
- map.to_sorted_assoc_list(M, AL).
-
-map.from_assoc_list(AL) = M :-
- map.from_assoc_list(AL, M).
-
-map.from_sorted_assoc_list(AL) = M :-
- map.from_sorted_assoc_list(AL, M).
-
-map.from_rev_sorted_assoc_list(AL) = M :-
- map.from_rev_sorted_assoc_list(AL, M).
-
-map.delete(M1, K) = M2 :-
- map.delete(K, M1, M2).
-
-map.delete_list(M1, Ks) = M2 :-
- map.delete_list(Ks, M1, M2).
-
-map.count(M) = N :-
- map.count(M, N).
-
-map.from_corresponding_lists(Ks, Vs) = M :-
- map.from_corresponding_lists(Ks, Vs, M).
-
-map.merge(M1, M2) = M3 :-
- map.merge(M1, M2, M3).
-
-map.old_merge(M1, M2) = M3 :-
- map.old_merge(M1, M2, M3).
-
-map.overlay(M1, M2) = M3 :-
- map.overlay(M1, M2, M3).
-
-map.overlay_large_map(M1, M2) = M3 :-
- map.overlay_large_map(M1, M2, M3).
-
-map.select(M1, S) = M2 :-
- map.select(M1, S, M2).
-
-map.apply_to_list(Ks, M) = Vs :-
- map.apply_to_list(Ks, M, Vs).
-
-map.optimize(M1) = M2 :-
- map.optimize(M1, M2).
-
-map.foldl(F, M, A) = B :-
- P = (pred(W::in, X::in, Y::in, Z::out) is det :- Z = F(W, X, Y) ),
- map.foldl(P, M, A, B).
-
-map.foldr(F, M, A) = B :-
- P = (pred(W::in, X::in, Y::in, Z::out) is det :- Z = F(W, X, Y) ),
- map.foldr(P, M, A, B).
-
-map.map_values(F, M1) = M2 :-
- P = (pred(X::in, Y::in, Z::out) is det :- Z = F(X, Y) ),
- map.map_values(P, M1, M2).
-
-map.map_values_only(F, M1) = M2 :-
- P = (pred(Y::in, Z::out) is det :- Z = F(Y) ),
- map.map_values_only(P, M1, M2).
-
-map.intersect(F, M1, M2) = M3 :-
- P = (pred(X::in, Y::in, Z::out) is det :- Z = F(X, Y) ),
- map.intersect(P, M1, M2, M3).
-
-map.det_intersect(PF, M1, M2) = M3 :-
- P = (pred(X::in, Y::in, Z::out) is semidet :- Z = PF(X, Y) ),
- map.det_intersect(P, M1, M2, M3).
-
-map.union(F, M1, M2) = M3 :-
- P = (pred(X::in, Y::in, Z::out) is det :- Z = F(X, Y) ),
- map.union(P, M1, M2, M3).
-
-map.det_union(F, M1, M2) = M3 :-
- P = (pred(X::in, Y::in, Z::out) is semidet :- Z = F(X, Y) ),
- map.det_union(P, M1, M2, M3).
-
map.reverse_map(Map) = RevMap :-
map.foldl(map.reverse_map_2, Map, map.init, RevMap).
@@ -1325,3 +1320,7 @@
'elem :='(Key, Map, Value) = map.set(Map, Key, Value).
'det_elem :='(Key, Map, Value) = map.det_update(Map, Key, Value).
+
+%-----------------------------------------------------------------------------%
+:- end_module map.
+%-----------------------------------------------------------------------------%
Index: library/rbtree.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/library/rbtree.m,v
retrieving revision 1.31
diff -u -r1.31 rbtree.m
--- library/rbtree.m 5 May 2011 04:35:34 -0000 1.31
+++ library/rbtree.m 18 May 2011 15:17:19 -0000
@@ -66,13 +66,13 @@
% Inserts a new key-value pair into the tree.
% Fails if key already in the tree.
%
-:- pred rbtree.insert(rbtree(K, V)::in, K::in, V::in,
- rbtree(K, V)::out) is semidet.
+:- pred rbtree.insert(K::in, V::in, rbtree(K, V)::in, rbtree(K, V)::out)
+ is semidet.
% Updates the value associated with a key.
% Fails if the key does not exist.
%
-:- pred rbtree.update(rbtree(K, V)::in, K::in, V::in, rbtree(K, V)::out)
+:- pred rbtree.update(K::in, V::in, rbtree(K, V)::in, rbtree(K, V)::out)
is semidet.
% Update the value at the given key by applying the supplied
@@ -85,13 +85,13 @@
% Sets a value regardless of whether key exists or not.
%
:- func rbtree.set(rbtree(K, V), K, V) = rbtree(K, V).
-:- pred rbtree.set(rbtree(K, V)::in, K::in, V::in, rbtree(K, V)::out) is det.
+:- pred rbtree.set(K::in, V::in, rbtree(K, V)::in, rbtree(K, V)::out) is det.
% Insert a duplicate key into the tree.
%
:- func rbtree.insert_duplicate(rbtree(K, V), K, V) = rbtree(K, V).
-:- pred rbtree.insert_duplicate(rbtree(K, V)::in, K::in, V::in,
- rbtree(K, V)::out) is det.
+:- pred rbtree.insert_duplicate(K::in, V::in,
+ rbtree(K, V)::in, rbtree(K, V)::out) is det.
:- pred rbtree.member(rbtree(K, V)::in, K::out, V::out) is nondet.
@@ -138,25 +138,25 @@
% Does nothing if the key does not exist.
%
:- func rbtree.delete(rbtree(K, V), K) = rbtree(K, V).
-:- pred rbtree.delete(rbtree(K, V)::in, K::in, rbtree(K, V)::out) is det.
+:- pred rbtree.delete(K::in, rbtree(K, V)::in, rbtree(K, V)::out) is det.
% Remove the key-value pair associated with a key.
% Fails if the key does not exist.
%
-:- pred rbtree.remove(rbtree(K, V)::in, K::in, V::out,
- rbtree(K, V)::out) is semidet.
+:- pred rbtree.remove(K::in, V::out, rbtree(K, V)::in, rbtree(K, V)::out)
+ is semidet.
% Deletes the node with the minimum key from the tree,
% and returns the key and value fields.
%
-:- pred rbtree.remove_smallest(rbtree(K, V)::in, K::out, V::out,
- rbtree(K, V)::out) is semidet.
+:- pred rbtree.remove_smallest(K::out, V::out,
+ rbtree(K, V)::in, rbtree(K, V)::out) is semidet.
% Deletes the node with the maximum key from the tree,
% and returns the key and value fields.
%
-:- pred rbtree.remove_largest(rbtree(K, V)::in, K::out, V::out,
- rbtree(K, V)::out) is semidet.
+:- pred rbtree.remove_largest(K::out, V::out,
+ rbtree(K, V)::in, rbtree(K, V)::out) is semidet.
% Returns an in-order list of all the keys in the rbtree.
%
@@ -189,19 +189,30 @@
:- func rbtree.foldl(func(K, V, T) = T, rbtree(K, V), T) = T.
:- pred rbtree.foldl(pred(K, V, T, T), rbtree(K, V), T, T).
:- mode rbtree.foldl(pred(in, in, in, out) is det, in, in, out) is det.
+:- mode rbtree.foldl(pred(in, in, mdi, muo) is det, in, mdi, muo) is det.
+:- mode rbtree.foldl(pred(in, in, di, uo) is det, in, di, uo) is det.
:- mode rbtree.foldl(pred(in, in, in, out) is semidet, in, in, out)
is semidet.
-:- mode rbtree.foldl(pred(in, in, di, uo) is det, in, di, uo) is det.
+:- mode rbtree.foldl(pred(in, in, mdi, muo) is semidet, in, mdi, muo)
+ is semidet.
+:- mode rbtree.foldl(pred(in, in, di, uo) is semidet, in, di, uo)
+ is semidet.
:- pred rbtree.foldl2(pred(K, V, T, T, U, U), rbtree(K, V), T, T, U, U).
:- mode rbtree.foldl2(pred(in, in, in, out, in, out) is det,
in, in, out, in, out) is det.
-:- mode rbtree.foldl2(pred(in, in, in, out, in, out) is semidet,
- in, in, out, in, out) is semidet.
+:- mode rbtree.foldl2(pred(in, in, in, out, mdi, muo) is det,
+ in, in, out, mdi, muo) is det.
:- mode rbtree.foldl2(pred(in, in, in, out, di, uo) is det,
in, in, out, di, uo) is det.
:- mode rbtree.foldl2(pred(in, in, di, uo, di, uo) is det,
in, di, uo, di, uo) is det.
+:- mode rbtree.foldl2(pred(in, in, in, out, in, out) is semidet,
+ in, in, out, in, out) is semidet.
+:- mode rbtree.foldl2(pred(in, in, in, out, mdi, muo) is semidet,
+ in, in, out, mdi, muo) is semidet.
+:- mode rbtree.foldl2(pred(in, in, in, out, di, uo) is semidet,
+ in, in, out, di, uo) is semidet.
:- pred rbtree.foldl3(pred(K, V, T, T, U, U, W, W), rbtree(K, V),
T, T, U, U, W, W).
@@ -241,6 +252,9 @@
%-----------------------------------------------------------------------------%
+rbtree.init = RBT :-
+ rbtree.init(RBT).
+
rbtree.init(empty).
rbtree.is_empty(Tree) :-
@@ -254,10 +268,10 @@
% * The root node must be black.
% * There can never be 2 red nodes in a row.
-rbtree.insert(empty, K, V, black(K, V, empty, empty)).
-rbtree.insert(red(_, _, _, _), _K, _V, _Tree) :-
+rbtree.insert(K, V, empty, black(K, V, empty, empty)).
+rbtree.insert(_K, _V, red(_, _, _, _), _Tree) :-
error("rbtree.insert: root node cannot be red!").
-rbtree.insert(black(K0, V0, L0, R0), K, V, Tree) :-
+rbtree.insert(K, V, black(K0, V0, L0, R0), Tree) :-
rbtree.insert_2(black(K0, V0, L0, R0), K, V, Tree0),
% Ensure that the root of the tree is black.
(
@@ -268,7 +282,7 @@
Tree = black(K1, V1, L1, R1)
;
Tree0 = empty,
- error("rbtree.set: new tree is empty")
+ error("rbtree.insert: new tree is empty")
).
% rbtree.insert_2:
@@ -369,34 +383,34 @@
%-----------------------------------------------------------------------------%
-rbtree.update(empty, _K, _V, _T) :-
+rbtree.update(_K, _V, empty, _T) :-
fail.
-rbtree.update(red(K0, V0, L, R), K, V, Tree) :-
+rbtree.update(K, V, red(K0, V0, L, R), Tree) :-
compare(Result, K, K0),
(
Result = (=),
Tree = red(K, V, L, R)
;
Result = (<),
- rbtree.update(L, K, V, NewL),
+ rbtree.update(K, V, L, NewL),
Tree = red(K0, V0, NewL, R)
;
Result = (>),
- rbtree.update(R, K, V, NewR),
+ rbtree.update(K, V, R, NewR),
Tree = red(K0, V0, L, NewR)
).
-rbtree.update(black(K0, V0, L, R), K, V, Tree) :-
+rbtree.update(K, V, black(K0, V0, L, R), Tree) :-
compare(Result, K, K0),
(
Result = (=),
Tree = black(K, V, L, R)
;
Result = (<),
- rbtree.update(L, K, V, NewL),
+ rbtree.update(K, V, L, NewL),
Tree = black(K0, V0, NewL, R)
;
Result = (>),
- rbtree.update(R, K, V, NewR),
+ rbtree.update(K, V, R, NewR),
Tree = black(K0, V0, L, NewR)
).
@@ -441,10 +455,13 @@
% * The root node must be black.
% * There can never be 2 red nodes in a row.
-rbtree.set(empty, K, V, black(K, V, empty, empty)).
-rbtree.set(red(_, _, _, _), _K, _V, _Tree) :-
+rbtree.set(!.RBT, K, V) = !:RBT :-
+ rbtree.set(K, V, !RBT).
+
+rbtree.set(K, V, empty, black(K, V, empty, empty)).
+rbtree.set(_K, _V, red(_, _, _, _), _Tree) :-
error("rbtree.set: root node cannot be red!").
-rbtree.set(black(K0, V0, L0, R0), K, V, Tree) :-
+rbtree.set(K, V, black(K0, V0, L0, R0), Tree) :-
rbtree.set_2(black(K0, V0, L0, R0), K, V, Tree0),
% Ensure that the root of the tree is black.
(
@@ -563,10 +580,13 @@
% * The root node must be black.
% * There can never be 2 red nodes in a row.
-rbtree.insert_duplicate(empty, K, V, black(K, V, empty, empty)).
-rbtree.insert_duplicate(red(_, _, _, _), _K, _V, _Tree) :-
+rbtree.insert_duplicate(!.RBT, K, V) = !:RBT :-
+ rbtree.insert_duplicate(K, V, !RBT).
+
+rbtree.insert_duplicate(K, V, empty, black(K, V, empty, empty)).
+rbtree.insert_duplicate(_K, _V, red(_, _, _, _), _Tree) :-
error("rbtree.insert_duplicate: root node cannot be red!").
-rbtree.insert_duplicate(black(K0, V0, L0, R0), K, V, Tree) :-
+rbtree.insert_duplicate(K, V, black(K0, V0, L0, R0), Tree) :-
rbtree.insert_duplicate_2(black(K0, V0, L0, R0), K, V, Tree0),
% Ensure that the root of the tree is black.
( Tree0 = red(K1, V1, L1, R1) ->
@@ -731,6 +751,9 @@
rbtree.search(Right, K, V)
).
+rbtree.lookup(RBT, K) = V :-
+ rbtree.lookup(RBT, K, V).
+
rbtree.lookup(T, K, V) :-
( rbtree.search(T, K, V0) ->
V = V0
@@ -808,8 +831,11 @@
%-----------------------------------------------------------------------------%
-rbtree.delete(Tree0, K, Tree) :-
- rbtree.delete_2(Tree0, K, no, _, Tree).
+rbtree.delete(!.RBT, K) = !:RBT :-
+ rbtree.delete(K, !RBT).
+
+rbtree.delete(K, !Tree) :-
+ rbtree.delete_2(!.Tree, K, no, _, !:Tree).
% rbtree.delete_2(Tree0, Key, MustRemove, MaybeValue, Tree):
%
@@ -842,11 +868,11 @@
compare(Result, K, K0),
(
Result = (=),
- ( rbtree.remove_largest(L, NewK, NewV, NewL) ->
+ ( rbtree.remove_largest(NewK, NewV, L, NewL) ->
Tree = red(NewK, NewV, NewL, R)
;
% L must be empty.
- ( rbtree.remove_smallest(R, NewK, NewV, NewR) ->
+ ( rbtree.remove_smallest(NewK, NewV, R, NewR) ->
Tree = red(NewK, NewV, empty, NewR)
;
% R must be empty
@@ -867,11 +893,11 @@
compare(Result, K, K0),
(
Result = (=),
- ( rbtree.remove_largest(L, NewK, NewV, NewL) ->
+ ( rbtree.remove_largest(NewK, NewV, L, NewL) ->
Tree = black(NewK, NewV, NewL, R)
;
% L must be empty
- ( rbtree.remove_smallest(R, NewK, NewV, NewR) ->
+ ( rbtree.remove_smallest(NewK, NewV, R, NewR) ->
Tree = black(NewK, NewV, empty, NewR)
;
% R must be empty
@@ -891,12 +917,12 @@
%-----------------------------------------------------------------------------%
-rbtree.remove(Tree0, K, V, Tree) :-
- rbtree.delete_2(Tree0, K, yes, yes(V), Tree).
+rbtree.remove(K, V, !Tree) :-
+ rbtree.delete_2(!.Tree, K, yes, yes(V), !:Tree).
-rbtree.remove_largest(empty, _K, _V, _Tree) :-
+rbtree.remove_largest(_K, _V, empty, _Tree) :-
fail.
-rbtree.remove_largest(red(K0, V0, L, R), NewK, NewV, Tree) :-
+rbtree.remove_largest(NewK, NewV, red(K0, V0, L, R), Tree) :-
(
R = empty,
NewK = K0,
@@ -906,10 +932,10 @@
( R = red(_, _, _, _)
; R = black(_, _, _, _)
),
- rbtree.remove_largest(R, NewK, NewV, NewR),
+ rbtree.remove_largest(NewK, NewV, R, NewR),
Tree = red(K0, V0, L, NewR)
).
-rbtree.remove_largest(black(K0, V0, L, R), NewK, NewV, Tree) :-
+rbtree.remove_largest(NewK, NewV, black(K0, V0, L, R), Tree) :-
(
R = empty,
NewK = K0,
@@ -919,7 +945,7 @@
( R = red(_, _, _, _)
; R = black(_, _, _, _)
),
- rbtree.remove_largest(R, NewK, NewV, NewR),
+ rbtree.remove_largest(NewK, NewV, R, NewR),
Tree = black(K0, V0, L, NewR)
).
@@ -927,9 +953,9 @@
% Deletes the node with the minimum K from the tree, and returns the
% key and value fields.
-rbtree.remove_smallest(empty, _K, _V, _Tree) :-
+rbtree.remove_smallest(_K, _V, empty, _Tree) :-
fail.
-rbtree.remove_smallest(red(K0, V0, L, R), NewK, NewV, Tree) :-
+rbtree.remove_smallest(NewK, NewV, red(K0, V0, L, R), Tree) :-
(
L = empty,
NewK = K0,
@@ -939,10 +965,10 @@
( L = red(_, _, _, _)
; L = black(_, _, _, _)
),
- rbtree.remove_smallest(L, NewK, NewV, NewL),
+ rbtree.remove_smallest(NewK, NewV, L, NewL),
Tree = red(K0, V0, NewL, R)
).
-rbtree.remove_smallest(black(K0, V0, L, R), NewK, NewV, Tree) :-
+rbtree.remove_smallest(NewK, NewV, black(K0, V0, L, R), Tree) :-
(
L = empty,
NewK = K0,
@@ -952,12 +978,15 @@
( L = red(_, _, _, _)
; L = black(_, _, _, _)
),
- rbtree.remove_smallest(L, NewK, NewV, NewL),
+ rbtree.remove_smallest(NewK, NewV, L, NewL),
Tree = black(K0, V0, NewL, R)
).
%-----------------------------------------------------------------------------%
+rbtree.keys(RBT) = Ks :-
+ rbtree.keys(RBT, Ks).
+
rbtree.keys(empty, []).
rbtree.keys(red(K0, _V0, L, R), List) :-
rbtree.keys(L, List0),
@@ -970,6 +999,9 @@
%-----------------------------------------------------------------------------%
+rbtree.values(RBT) = Vs :-
+ rbtree.values(RBT, Vs).
+
rbtree.values(empty, []).
rbtree.values(red(_K0, V0, L, R), List) :-
rbtree.values(L, List0),
@@ -982,6 +1014,9 @@
%-----------------------------------------------------------------------------%
+rbtree.count(RBT) = N :-
+ rbtree.count(RBT, N).
+
rbtree.count(empty, 0).
rbtree.count(red(_K, _V, L, R), N) :-
rbtree.count(L, NO),
@@ -994,13 +1029,23 @@
%-----------------------------------------------------------------------------%
+rbtree.from_assoc_list(AList) = rbtree.assoc_list_to_rbtree(AList).
+
+rbtree.assoc_list_to_rbtree(AL) = RBT :-
+ rbtree.assoc_list_to_rbtree(AL, RBT).
+
rbtree.assoc_list_to_rbtree([], empty).
-rbtree.assoc_list_to_rbtree([K - V|T], Tree) :-
+rbtree.assoc_list_to_rbtree([K - V | T], Tree) :-
rbtree.assoc_list_to_rbtree(T, Tree0),
- rbtree.set(Tree0, K, V, Tree).
+ rbtree.set(K, V, Tree0, Tree).
%-----------------------------------------------------------------------------%
+rbtree.to_assoc_list(T) = rbtree.rbtree_to_assoc_list(T).
+
+rbtree.rbtree_to_assoc_list(RBT) = AL :-
+ rbtree.rbtree_to_assoc_list(RBT, AL).
+
rbtree.rbtree_to_assoc_list(empty, []).
rbtree.rbtree_to_assoc_list(red(K0, V0, Left, Right), L) :-
rbtree.rbtree_to_assoc_list(Left, L0),
@@ -1013,6 +1058,10 @@
%-----------------------------------------------------------------------------%
+rbtree.foldl(F, T, A) = B :-
+ P = ( pred(W::in, X::in, Y::in, Z::out) is det :- Z = F(W, X, Y) ),
+ rbtree.foldl(P, T, A, B).
+
rbtree.foldl(_Pred, empty, !Acc).
rbtree.foldl(Pred, red(K, V, Left, Right), !Acc) :-
rbtree.foldl(Pred, Left, !Acc),
@@ -1049,6 +1098,10 @@
%-----------------------------------------------------------------------------%
+rbtree.map_values(F, T1) = T2 :-
+ P = ( pred(X::in, Y::in, Z::out) is det :- Z = F(X, Y) ),
+ rbtree.map_values(P, T1, T2).
+
rbtree.map_values(_Pred, empty, empty).
rbtree.map_values(Pred, Tree0, Tree) :-
Tree0 = red(K0, V0, Left0, Right0),
@@ -1064,52 +1117,5 @@
Tree = black(K0, W0, Left, Right).
%-----------------------------------------------------------------------------%
-%-----------------------------------------------------------------------------%
-% Ralph Becket <rwab1 at cl.cam.ac.uk> 29/04/99
-% Function forms added.
-
-rbtree.init = RBT :-
- rbtree.init(RBT).
-
-rbtree.set(RBT1, K, V) = RBT2 :-
- rbtree.set(RBT1, K, V, RBT2).
-
-rbtree.insert_duplicate(RBT1, K, V) = RBT2 :-
- rbtree.insert_duplicate(RBT1, K, V, RBT2).
-
-rbtree.lookup(RBT, K) = V :-
- rbtree.lookup(RBT, K, V).
-
-rbtree.delete(RBT1, K) = RBT2 :-
- rbtree.delete(RBT1, K, RBT2).
-
-rbtree.keys(RBT) = Ks :-
- rbtree.keys(RBT, Ks).
-
-rbtree.values(RBT) = Vs :-
- rbtree.values(RBT, Vs).
-
-rbtree.count(RBT) = N :-
- rbtree.count(RBT, N).
-
-rbtree.assoc_list_to_rbtree(AL) = RBT :-
- rbtree.assoc_list_to_rbtree(AL, RBT).
-
-rbtree.rbtree_to_assoc_list(RBT) = AL :-
- rbtree.rbtree_to_assoc_list(RBT, AL).
-
-rbtree.foldl(F, T, A) = B :-
- P = ( pred(W::in, X::in, Y::in, Z::out) is det :- Z = F(W, X, Y) ),
- rbtree.foldl(P, T, A, B).
-
-rbtree.map_values(F, T1) = T2 :-
- P = ( pred(X::in, Y::in, Z::out) is det :- Z = F(X, Y) ),
- rbtree.map_values(P, T1, T2).
-
-rbtree.from_assoc_list(AList) = rbtree.assoc_list_to_rbtree(AList).
-
-rbtree.to_assoc_list(T) = rbtree.rbtree_to_assoc_list(T).
-
-%-----------------------------------------------------------------------------%
:- end_module rbtree.
%-----------------------------------------------------------------------------%
Index: library/tree234.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/library/tree234.m,v
retrieving revision 1.72
diff -u -r1.72 tree234.m
--- library/tree234.m 6 May 2011 05:03:28 -0000 1.72
+++ library/tree234.m 18 May 2011 15:14:53 -0000
@@ -74,21 +74,21 @@
:- func tree234.min_key(tree234(K, V)) = K is semidet.
-:- pred tree234.insert(tree234(K, V)::in, K::in, V::in, tree234(K, V)::out)
+:- pred tree234.insert(K::in, V::in, tree234(K, V)::in, tree234(K, V)::out)
is semidet.
:- func tree234.set(tree234(K, V), K, V) = tree234(K, V).
-:- pred tree234.set(tree234(K, V)::in, K::in, V::in, tree234(K, V)::out)
+:- pred tree234.set(K::in, V::in, tree234(K, V)::in, tree234(K, V)::out)
is det.
:- func tree234.delete(tree234(K, V), K) = tree234(K, V).
-:- pred tree234.delete(tree234(K, V)::in, K::in, tree234(K, V)::out) is det.
+:- pred tree234.delete(K::in, tree234(K, V)::in, tree234(K, V)::out) is det.
-:- pred tree234.remove(tree234(K, V), K, V, tree234(K, V)).
-:- mode tree234.remove(in, in, out, out) is semidet.
+:- pred tree234.remove(K, V, tree234(K, V), tree234(K, V)).
+:- mode tree234.remove(in, out, in, out) is semidet.
-:- pred tree234.remove_smallest(tree234(K, V), K, V, tree234(K, V)).
-:- mode tree234.remove_smallest(in, out, out, out) is semidet.
+:- pred tree234.remove_smallest(K, V, tree234(K, V), tree234(K, V)).
+:- mode tree234.remove_smallest(out, out, in, out) is semidet.
% Given a tree234, return a list of all the keys in the tree.
% The list that is returned is in sorted order.
@@ -99,7 +99,7 @@
:- func tree234.values(tree234(K, V)) = list(V).
:- pred tree234.values(tree234(K, V)::in, list(V)::out) is det.
-:- pred tree234.update(tree234(K, V)::in, K::in, V::in, tree234(K, V)::out)
+:- pred tree234.update(K::in, V::in, tree234(K, V)::in, tree234(K, V)::out)
is semidet.
% Update the value at the given key by applying the supplied
@@ -889,7 +889,7 @@
%------------------------------------------------------------------------------%
-tree234.update(Tin, K, V, Tout) :-
+tree234.update(K, V, Tin, Tout) :-
(
Tin = empty,
fail
@@ -898,14 +898,14 @@
compare(Result, K, K0),
(
Result = (<),
- tree234.update(T0, K, V, NewT0),
+ tree234.update(K, V, T0, NewT0),
Tout = two(K0, V0, NewT0, T1)
;
Result = (=),
Tout = two(K0, V, T0, T1)
;
Result = (>),
- tree234.update(T1, K, V, NewT1),
+ tree234.update(K, V, T1, NewT1),
Tout = two(K0, V0, T0, NewT1)
)
;
@@ -913,7 +913,7 @@
compare(Result0, K, K0),
(
Result0 = (<),
- tree234.update(T0, K, V, NewT0),
+ tree234.update(K, V, T0, NewT0),
Tout = three(K0, V0, K1, V1, NewT0, T1, T2)
;
Result0 = (=),
@@ -923,14 +923,14 @@
compare(Result1, K, K1),
(
Result1 = (<),
- tree234.update(T1, K, V, NewT1),
+ tree234.update(K, V, T1, NewT1),
Tout = three(K0, V0, K1, V1, T0, NewT1, T2)
;
Result1 = (=),
Tout = three(K0, V0, K1, V, T0, T1, T2)
;
Result1 = (>),
- tree234.update(T2, K, V, NewT2),
+ tree234.update(K, V, T2, NewT2),
Tout = three(K0, V0, K1, V1, T0, T1, NewT2)
)
)
@@ -942,14 +942,14 @@
compare(Result0, K, K0),
(
Result0 = (<),
- tree234.update(T0, K, V, NewT0),
+ tree234.update(K, V, T0, NewT0),
Tout = four(K0, V0, K1, V1, K2, V2, NewT0, T1, T2, T3)
;
Result0 = (=),
Tout = four(K0, V, K1, V1, K2, V2, T0, T1, T2, T3)
;
Result0 = (>),
- tree234.update(T1, K, V, NewT1),
+ tree234.update(K, V, T1, NewT1),
Tout = four(K0, V0, K1, V1, K2, V2, T0, NewT1, T2, T3)
)
;
@@ -960,14 +960,14 @@
compare(Result2, K, K2),
(
Result2 = (<),
- tree234.update(T2, K, V, NewT2),
+ tree234.update(K, V, T2, NewT2),
Tout = four(K0, V0, K1, V1, K2, V2, T0, T1, NewT2, T3)
;
Result2 = (=),
Tout = four(K0, V0, K1, V1, K2, V, T0, T1, T2, T3)
;
Result2 = (>),
- tree234.update(T3, K, V, NewT3),
+ tree234.update(K, V, T3, NewT3),
Tout = four(K0, V0, K1, V1, K2, V2, T0, T1, T2, NewT3)
)
)
@@ -1116,7 +1116,7 @@
% we have already split 4-nodes into 2-nodes), or if the tree itself is
% empty. This algorithm is O(lgN).
-tree234.insert(Tin, K, V, Tout) :-
+tree234.insert(K, V, Tin, Tout) :-
(
Tin = empty,
Tout = two(K, V, empty, empty)
@@ -1387,7 +1387,7 @@
% tree234.set uses the same algorithm as used for tree234.insert,
% except that instead of failing for equal keys, we replace the value.
-tree234.set(Tin, K, V, Tout) :-
+tree234.set(K, V, Tin, Tout) :-
(
Tin = empty,
Tout = two(K, V, empty, empty)
@@ -1660,7 +1660,7 @@
%------------------------------------------------------------------------------%
%------------------------------------------------------------------------------%
-tree234.delete(Tin, K, Tout) :-
+tree234.delete(K, Tin, Tout) :-
tree234.delete_2(Tin, K, Tout, _).
% When deleting an item from a tree, the height of the tree may be
@@ -1912,7 +1912,7 @@
% We use the same algorithm as tree234.delete.
-tree234.remove(Tin, K, V, Tout) :-
+tree234.remove(K, V, Tin, Tout) :-
tree234.remove_2(Tin, K, V, Tout, _).
:- pred tree234.remove_2(tree234(K, V), K, V, tree234(K, V), bool).
@@ -2165,7 +2165,7 @@
% The algorithm we use similar to tree234.delete, except that we
% always go down the left subtree.
-tree234.remove_smallest(Tin, K, V, Tout) :-
+tree234.remove_smallest(K, V, Tin, Tout) :-
tree234.remove_smallest_2(Tin, K, V, Tout, _).
:- pred tree234.remove_smallest_2(tree234(K, V), K, V, tree234(K, V), bool).
@@ -2602,9 +2602,9 @@
tree234(K, V)::in, tree234(K, V)::out) is det.
tree234.assoc_list_to_tree234_2([], Tree, Tree).
-tree234.assoc_list_to_tree234_2([K - V | Rest], Tree0, Tree) :-
- tree234.set(Tree0, K, V, Tree1),
- tree234.assoc_list_to_tree234_2(Rest, Tree1, Tree).
+tree234.assoc_list_to_tree234_2([K - V | Rest], !Tree) :-
+ tree234.set(K, V, !Tree),
+ tree234.assoc_list_to_tree234_2(Rest, !Tree).
%------------------------------------------------------------------------------%
@@ -3060,11 +3060,11 @@
tree234.lookup(T, K) = V :-
tree234.lookup(T, K, V).
-tree234.set(T1, K, V) = T2 :-
- tree234.set(T1, K, V, T2).
+tree234.set(!.T, K, V) = !:T :-
+ tree234.set(K, V, !T).
-tree234.delete(T1, K) = T2 :-
- tree234.delete(T1, K, T2).
+tree234.delete(!.T, K) = !:T :-
+ tree234.delete(K, !T).
tree234.keys(T) = Ks :-
tree234.keys(T, Ks).
@@ -3478,4 +3478,5 @@
depth_levels(T4, NextDepth, !Depths).
%-----------------------------------------------------------------------------%
+:- end_module tree234.
%-----------------------------------------------------------------------------%
Index: profiler/generate_output.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/profiler/generate_output.m,v
retrieving revision 1.26
diff -u -r1.26 generate_output.m
--- profiler/generate_output.m 3 May 2011 04:35:01 -0000 1.26
+++ profiler/generate_output.m 18 May 2011 12:11:12 -0000
@@ -153,7 +153,7 @@
DescPercentage, DescTime, TotalCalls, SelfCalls, [], []),
map.det_insert(Name, OutputProfNode, InfoMap0, InfoMap),
- rbtree.insert_duplicate(CallTree0, DescPercentage, Name, CallTree),
+ rbtree.insert_duplicate(DescPercentage, Name, CallTree0, CallTree),
!:OutputProf = profiling(InfoMap, CallTree, FreeTree).
@@ -215,11 +215,10 @@
),
map.det_insert(LabelName, OutputProfNode, InfoMap0, InfoMap),
- rbtree.insert_duplicate(CallTree0, DescPercentage,
- LabelName, CallTree),
- rbtree.insert_duplicate(FlatTree0,
- flat_key(FlatPercentage, TotalCalls),
- LabelName, FlatTree),
+ rbtree.insert_duplicate(DescPercentage, LabelName,
+ CallTree0, CallTree),
+ rbtree.insert_duplicate(flat_key(FlatPercentage, TotalCalls),
+ LabelName, FlatTree0, FlatTree),
!:OutputProf = profiling(InfoMap, CallTree, FlatTree)
).
@@ -323,7 +322,7 @@
Parent = parent(LabelName, ParentCycleNum, PropSelfTime, PropDescTime,
Calls),
- rbtree.insert_duplicate(!.Output, Calls, Parent, !:Output),
+ rbtree.insert_duplicate(Calls, Parent, !Output),
process_prof_node_parents_3(PNs, SelfTime, DescTime, TotalCalls,
CycleMap, !Output).
@@ -405,7 +404,7 @@
Child = child(LabelName, CycleNum, PropSelfTime, PropDescTime, Calls,
TotalCalls),
- rbtree.insert_duplicate(!.Output, Calls, Child, !:Output),
+ rbtree.insert_duplicate(Calls, Child, !Output),
process_prof_node_children_2(PNs, Prof, !Output).
% assign_index_numbers(IndexMap, RevList, List):
Index: tests/debugger/declarative/mapinit.m
===================================================================
RCS file: /home/mercury/mercury1/repository/tests/debugger/declarative/mapinit.m,v
retrieving revision 1.1
diff -u -r1.1 mapinit.m
--- tests/debugger/declarative/mapinit.m 13 Mar 2003 01:47:11 -0000 1.1
+++ tests/debugger/declarative/mapinit.m 18 May 2011 14:49:00 -0000
@@ -39,4 +39,4 @@
:- pred xmap_set(xmap(K, V)::in, K::in, V::in, xmap(K, V)::out) is det.
xmap_set(Map0, Key, Value, Map) :-
- tree234__set(Map0, Key, Value, Map).
+ tree234__set(Key, Value, Map0, Map).
Index: tests/hard_coded/transform_value.m
===================================================================
RCS file: /home/mercury/mercury1/repository/tests/hard_coded/transform_value.m,v
retrieving revision 1.1
diff -u -r1.1 transform_value.m
--- tests/hard_coded/transform_value.m 13 Jan 2005 11:04:38 -0000 1.1
+++ tests/hard_coded/transform_value.m 18 May 2011 12:13:22 -0000
@@ -11,19 +11,19 @@
:- implementation.
-:- import_module map, int, svmap, list, assoc_list, rbtree.
+:- import_module map, int, list, assoc_list, rbtree.
main(!IO) :-
some [!M] (
!:M = map.init,
- svmap.set(1, 1, !M),
- svmap.set(2, 1, !M),
- svmap.set(3, 1, !M),
- svmap.set(4, 1, !M),
- svmap.set(5, 1, !M),
- svmap.set(6, 1, !M),
- svmap.set(7, 1, !M),
- svmap.set(8, 1, !M),
+ map.set(1, 1, !M),
+ map.set(2, 1, !M),
+ map.set(3, 1, !M),
+ map.set(4, 1, !M),
+ map.set(5, 1, !M),
+ map.set(6, 1, !M),
+ map.set(7, 1, !M),
+ map.set(8, 1, !M),
M0 = !.M,
( map.transform_value(add1, 2, !.M, M1) ->
io.write_int(M1 ^ det_elem(2), !IO)
@@ -49,8 +49,8 @@
io.write(A, !IO),
io.nl(!IO),
RB0 = rbtree.init,
- rbtree.set(RB0, 1, 1, RB1),
- rbtree.set(RB1, 2, 1, RB2),
+ rbtree.set(1, 1, RB0, RB1),
+ rbtree.set(2, 1, RB1, RB2),
(
rbtree.transform_value(add1, 1, RB2, RB3),
rbtree.transform_value(add1, 2, RB3, RB4)
--------------------------------------------------------------------------
mercury-reviews mailing list
Post messages to: mercury-reviews at csse.unimelb.edu.au
Administrative Queries: owner-mercury-reviews at csse.unimelb.edu.au
Subscriptions: mercury-reviews-request at csse.unimelb.edu.au
--------------------------------------------------------------------------
More information about the reviews
mailing list