New :lists feature in @(collect)/@(coll).

This is for those situations when multiple lists are being
collected, and must all be bound even if empty. Yet, the
lists are independent rather than parallel, so the discipline
of :vars is too rigid.

* match.c (lists_k): New keyword symbol variable.
(h_coll, v_collect): Extract :lists argument as local variable
lists, validate that :lists is not used on @(repeat)/@(rep)
and implement logic.
(match_expand_keyword_args): Treat expansion of :lists
the same way as :vars.
(syms_init): Initialize lists_k.

* match.c (lists_k): Declared.

* txr.1: Documented.

3 files changed, 47 insertions, 6 deletions

diff --git a/match.c b/match.c
index a87c09e5..e137d8e3 100644
--- a/match.c
+++ b/match.c
@@ -62,7 +62,7 @@ val text_s, choose_s, gather_s, do_s, mdo_s, mod_s, modlast_s;
 val line_s, data_s, fuzz_s, load_s;
 val include_s, close_s, require_s, in_package_s;
 val longest_k, shortest_k, greedy_k;
-val vars_k, resolve_k;
+val vars_k, lists_k, resolve_k;
 val append_k, into_k, var_k, list_k, tlist_k, string_k, env_k, counter_k;
 val named_k, continue_k, finish_k, mandatory_k;
 
@@ -935,8 +935,9 @@ static val h_coll(match_line_ctx *c)
                                 c->bindings), zero);
   val counter_binding = if2(counter, cons(counter, nil));
   val bindings_with_counter = if2(counter, cons(counter_binding, nil));
-  val have_vars;
+  val have_vars, have_lists;
   val vars = getplist_f(args, vars_k, mkcloc(have_vars));
+  val lists = getplist_f(args, lists_k, mkcloc(have_lists));
   cnum cmax = if3(gap, c_num(gap), if3(max, c_num(max), 0));
   cnum cmin = if3(gap, c_num(gap), if3(min, c_num(min), 0));
   cnum mincounter = cmin, maxcounter = 0;
@@ -950,6 +951,9 @@ static val h_coll(match_line_ctx *c)
     if (have_vars)
       sem_error(elem, lit("~s: coll takes :vars, rep does not"),
                 op_sym, nao);
+    if (have_lists)
+      sem_error(elem, lit("~s: coll takes :lists, rep does not"),
+                op_sym, nao);
     have_vars = t;
   }
 
@@ -1113,6 +1117,13 @@ next_coll:
     }
   }
 
+  for (iter = lists; iter; iter = cdr(iter)) {
+    val sym = car(iter);
+    val exists = tx_lookup_var(sym, c->bindings);
+    if (!exists)
+      c->bindings = acons(sym, nil, c->bindings);
+  }
+
   return next_spec_k;
 }
 
@@ -3114,11 +3125,11 @@ val match_expand_keyword_args(val args)
     if (more &&
         (sym == maxgap_k || sym == mingap_k || sym == gap_k ||
          sym == times_k || sym == mintimes_k || sym == maxtimes_k ||
-         sym == lines_k || sym == vars_k ||
+         sym == lines_k || sym == vars_k || sym == lists_k ||
          sym == list_k || sym == string_k))
     {
       val form = car(next);
-      val form_ex = if3(sym == vars_k,
+      val form_ex = if3(sym == vars_k || sym == lists_k,
                         match_expand_vars(form),
                         expand(form, nil));
       ptail = list_collect(ptail, sym);
@@ -3234,8 +3245,9 @@ static val v_collect(match_files_ctx *c)
                                 c->bindings), zero);
   val counter_binding = if2(counter, cons(counter, nil));
   val bindings_with_counter = if2(counter, cons(counter_binding, nil));
-  val have_vars;
+  val have_vars, have_lists;
   volatile val vars = getplist_f(args, vars_k, mkcloc(have_vars));
+  val lists = getplist_f(args, lists_k, mkcloc(have_lists));
   cnum cmax = if3(gap, c_num(gap), if3(max, c_num(max), 0));
   cnum cmin = if3(gap, c_num(gap), if3(min, c_num(min), 0));
   cnum mincounter = cmin, maxcounter = 0;
@@ -3256,6 +3268,9 @@ static val v_collect(match_files_ctx *c)
     if (have_vars)
       sem_error(specline, lit("~s: collect takes :vars, repeat does not"),
                 op_sym, nao);
+    if (have_lists)
+      sem_error(specline, lit("~s: collect takes :lists, repeat does not"),
+                op_sym, nao);
     have_vars = t;
   }
 
@@ -3449,6 +3464,13 @@ next_collect:
     }
   }
 
+  for (iter = lists; iter; iter = cdr(iter)) {
+    val sym = car(iter);
+    val exists = tx_lookup_var(sym, c->bindings);
+    if (!exists)
+      c->bindings = acons(sym, nil, c->bindings);
+  }
+
   return next_spec_k;
 }
 
@@ -4738,6 +4760,7 @@ static void syms_init(void)
   shortest_k = intern(lit("shortest"), keyword_package);
   greedy_k = intern(lit("greedy"), keyword_package);
   vars_k = intern(lit("vars"), keyword_package);
+  lists_k = intern(lit("lists"), keyword_package);
   resolve_k = intern(lit("resolve"), keyword_package);
   append_k = intern(lit("append"), keyword_package);
   into_k = intern(lit("into"), keyword_package);
diff --git a/match.h b/match.h
index 35e7cd05..e0682ce3 100644
--- a/match.h
+++ b/match.h
@@ -27,7 +27,7 @@
 
 extern val text_s, choose_s, gather_s, do_s, mdo_s, require_s, in_package_s;
 extern val close_s, load_s, include_s, mod_s, modlast_s, line_s;
-extern val counter_k, vars_k, env_k, var_k, into_k, named_k;
+extern val counter_k, vars_k, lists_k, env_k, var_k, into_k, named_k;
 val match_expand_keyword_args(val elem);
 val match_expand_elem(val elem);
 val match_filter(val name, val arg, val other_args);
diff --git a/txr.1 b/txr.1
index 6f7e9f1f..d55a2839 100644
--- a/txr.1
+++ b/txr.1
@@ -5526,6 +5526,24 @@ The behavior of the
 keyword is specified in the following section, "Specifying variables in
 .codn collect \(dq.
 
+.meIP :lists <> ( variable *)
+The
+.code :lists
+keyword indicates a list of variables. After the
+.code collect
+terminates, each
+.meta variable
+in the list which does not have a binding is bound to the empty
+list symbol
+.codn nil .
+Unlike
+.code :vars
+the
+.code :lists
+mechanism doesn't assert that only the listed variables may emanate
+from the collect. It also doesn't assert that each iteration of the
+collect must bind each of those variables.
+
 .meIP :counter >> { variable | >> ( variable << starting-value )}
 The
 .code :counter