naming: partial_list_ws//1 --> list_ws//1

A DCG describes a list, so "list" is an appropriate name.

diff --git a/src/prolog/examples/bimetatrans_ruleml.pl b/src/prolog/examples/bimetatrans_ruleml.pl
index 142d9d1e33849d2e71d388f35e943fe54a013098..9a325fdebd833e2e7dc17f791f40b0e08a9d02f8 100644 (file)
--- a/src/prolog/examples/bimetatrans_ruleml.pl
+++ b/src/prolog/examples/bimetatrans_ruleml.pl
@@ -65,8 +65,8 @@ parse_ruleml(AssertItem, QueryItem, XML) :-
  */
 
 parse_header -->
-    partial_string_ws("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"),
-    partial_string_ws("<?xml-model href=\"http://deliberation.ruleml.org\
+    list_ws("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"),
+    list_ws("<?xml-model href=\"http://deliberation.ruleml.org\
 /1.02/xsd/naffologeq.xsd\"?>").
 
 
@@ -176,10 +176,10 @@ ruleml_top_level_items(AssertItem, QueryItems) -->
 
 ruleml_assert(Items) -->
     (  { var(Items) } ->
-       partial_string_ws("<Assert mapClosure=\"universal\">"),
+       list_ws("<Assert mapClosure=\"universal\">"),
        ruleml_assert_items(Items),
        !,
-       partial_string_ws("</Assert>")
+       list_ws("</Assert>")
     ;  partial_string("<Assert mapClosure=\"universal\">"),
        { Items \== [] },
        ruleml_assert_items(Items),
@@ -244,13 +244,13 @@ ruleml_query_items([]) --> [].
 
 ruleml_query_item(Item) -->
     (  { var(Item) } ->
-       partial_string_ws("<Query closure=\"existential\">"),
+       list_ws("<Query closure=\"existential\">"),
        (  ruleml_condition(Item0),
           { Item = (?- Item0) } ->
           { true }
        ;  { true }
        ),
-       partial_string_ws("</Query>")
+       list_ws("</Query>")
     ;  partial_string("<Query closure=\"existential\">"),
        { Item = (?- Item0) },
        ruleml_condition(Item0),
@@ -264,7 +264,7 @@ ruleml_query_item(Item) -->
  * items. Whitespace, for example, is discarded immediately after
  * being read.
  *
- * partial_string_ws reads a string into its argument as a partial
+ * list_ws reads a string into its argument as a partial
  * string before consuming any following whitespace.
  */
 
@@ -283,7 +283,7 @@ sign('+') --> "+".
 
 double_quote('"') --> "\"".
 
-partial_string_ws(String) -->
+list_ws(String) -->
     partial_string(String),
     ws.
 
@@ -370,7 +370,7 @@ ruleml_item_conjunction([]) --> [].
 
 ruleml_conjunction_of_items(Items) -->
     (  { var(Items) } ->
-       partial_string_ws("<And>"),
+       list_ws("<And>"),
        ruleml_item_conjunction(ItemsList),
        (  { ItemsList = [_,_|_] } ->
           { fold_commas(ItemsList, Items) }
@@ -379,7 +379,7 @@ ruleml_conjunction_of_items(Items) -->
        ;  { ItemsList = [] } ->
           { Items = (true, true) }
        ),
-       partial_string_ws("</And>")
+       list_ws("</And>")
     ;  partial_string("<And>"),
        (  { Items = (true, true) } ->
           { true }
@@ -417,7 +417,7 @@ ruleml_item_disjunction([]) --> [].
 
 ruleml_disjunction_of_items(Items) -->
     (  { var(Items) } ->
-       partial_string_ws("<Or>"),
+       list_ws("<Or>"),
        ruleml_item_disjunction(ItemsList),
        (  { ItemsList = [_,_|_] } ->
           { fold_semicolons(ItemsList, Items) }
@@ -426,7 +426,7 @@ ruleml_disjunction_of_items(Items) -->
        ;  { ItemsList = [] } ->
           { Items = (false ; false) }
        ),
-       partial_string_ws("</Or>")
+       list_ws("</Or>")
     ;  partial_string("<Or>"),
        (  { Items = (false ; false) } ->
           { true }
@@ -485,16 +485,16 @@ split_plex(Xs, PlexItems, RepoItem) :-
 
 ruleml_plex(Plex) -->
     (  { var(Plex) } ->
-       (  partial_string_ws("<Plex>") ->
+       (  list_ws("<Plex>") ->
           ruleml_items(PlexItems),
-          (  partial_string_ws("<repo>") ->
+          (  list_ws("<repo>") ->
              ruleml_var(RepoVar),
-             partial_string_ws("</repo>"),
+             list_ws("</repo>"),
              { append(PlexItems, RepoVar, Plex) }
           ;  { Plex = PlexItems }
           ),
-          partial_string_ws("</Plex>")
-       ;  partial_string_ws("<Plex/>")
+          list_ws("</Plex>")
+       ;  list_ws("<Plex/>")
        )
     ;  {  \+ string(Plex),
           acyclic_term(Plex) },
@@ -526,10 +526,10 @@ ruleml_plex(Plex) -->
 
 ruleml_naf(Item) -->
     (  { var(Item) } ->
-       partial_string_ws("<Naf>"),
+       list_ws("<Naf>"),
        ruleml_condition(NafItem),
        { Item = (\+ NafItem) },
-       partial_string_ws("</Naf>")
+       list_ws("</Naf>")
     ;  partial_string("<Naf>"),
        { Item = (\+ NafItem) },
        ruleml_condition(NafItem),
@@ -577,13 +577,13 @@ ruleml_atoms([]) --> [].
 
 ruleml_atom(Item) -->
     (  { var(Item) } ->
-       partial_string_ws("<Atom>"),
-       partial_string_ws("<Rel>"),
+       list_ws("<Atom>"),
+       list_ws("<Rel>"),
        prolog_symbol(Name),
        { Name \== (','), Name \== (';') },
-       partial_string_ws("</Rel>"),
+       list_ws("</Rel>"),
        ruleml_items(Args),
-       partial_string_ws("</Atom>"),
+       list_ws("</Atom>"),
        { Item =.. [Name | Args] }
     ;  { Item =.. [Name | Args] },
        { Name \== (','), Name \== (';') },
@@ -642,20 +642,20 @@ ruleml_item(Item) -->
 
 ruleml_expr(Item) -->
     (  { var(Item) } ->
-       partial_string_ws("<Expr>"),
-       partial_string_ws("<Fun>"),
+       list_ws("<Expr>"),
+       list_ws("<Fun>"),
        prolog_symbol(Name),
-       partial_string_ws("</Fun>"),
+       list_ws("</Fun>"),
        ruleml_items(Args),
-       (  partial_string_ws("<repo>"),
+       (  list_ws("<repo>"),
           ruleml_item(RepoItem),
-          partial_string_ws("</repo>"),
+          list_ws("</repo>"),
           !,
           { fold_commas(Args, ArgsCommas) },
           { Item =.. [Name, (ArgsCommas | RepoItem)] }
        ;  { Item =.. [Name | Args] }
        ),
-       partial_string_ws("</Expr>")
+       list_ws("</Expr>")
     ;  { Item =.. [Name | Args] },
        partial_string("<Expr>"),
        partial_string("<Fun>"),
@@ -686,9 +686,9 @@ ruleml_expr(Item) -->
 
 ruleml_ind(Name) -->
     (  { var(Name) } ->
-       partial_string_ws("<Ind>"),
+       list_ws("<Ind>"),
        ruleml_ind_helper(Cs),
-       partial_string_ws("</Ind>"),
+       list_ws("</Ind>"),
        { atom_chars(Name, Cs) }
     ;  { atom(Name) },
        partial_string("<Ind>"),
@@ -728,11 +728,11 @@ ruleml_ind_helper(Cs) -->
 
 ruleml_var(Var) -->
     (  { var(Var) } ->
-       partial_string_ws("<Var>"),
+       list_ws("<Var>"),
        ruleml_var_contents(VarChars),
        { atom_chars(VarName, VarChars) },
        { Var = '$V'(VarName) },
-       partial_string_ws("</Var>")
+       list_ws("</Var>")
     ;  { Var = '$V'(VarName) },
        partial_string("<Var>"),
        { atom_chars(VarName, VarChars) },
@@ -801,12 +801,12 @@ constant_chars(symbol, Constant, Chars) :-
 
 ruleml_data(Name) -->
     (  { var(Name) } ->
-       partial_string_ws("<Data xsi:type=\""),
+       list_ws("<Data xsi:type=\""),
        prolog_symbol(Type),
-       partial_string_ws("\">"),
+       list_ws("\">"),
        ruleml_data_contents(Type, Cs),
        { constant_chars(Type, Name, Cs) },
-       partial_string_ws("</Data>")
+       list_ws("</Data>")
     ;  partial_string("<Data xsi:type=\""),
        { constant_chars(Type, Name, Cs) },
        prolog_symbol(Type),
@@ -1042,14 +1042,14 @@ ruleml_implies_head(Item) -->
 
 ruleml_implies(Rule) -->
     (  { var(Rule) } ->
-       partial_string_ws("<Implies>"),
-       partial_string_ws("<then>"),
+       list_ws("<Implies>"),
+       list_ws("<then>"),
        ruleml_implies_head(Head),
-       partial_string_ws("</then>"),
-       partial_string_ws("<if>"),
+       list_ws("</then>"),
+       list_ws("<if>"),
        ruleml_condition(Body),
-       partial_string_ws("</if>"),
-       partial_string_ws("</Implies>"),
+       list_ws("</if>"),
+       list_ws("</Implies>"),
        { Rule = ( Head :- Body ) }
     ;  { Rule = ( Head :- Body ) },
        partial_string("<Implies>"),
@@ -1082,10 +1082,10 @@ ruleml_equal_item(EqualItem) -->
 
 ruleml_equal(Equal) -->
     (  { var(Equal) } ->
-       partial_string_ws("<Equal>"),
+       list_ws("<Equal>"),
        ruleml_equal_item(Left),
        ruleml_equal_item(Right),
-       partial_string_ws("</Equal>"),
+       list_ws("</Equal>"),
        { Equal = (Left = Right) }
     ;  { Equal = (Left = Right) },
        partial_string("<Equal>"),