[m-rev.] diff: delete the graph and group modules from the stdlib
Julien Fischer
juliensf at csse.unimelb.edu.au
Tue May 10 02:42:45 AEST 2011
Branches: main
Delete some deprecated modules from the standard library.
library/graph.m:
library/group.m:
Delete the contents of these files.
library/library.m:
Do not include the above modules in the library.
tests/invalid/missing_interface_import3.m:
tests/invalid/missing_interface_import2.{m,err_exp}:
Replace a use of the group module in this test.
NEWS:
Announce the above, plus the recent removal of the relation
module.
Julien.
Index: NEWS
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/NEWS,v
retrieving revision 1.566
diff -u -r1.566 NEWS
--- NEWS 8 May 2011 16:02:21 -0000 1.566
+++ NEWS 9 May 2011 16:39:29 -0000
@@ -95,6 +95,9 @@
version_hash_table.unsafe_new_default/1
version_store.new/1
+* The deprecated modules graph, group and relation are no longer included
+ in the library.
+
NEWS for Mercury 11.01
----------------------
Index: library/graph.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/library/graph.m,v
retrieving revision 1.36
diff -u -r1.36 graph.m
--- library/graph.m 3 May 2011 04:35:01 -0000 1.36
+++ library/graph.m 6 May 2011 15:22:18 -0000
@@ -1,377 +1,3 @@
%---------------------------------------------------------------------------%
-% vim: ft=mercury ts=4 sw=4 et wm=0 tw=0
+% THIS FILE IS NO LONGER USED.
%---------------------------------------------------------------------------%
-% Copyright (C) 1994-1999, 2003, 2005-2006, 2010-2011 The University of Melbourne.
-% This file may only be copied under the terms of the GNU Library General
-% Public License - see the file COPYING.LIB in the Mercury distribution.
-%------------------------------------------------------------------------------%
-%
-% File: graph.m.
-% Main author: conway.
-% Stability: low.
-%
-% This module defines a directed graph data type. The type graph(N, A)
-% stores information of type N in the nodes, and information of type A
-% in the arcs.
-%
-%------------------------------------------------------------------------------%
-%------------------------------------------------------------------------------%
-
-:- module graph.
-:- interface.
-
-:- import_module list.
-:- import_module set.
-:- import_module unit.
-
-%------------------------------------------------------------------------------%
-
- % graph(Node, Arc) represents a directed graph with information of
- % type Node associated with each node, and information of type Arc
- % associated with each arc.
- %
-:- type graph(N, A).
-
-:- type node(N).
-
-:- type arc(A).
-
- % Lots of graphs don't need to store anything in the arcs so here's
- % a type equivalence that only has `real' information in the nodes.
- %
-:- type graph(N) == graph(N, unit).
-
-:- type arc == arc(unit).
-
- % graph.init(Graph) binds Graph to an empty graph containing no nodes
- % and no arcs. (The graph contains a counter of the number of nodes
- % allocated in it, so it is possible for a graph to contain no nodes
- % or arcs and still fail to unify with the binding of Graph from
- % graph.init.)
- %
-:- pred graph.init(graph(N, A)::out) is det.
-:- func graph.init = graph(N, A).
-
- % graph.set_node(OldGraph, NodeInfo, Node, NewGraph) takes
- % OldGraph and NodeInfo which is the information to be stored
- % in a new node, and returns a key "Node" which refers to that
- % node, and the new graph NewGraph containing all of the nodes
- % and arcs in OldGraph as well as the new node.
- % It is possible to have two nodes in the graph with the
- % same information stored in them.
- %
- % This operation is O(lgN) for a graph containing N nodes.
- %
-:- pred graph.set_node(graph(N, A)::in, N::in, node(N)::out,
- graph(N, A)::out) is det.
-
- % graph.insert_node/4 is the same as graph.set_node/4 except
- % that if the information to be stored in the node is stored
- % in another node, then the graph.insert_node/4 fails.
- %
- % This operation is O(N) for a graph containing N nodes since
- % this predicate has to check that the node data isn't in an
- % existing node.
- %
-:- pred graph.insert_node(graph(N, A)::in, N::in, node(N)::out,
- graph(N, A)::out) is semidet.
-
- % graph.det_insert_node/4 is like graph.insert_node, except
- % that if the insertion would fail, it calls error/1.
- %
-:- pred graph.det_insert_node(graph(N, A)::in, N::in, node(N)::out,
- graph(N, A)::out) is det.
-
- % graph.search_node(Graph, NodeInfo, Node) nondeterministically
- % produces bindings of Node such that Node is a node in Graph
- % that has the information NodeInfo attached to it.
- %
- % This operation is O(lgN) for the first solution for a graph
- % containing N nodes.
- %
-:- pred graph.search_node(graph(N, A)::in, N::in, node(N)::out) is nondet.
-
- % graph.find_matching_nodes(Graph, NodeInfo, Nodes) takes a graph
- % Graph and the information NodeInfo and returns the set of nodes
- % Nodes which have the information NodeInfo stored in them. (The set
- % Nodes will of course be empty if there are no matching nodes.)
- %
- % This operation is O(NlgN) for a graph containing N nodes.
- %
-:- pred graph.find_matching_nodes(graph(N, A)::in, N::in, set(node(N))::out)
- is det.
-:- func graph.find_matching_nodes(graph(N, A), N) = set(node(N)).
-
- % graph.node_contents(Graph, Node, NodeInfo) takes Graph and
- % Node and returns the information NodeInfo stored in Node.
- %
- % This operation is O(lgN) for a graph containing N nodes.
- %
-:- pred graph.node_contents(graph(N, A)::in, node(N)::in, N::out) is det.
-:- func graph.node_contents(graph(N, A), node(N)) = N.
-
- % graph.successors(Graph, Node, Nodes) takes a graph Graph and
- % a node Node and returns the set of nodes Nodes that are reachable
- % (directly - not transitively) from Node.
- %
- % This operation is O(NlgN) for a graph containing N nodes.
- %
-:- pred graph.successors(graph(N, A)::in, node(N)::in, set(node(N))::out)
- is det.
-:- func graph.successors(graph(N, A), node(N)) = set(node(N)).
-
- % graph.nodes(Graph, Nodes) binds Nodes to the set of nodes in Graph.
- %
-:- pred graph.nodes(graph(N, A)::in, set(node(N))::out) is det.
-:- func graph.nodes(graph(N, A)) = set(node(N)).
-
- % graph.set_edge(OldGraph, Start, End, ArcInfo, Arc, NewGraph)
- % takes a graph OldGraph and adds an arc from Start to End with
- % the information ArcInfo stored in it, and returns a key for
- % that arc Arc, and the new graph NewGraph.
- % If an identical arc already exists then this operation has
- % no effect.
- %
- % This operation is O(lgN+lgM) for a graph with N nodes and M arcs.
- %
-:- pred graph.set_edge(graph(N, A)::in, node(N)::in, node(N)::in, A::in,
- arc(A)::out, graph(N, A)::out) is det.
-
- % graph.insert_edge/6 is the same as graph.set_edge/6 except that
- % if an identical arc already exists in the graph the operation fails.
- % This is O(N) for a graph with N edges between the two nodes.
- %
-:- pred graph.insert_edge(graph(N, A)::in, node(N)::in, node(N)::in, A::in,
- arc(A)::out, graph(N, A)::out) is semidet.
-
- % graph.det_insert_edge/6 is like graph.insert_edge except
- % than instead of failing, it calls error/1.
- %
-:- pred graph.det_insert_edge(graph(N, A)::in, node(N)::in, node(N)::in,
- A::in, arc(A)::out, graph(N, A)::out) is det.
-
- % graph.arc_contents(Graph, Arc, Start, End, ArcInfo) takes a
- % graph Graph and an arc Arc and returns the start and end nodes
- % and the information stored in that arc.
- %
-:- pred graph.arc_contents(graph(N, A)::in, arc(A)::in,
- node(N)::out, node(N)::out, A::out) is det.
-
- % graph.path(Graph, Start, End, Path) is true iff there is a path
- % from the node Start to the node End in Graph that goes through
- % the sequence of arcs Arcs.
- % The algorithm will return paths containing at most one cycle.
- %
-:- pred graph.path(graph(N, A), node(N), node(N), list(arc(A))).
-:- mode graph.path(in, in, in, out) is nondet.
-:- mode graph.path(in, in, out, out) is nondet.
-
-%------------------------------------------------------------------------------%
-%------------------------------------------------------------------------------%
-
-:- implementation.
-
-:- import_module counter.
-:- import_module map.
-:- import_module require.
-:- import_module solutions.
-
-%------------------------------------------------------------------------------%
-
-:- type graph(N, A)
- ---> graph(
- node_supply :: counter,
- arc_supply :: counter,
- node_map :: map(node(N), N),
- arc_map :: map(arc(A), arc_info(N, A)),
- edge_map :: map(node(N), map(arc(A), node(N)))
- ).
-
-:- type node(N)
- ---> node(int).
-
-:- type arc(A)
- ---> arc(int).
-
-:- type arc_info(N, A)
- ---> arc_info(node(N), node(N), A).
-
-%------------------------------------------------------------------------------%
-
-graph.init(Graph) :-
- Graph = graph(counter.init(0), counter.init(0), Nodes, Arcs, Edges),
- map.init(Nodes),
- map.init(Arcs),
- map.init(Edges).
-
-%------------------------------------------------------------------------------%
-
-graph.set_node(!.G, NInfo, node(N), !:G) :-
- NS0 = !.G ^ node_supply,
- counter.allocate(N, NS0, NS),
- !G ^ node_supply := NS,
-
- Nodes0 = !.G ^ node_map,
- map.set(node(N), NInfo, Nodes0, Nodes),
- !G ^ node_map := Nodes,
-
- Edges0 = !.G ^ edge_map,
- map.init(EdgeMap),
- map.set(node(N), EdgeMap, Edges0, Edges),
- !G ^ edge_map := Edges.
-
-graph.det_insert_node(!.G, NInfo, N, !:G) :-
- ( graph.insert_node(!.G, NInfo, NPrime, !:G) ->
- N = NPrime
- ;
- error("graph.det_insert_node: node already exists.")
- ).
-
-graph.insert_node(!.G, NInfo, node(N), !:G) :-
- % Make sure that the graph doesn't contain NInfo already.
- \+ map.member(!.G ^ node_map, _, NInfo),
-
- NS0 = !.G ^ node_supply,
- counter.allocate(N, NS0, NS),
- !G ^ node_supply := NS,
-
- Nodes0 = !.G ^ node_map,
- map.set(node(N), NInfo, Nodes0, Nodes),
- !G ^ node_map := Nodes,
-
- Edges0 = !.G ^ edge_map,
- map.init(EdgeSet),
- map.set(node(N), EdgeSet, Edges0, Edges),
- !G ^ edge_map := Edges.
-
-%------------------------------------------------------------------------------%
-
-graph.search_node(Graph, NodeInfo, Node) :-
- NodeTable = Graph ^ node_map,
- map.member(NodeTable, Node, NodeInfo).
-
-%------------------------------------------------------------------------------%
-
-graph.find_matching_nodes(Graph, NodeInfo, NodeSet) :-
- NodeTable = Graph ^ node_map,
-% SolnGoal = lambda([Node::out] is nondet,
-% map.member(NodeTable, Node, NodeInfo)),
-% solutions(SolnGoal, NodeList),
- solutions(graph.select_node(NodeTable, NodeInfo), NodeList),
- set.sorted_list_to_set(NodeList, NodeSet).
-
-:- pred graph.select_node(map(node(N), N)::in, N::in, node(N)::out) is nondet.
-
-graph.select_node(NodeTable, NodeInfo, Node) :-
- map.member(NodeTable, Node, NodeInfo).
-
-%------------------------------------------------------------------------------%
-
-graph.node_contents(G, N, I) :-
- map.lookup(G ^ node_map, N, I).
-
-%------------------------------------------------------------------------------%
-
-graph.successors(G, N, Ss) :-
- map.lookup(G ^ edge_map, N, E),
- map.values(E, SsList),
- set.list_to_set(SsList, Ss).
-
-%------------------------------------------------------------------------------%
-
-graph.nodes(G, Ns) :-
- map.keys(G ^ node_map, Ns1),
- set.list_to_set(Ns1, Ns).
-
-%------------------------------------------------------------------------------%
-
-graph.set_edge(!.G, Start, End, Info, Arc, !:G) :-
- AS0 = !.G ^ arc_supply,
- counter.allocate(A, AS0, AS),
- Arc = arc(A),
- !G ^ arc_supply := AS,
-
- Arcs0 = !.G ^ arc_map,
- map.set(Arc, arc_info(Start, End, Info), Arcs0, Arcs),
- !G ^ arc_map := Arcs,
-
- Es0 = !.G ^ edge_map,
- map.lookup(Es0, Start, EdgeMap0),
- map.set(Arc, End, EdgeMap0, EdgeMap),
- map.set(Start, EdgeMap, Es0, Es),
- !G ^ edge_map := Es.
-
-%------------------------------------------------------------------------------%
-
-graph.det_insert_edge(!.G, Start, End, Info, Arc, !:G) :-
- ( graph.insert_edge(!.G, Start, End, Info, ArcPrime, !:G) ->
- Arc = ArcPrime
- ;
- error("graph.det_insert_edge: this edge is already in the graph.")
- ).
-
-graph.insert_edge(!.G, Start, End, Info, Arc, !:G) :-
- AS0 = !.G ^ arc_supply,
- counter.allocate(A, AS0, AS),
- Arc = arc(A),
- !G ^ arc_supply := AS,
-
- Arcs0 = !.G ^ arc_map,
- map.insert(Arc, arc_info(Start, End, Info), Arcs0, Arcs),
- !G ^ arc_map := Arcs,
-
- Es0 = !.G ^ edge_map,
- map.lookup(Es0, Start, EdgeMap0),
- map.set(Arc, End, EdgeMap0, EdgeMap),
- map.set(Start, EdgeMap, Es0, Es),
- !G ^ edge_map := Es.
-
-%------------------------------------------------------------------------------%
-
-graph.arc_contents(G, N, S, E, A) :-
- map.lookup(G ^ arc_map, N, I),
- I = arc_info(S, E, A).
-
-%------------------------------------------------------------------------------%
-
-graph.path(G, S, E, Path) :-
- graph.path_2(G, S, E, [], Path).
-
-:- pred graph.path_2(graph(N, A), node(N), node(N),
- list(node(N)), list(arc(A))).
-:- mode graph.path_2(in, in, in, in, out) is nondet.
-:- mode graph.path_2(in, in, out, in, out) is nondet.
-
-graph.path_2(G, S, E, Nodes0, Path) :-
- Es = G ^ edge_map,
- map.lookup(Es, S, Arcs),
- (
- map.member(Arcs, A, E),
- \+ list.member(E, Nodes0),
- Path = [A]
- ;
- map.member(Arcs, A, N),
- \+ list.member(N, Nodes0),
- graph.path_2(G, N, E, [N | Nodes0], Path0),
- Path = [A | Path0]
- ).
-
-%-----------------------------------------------------------------------------%
-%-----------------------------------------------------------------------------%
-% Ralph Becket <rwab1 at cl.cam.ac.uk> 29/04/99
-% Functional forms added.
-
-graph.init = G :-
- graph.init(G).
-
-graph.find_matching_nodes(G, N) = S :-
- graph.find_matching_nodes(G, N, S).
-
-graph.node_contents(G, N) = NI :-
- graph.node_contents(G, N, NI).
-
-graph.successors(G, N) = S :-
- graph.successors(G, N, S).
-
-graph.nodes(G) = S :-
- graph.nodes(G,S).
Index: library/group.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/library/group.m,v
retrieving revision 1.31
diff -u -r1.31 group.m
--- library/group.m 3 May 2011 04:35:01 -0000 1.31
+++ library/group.m 6 May 2011 15:22:06 -0000
@@ -1,233 +1,3 @@
-%-----------------------------------------------------------------------------%
-% vim: ft=mercury ts=4 sw=4 et wm=0 tw=0
-%-----------------------------------------------------------------------------%
-% Copyright (C) 1994-1997, 1999, 2003, 2005-2007, 2010-2011 The University of Melbourne.
-% This file may only be copied under the terms of the GNU Library General
-% Public License - see the file COPYING.LIB in the Mercury distribution.
-%-----------------------------------------------------------------------------%
-%
-% File: group.m.
-% Main author: conway.
-% Stability: low (obsolete).
-%
-% This module is probably not terribly useful, and it may not be supported
-% in future releases.
-%
-% The `group' module provides a facility for handling a partitioned set.
-% A group is a set of sets of elements, where each element is unique within
-% the scope of the group. The module provides moderately efficient ways for
-% manipulating groups and elements.
-%
-%-----------------------------------------------------------------------------%
-%-----------------------------------------------------------------------------%
-
-:- module group.
-:- interface.
-
-:- import_module assoc_list.
-:- import_module list.
-:- import_module set.
-
-%-----------------------------------------------------------------------------%
-
-:- type group(T).
-
-:- type group.key.
-
- % Create an empty group.
- %
-:- pred group.init(group(T)::out) is det.
-:- func group.init = group(T).
-
- % Insert a set of elements into the group.
- %
-:- pred group.insert(group(T)::in, set(T)::in, group(T)::out) is det.
-:- func group.insert(group(T), set(T)) = group(T).
-
- % Given an element, get the set containing that element.
- %
-:- pred group.group(group(T)::in, T::in, set(T)::out) is det.
-:- func group.group(group(T), T) = set(T).
-
- % Convert the group to a set of sets.
- %
-:- pred group.to_set(group(T)::in, set(set(T))::out) is det.
-:- func group.to_set(group(T)) = set(set(T)).
-
-:- pred group.sets_and_keys(group(T)::in,
- assoc_list(set(T), group.key)::out) is det.
-:- func group.sets_and_keys(group(T)) = assoc_list(set(T), group.key).
-
- % Given an element, get the key for the group containing that element.
- %
-:- pred group.group_key(group(T)::in, T::in, group.key::out) is det.
-:- func group.group_key(group(T), T) = group.key.
-
- % Given a group key, get the corresponding set of elements.
- %
-:- pred group.key_group(group(T)::in, group.key::in, set(T)::out) is det.
-:- func group.key_group(group(T), group.key) = set(T).
-
- % Remove a set from the group, and return the set.
- %
-:- pred group.remove_group(group(T)::in, group.key::in, set(T)::out,
- group(T)::out) is det.
-
- % Test to see if two elements are in the same set.
- %
-:- pred group.same_group(group(T)::in, T::in, T::in) is semidet.
-
-:- pred group.largest_group_key(group(T)::in, group.key::out) is det.
-:- func group.largest_group_key(group(T)) = group.key.
-
-:- pred group.group_keys(group(T)::in, list(group.key)::out) is det.
-:- func group.group_keys(group(T)) = list(group.key).
-
%---------------------------------------------------------------------------%
+% THIS FILE IS NO LONGER USED.
%---------------------------------------------------------------------------%
-
-:- implementation.
-
-:- import_module counter.
-:- import_module map.
-:- import_module pair.
-:- import_module require.
-
-:- type group(T)
- ---> group(
- key_supply :: counter,
- sets :: map(group.key, set(T)),
- elements :: map(T, group.key)
- ).
-
-:- type group.key == int.
-
-group.init(G) :-
- map.init(Es),
- map.init(Ss),
- G = group(counter.init(0), Es, Ss).
-
-group.insert(!.G, S, !:G) :-
- !.G = group(KS0, Ss0, Es0),
- counter.allocate(C, KS0, KS),
- map.set(C, S, Ss0, Ss),
- set.to_sorted_list(S, SL),
- group.insert_elements(SL, C, Es0, Es),
- !:G = group(KS, Ss, Es).
-
-:- pred group.insert_elements(list(T)::in, group.key::in,
- map(T, group.key)::in, map(T, group.key)::out) is det.
-
-group.insert_elements([], _GK, !Es).
-group.insert_elements([I | Is], GK, !Es) :-
- map.set(I, GK, !Es),
- group.insert_elements(Is, GK, !Es).
-
-group.group(G, E, S) :-
- map.lookup(G ^ elements, E, GK),
- map.lookup(G ^ sets, GK, S).
-
-group.to_set(G, S) :-
- map.values(G ^ sets, S0),
- set.list_to_set(S0, S).
-
-group.sets_and_keys(G, SKs) :-
- map.to_assoc_list(G ^ sets, SKs0),
- assoc_list.reverse_members(SKs0, SKs).
-
-group.group_key(G, E, GK) :-
- map.lookup(G ^ elements, E, GK).
-
-group.key_group(G, GK, S) :-
- map.lookup(G ^ sets, GK, S).
-
-group.remove_group(!.G, GK, S, !:G) :-
- Ss0 = !.G ^ sets,
- Es0 = !.G ^ elements,
- ( map.remove(GK, SPrime, Ss0, SsPrime) ->
- S = SPrime,
- Ss = SsPrime
- ;
- error("map.remove unexpectedly failed.")
- ),
- set.to_sorted_list(S, SL),
- group.remove_elements(SL, Es0, Es),
- !G ^ sets := Ss,
- !G ^ elements := Es.
-
-:- pred group.remove_elements(list(T)::in,
- map(T, group.key)::in, map(T, group.key)::out) is det.
-
-group.remove_elements([], !Es).
-group.remove_elements([I | Is], !Es) :-
- map.delete(I, !Es),
- group.remove_elements(Is, !Es).
-
-group.same_group(G, E0, E1) :-
- Es = G ^ elements,
- map.lookup(Es, E0, GK),
- map.lookup(Es, E1, GK).
-
-group.largest_group_key(G, GK) :-
- Ss = G ^ sets,
- map.to_assoc_list(Ss, SL),
- group.largest_group_key_2(SL, 0, 0, GK).
-
-:- pred group.largest_group_key_2(assoc_list(group.key, set(T))::in, int::in,
- group.key::in, group.key::out) is det.
-
-group.largest_group_key_2([], _, GK, GK).
-group.largest_group_key_2([GK0 - S0 | Ss], Sz0, GK1, GK) :-
- set.to_sorted_list(S0, S1),
- list.length(S1, Sz1),
- compare(R, Sz1, Sz0),
- (
- R = (>),
- Sz = Sz1,
- GK2 = GK0
- ;
- ( R = (=)
- ; R = (<)
- ),
- Sz = Sz0,
- GK2 = GK1
- ),
- group.largest_group_key_2(Ss, Sz, GK2, GK).
-
-%---------------------------------------------------------------------------%
-
-group.group_keys(G, Ks) :-
- map.keys(G ^ sets, Ks).
-
-%---------------------------------------------------------------------------%
-%---------------------------------------------------------------------------%
-% Ralph Becket <rwab1 at cl.cam.ac.uk> 29/04/99
-% Function forms added.
-
-group.init = G :-
- group.init(G).
-
-group.insert(G1, S) = G2 :-
- group.insert(G1, S, G2).
-
-group.group(G, T) = S :-
- group.group(G, T, S).
-
-group.to_set(G) = SS :-
- group.to_set(G, SS).
-
-group.sets_and_keys(G) = AL :-
- group.sets_and_keys(G, AL).
-
-group.group_key(G, T) = K :-
- group.group_key(G, T, K).
-
-group.key_group(G, K) = S :-
- group.key_group(G, K, S).
-
-group.largest_group_key(G) = K :-
- group.largest_group_key(G, K).
-
-group.group_keys(G) = Ks :-
- group.group_keys(G, Ks).
-
Index: library/library.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/library/library.m,v
retrieving revision 1.128
diff -u -r1.128 library.m
--- library/library.m 28 Apr 2011 13:52:54 -0000 1.128
+++ library/library.m 6 May 2011 15:22:56 -0000
@@ -72,8 +72,6 @@
:- import_module gc.
:- import_module getopt.
:- import_module getopt_io.
-:- import_module graph.
-:- import_module group.
:- import_module hash_table.
:- import_module injection.
:- import_module int.
@@ -243,8 +241,6 @@
mercury_std_library_module("gc").
mercury_std_library_module("getopt").
mercury_std_library_module("getopt_io").
-mercury_std_library_module("graph").
-mercury_std_library_module("group").
mercury_std_library_module("hash_table").
mercury_std_library_module("injection").
mercury_std_library_module("int").
Index: tests/invalid/missing_interface_import2.err_exp
===================================================================
RCS file: /home/mercury/mercury1/repository/tests/invalid/missing_interface_import2.err_exp,v
retrieving revision 1.4
diff -u -r1.4 missing_interface_import2.err_exp
--- tests/invalid/missing_interface_import2.err_exp 10 Sep 2006 23:39:16 -0000 1.4
+++ tests/invalid/missing_interface_import2.err_exp 9 May 2011 16:29:46 -0000
@@ -1,7 +1,7 @@
missing_interface_import2.m:009: In definition of predicate
missing_interface_import2.m:009: `missing_interface_import2.write_key'/3:
-missing_interface_import2.m:009: error: undefined type `key'/0.
-missing_interface_import2.m:009: (The modules `group' and
+missing_interface_import2.m:009: error: undefined type `partition_id'/0.
+missing_interface_import2.m:009: (The modules `eqvclass' and
missing_interface_import2.m:009: `missing_interface_import3' have not been
missing_interface_import2.m:009: imported in the interface.)
missing_interface_import2.m:009: In definition of predicate
Index: tests/invalid/missing_interface_import2.m
===================================================================
RCS file: /home/mercury/mercury1/repository/tests/invalid/missing_interface_import2.m,v
retrieving revision 1.1
diff -u -r1.1 missing_interface_import2.m
--- tests/invalid/missing_interface_import2.m 1 Dec 2003 15:56:11 -0000 1.1
+++ tests/invalid/missing_interface_import2.m 9 May 2011 16:28:47 -0000
@@ -1,12 +1,12 @@
:- module missing_interface_import2.
:- import_module io.
-:- import_module group.
+:- import_module eqvclass.
:- import_module missing_interface_import3.
:- interface.
-:- pred write_key(key::in, io__state::di, io__state::uo) is det.
+:- pred write_key(partition_id::in, io__state::di, io__state::uo) is det.
:- implementation.
Index: tests/invalid/missing_interface_import3.m
===================================================================
RCS file: /home/mercury/mercury1/repository/tests/invalid/missing_interface_import3.m,v
retrieving revision 1.1
diff -u -r1.1 missing_interface_import3.m
--- tests/invalid/missing_interface_import3.m 1 Dec 2003 15:56:11 -0000 1.1
+++ tests/invalid/missing_interface_import3.m 9 May 2011 16:29:00 -0000
@@ -1,4 +1,4 @@
:- module missing_interface_import3.
:- interface.
-:- type key == int.
+:- type partition_id == int.
--------------------------------------------------------------------------
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