New syntax proposal

[Thomas Charles CONWAY]

Hi

The following diff proposes new syntax for higher-order pred expressions
with DCG syntax. Comments on the new syntax very welcome.

-- 
ZZ:wq!
^X^C
Thomas Conway               				      conway at cs.mu.oz.au
AD DEUM ET VINUM	  			      Every sword has two edges.


This change adds some new syntax for higher-order pred expressions
that use DCG notation. The newly accepted expressions have the form:

	Pred = (pred(Arg1::Mode1, ..., ArgN::ModeN, DCGMode0, DCGMode1) is Det
			--> Goal)

compiler/prog_io_goal.m:
	add a predicate for parsing dcg pred expressions.

compiler/prog_io_dcg.m:
	add an interface predicate for parsing dcg goals.

compiler/make_hlds.m:
	detect and expand higher-order dcg pred expressions.

doc/reference_manual.texi:
	mention the new syntax in the section on higher-order.

NEWS:
	mention the new syntax.

cvs diff: Diffing .
Index: NEWS
===================================================================
RCS file: /home/staff/zs/imp/mercury/NEWS,v
retrieving revision 1.77
diff -u -r1.77 NEWS
--- NEWS	1997/10/04 06:49:29	1.77
+++ NEWS	1997/10/06 05:56:41
@@ -102,3 +102,7 @@
   for providing the original version. 
 
 * We've added a new predicate to bag.m, bag__to_list/2.
+
+* We've introduced new syntax to allow higher-order predicate expressions
+  to use DCG notation.
+
cvs diff: Diffing bindist
cvs diff: Diffing boehm_gc
cvs diff: Diffing boehm_gc/Mac_files
cvs diff: Diffing boehm_gc/cord
cvs diff: Diffing boehm_gc/cord/private
cvs diff: Diffing boehm_gc/include
cvs diff: Diffing boehm_gc/include/private
cvs diff: Diffing bytecode
cvs diff: Diffing bytecode/test
cvs diff: Diffing compiler
Index: compiler/make_hlds.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/make_hlds.m,v
retrieving revision 1.240
diff -u -r1.240 make_hlds.m
--- make_hlds.m	1997/09/30 14:54:24	1.240
+++ make_hlds.m	1997/10/06 02:01:53
@@ -56,8 +56,8 @@
 
 :- implementation.
 
-:- import_module prog_io, prog_io_goal, prog_io_util, prog_out, hlds_out.
-:- import_module module_qual, prog_util, globals, options.
+:- import_module prog_io, prog_io_goal, prog_io_dcg, prog_io_util, prog_out.
+:- import_module module_qual, prog_util, globals, options, hlds_out.
 :- import_module make_tags, quantification, (inst).
 :- import_module code_util, unify_proc, special_pred, type_util, mode_util.
 :- import_module mercury_to_mercury, passes_aux, clause_to_proc, inst_match.
@@ -2803,6 +2803,34 @@
 			HLDS_Goal0, VarSet3, HLDS_Goal, VarSet, Info2, Info),
 		{ create_atomic_unification(X,
 			lambda_goal(predicate, Vars, Modes, Det, HLDS_Goal),
+			Context, MainContext, SubContext, Goal) }
+	;
+	    {
+		% handle higher-order dcg pred expressions -
+		% same semantics as higher-order pred expressions,
+		% but has two extra arguments, and the goal is expanded
+		% as a DCG goal.
+		F = term__atom("-->"),
+		Args = [PredTerm, GoalTerm],
+		parse_dcg_pred_expression(PredTerm, Vars0, Modes0, Det)
+	    }
+	->
+		{ qual_info_get_mq_info(Info0, MQInfo0) },
+		module_qual__qualify_lambda_mode_list(Modes0, Modes, Context,
+			MQInfo0, MQInfo1),
+		{ qual_info_set_mq_info(Info0, MQInfo1, Info1) },
+		{ parse_dcg_pred_goal(GoalTerm, VarSet0, ParsedGoal,
+			DCG0, DCGn, VarSet1) },
+		{ make_fresh_arg_vars(Vars1, VarSet1, Vars, VarSet2) },
+		{ list__append(Vars0,
+			[term__variable(DCG0), term__variable(DCGn)], Vars1) },
+		{ map__init(Substitution) },
+		transform_goal(ParsedGoal, VarSet2, Substitution,
+			HLDS_Goal0, VarSet3, Info1, Info2),
+		insert_arg_unifications(Vars, Vars1, Context, head,
+			HLDS_Goal0, VarSet3, HLDS_Goal, VarSet, Info2, Info),
+		{ create_atomic_unification(X,
+		lambda_goal(predicate, Vars, Modes, Det, HLDS_Goal),
 			Context, MainContext, SubContext, Goal) }
 	;
 	    {
Index: compiler/prog_io_dcg.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/prog_io_dcg.m,v
retrieving revision 1.5
diff -u -r1.5 prog_io_dcg.m
--- prog_io_dcg.m	1997/07/27 15:01:27	1.5
+++ prog_io_dcg.m	1997/10/06 02:05:49
@@ -21,6 +21,9 @@
 			maybe_item_and_context).
 :- mode parse_dcg_clause(in, in, in, in, in, out) is det.
 
+:- pred parse_dcg_pred_goal(term, varset, goal, var, var, varset).
+:- mode parse_dcg_pred_goal(in, in, out, out, out, out) is det.
+
 :- implementation.
 
 :- import_module prog_io_goal, prog_util, prog_data.
@@ -37,6 +40,13 @@
 			HeadResult),
 	process_dcg_clause(HeadResult, VarSet, DCG_0_Var, DCG_Var, Body, R),
 	add_context(R, DCG_Context, Result).
+
+%-----------------------------------------------------------------------------%
+
+parse_dcg_pred_goal(GoalTerm, VarSet0, Goal, DCGVar0, DCGVar, VarSet) :-
+	new_dcg_var(VarSet0, 0, VarSet1, N0, DCGVar0),
+	parse_dcg_goal(GoalTerm, VarSet1, N0, DCGVar0,
+			Goal, VarSet, _N, DCGVar).
 
 %-----------------------------------------------------------------------------%
 
Index: compiler/prog_io_goal.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/prog_io_goal.m,v
retrieving revision 1.5
diff -u -r1.5 prog_io_goal.m
--- prog_io_goal.m	1997/07/27 15:01:28	1.5
+++ prog_io_goal.m	1997/10/06 06:57:53
@@ -49,6 +49,17 @@
 :- pred parse_pred_expression(term, list(term), list(mode), determinism).
 :- mode parse_pred_expression(in, out, out, out) is semidet.
 
+	% parse_dcg_pred_expression/3 converts the first argument to a -->/2
+	% higher-order dcg pred expression into a list of variables, a list
+	% of their corresponding modes and the two dcg argument modes, and a
+	% determinism.
+	% This is a variant of the higher-order pred syntax:
+	%	`(pred(Var1::Mode1, ..., VarN::ModeN, DCG0Mode, DCGMode)
+	%		is Det --> Goal)'.
+	%
+:- pred parse_dcg_pred_expression(term, list(term), list(mode), determinism).
+:- mode parse_dcg_pred_expression(in, out, out, out) is semidet.
+
 	% parse_func_expression/3 converts the first argument to a :-/2
 	% higher-order func expression into a list of variables, a list
 	% of their corresponding modes, and a determinism.  The syntax
@@ -276,6 +287,13 @@
 	PredArgsTerm = term__functor(term__atom("pred"), PredArgsList, _),
 	parse_pred_expr_args(PredArgsList, Vars, Modes).
 
+parse_dcg_pred_expression(PredTerm, Vars, Modes, Det) :-
+	PredTerm = term__functor(term__atom("is"), [PredArgsTerm, DetTerm], _),
+	DetTerm = term__functor(term__atom(DetString), [], _),
+	standard_det(DetString, Det),
+	PredArgsTerm = term__functor(term__atom("pred"), PredArgsList, _),
+	parse_dcg_pred_expr_args(PredArgsList, Vars, Modes).
+
 parse_func_expression(FuncTerm, Vars, Modes, Det) :-
 	%
 	% parse a func expression with specified modes and determinism
@@ -316,6 +334,21 @@
 parse_pred_expr_args([Term|Terms], [Arg|Args], [Mode|Modes]) :-
 	parse_lambda_arg(Term, Arg, Mode),
 	parse_pred_expr_args(Terms, Args, Modes).
+
+	% parse_dcg_pred_expr_args is like parse_pred_expr_args except
+	% that the last two elements of the list are the modes of the
+	% two dcg arguments.
+:- pred parse_dcg_pred_expr_args(list(term), list(term), list(mode)).
+:- mode parse_dcg_pred_expr_args(in, out, out) is semidet.
+
+parse_dcg_pred_expr_args([DCGModeTerm0, DCGModeTerm1], [],
+		[DCGMode0, DCGMode1]) :-
+	convert_mode(DCGModeTerm0, DCGMode0),
+	convert_mode(DCGModeTerm1, DCGMode1).
+parse_dcg_pred_expr_args([Term|Terms], [Arg|Args], [Mode|Modes]) :-
+	Terms = [_, _|_],
+	parse_lambda_arg(Term, Arg, Mode),
+	parse_dcg_pred_expr_args(Terms, Args, Modes).
 
 %-----------------------------------------------------------------------------%
 
cvs diff: Diffing compiler/notes
cvs diff: Diffing doc
Index: doc/reference_manual.texi
===================================================================
RCS file: /home/staff/zs/imp/mercury/doc/reference_manual.texi,v
retrieving revision 1.73
diff -u -r1.73 reference_manual.texi
--- reference_manual.texi	1997/09/27 19:53:41	1.73
+++ reference_manual.texi	1997/10/06 06:04:02
@@ -2137,6 +2137,31 @@
 binds @samp{Double} to a higher-order function term of type
 @samp{func(list(int)) = list(int)}.
 
+For higher-order predicate expressions that thread an accumulator
+pair, we have syntax that allows you to use DCG notation in the
+goal of the expression:
+
+ at example
+Pred = (pred(Strings::in, Num::out, di, uo) is det -->
+    io__write_string("The strings are: "),
+    { list__length(Strings, Num) },
+    io__write_strings(Strings),
+    io__nl
+)
+ at end example
+
+ at noindent
+which is equivalent to
+
+ at example
+Pred = (pred(Strings::in, Num::out, IO0::di, IO::uo) is det -->
+    io__write_string("The strings are: ", IO0, IO1),
+    list__length(Strings, Num),
+    io__write_strings(Strings, IO1, IO2),
+    io__nl(IO2, IO)
+)
+ at end example
+
 Higher-order function terms of zero arity can only be created using
 an explicit lambda expression; you have to use e.g. @samp{(func) = foo}
 rather than plain @samp{foo}, because the latter denotes the result