seq_build: seq_pend must be nondestructive for lists.

Let's have both a seq_pend and seq_nconc, where seq_nconc
can reuse the pieces of list passed to it.

* lib.h (struct seq_build_ops): New member, nconc.
(seq_build_ops_init): Add nconc parameter and initializer.
(seq_nconc): Function declared.

* lib.c (seq_build_list_pend): Switch to list_collect_append,
otherwise mappend behaves destructively.
(seq_build_list_nconc): New function.
(sb_vec_ops, sb_str_ops, sb_buf_ops, sb_struct_ops,
sb_carray_ops): Use seq_build_generic_pend for nconc
operation.
(sb_list_ops): Use new seq_build_list_nconc for nconc
operation.
(sb_finished_ops): Use null pointer for nconc operation.
(seq_nconc): New function.

1 files changed, 17 insertions, 1 deletions

diff --git a/lib.c b/lib.c
index c336bd7f..15d5a546 100644
--- a/lib.c
+++ b/lib.c
@@ -1480,6 +1480,11 @@ static void seq_build_list_add(seq_build_t *bu, val item)
 
 static void seq_build_list_pend(seq_build_t *bu, val items)
 {
+  bu->tail = list_collect_append(bu->tail, items);
+}
+
+static void seq_build_list_nconc(seq_build_t *bu, val items)
+{
   bu->tail = list_collect_nconc(bu->tail, items);
 }
 
@@ -1505,41 +1510,47 @@ static void seq_build_carray_finish(seq_build_t *bu)
 static struct seq_build_ops
   sb_vec_ops = seq_build_ops_init(seq_build_vec_add,
                                   seq_build_generic_pend,
+                                  seq_build_generic_pend,
                                   0,
                                   seq_build_obj_mark);
 
 static struct seq_build_ops
   sb_str_ops = seq_build_ops_init(seq_build_str_add,
                                   seq_build_generic_pend,
+                                  seq_build_generic_pend,
                                   seq_build_str_finish,
                                   seq_build_obj_mark);
 
 static struct seq_build_ops
   sb_buf_ops = seq_build_ops_init(seq_build_buf_add,
                                   seq_build_generic_pend,
+                                  seq_build_generic_pend,
                                   seq_build_buf_finish,
                                   seq_build_obj_mark);
 
 static struct seq_build_ops
   sb_struct_ops = seq_build_ops_init(seq_build_list_add,
                                      seq_build_generic_pend,
+                                     seq_build_generic_pend,
                                      seq_build_struct_finish,
                                      seq_build_struct_mark);
 
 static struct seq_build_ops
   sb_carray_ops = seq_build_ops_init(seq_build_list_add,
                                      seq_build_generic_pend,
+                                     seq_build_generic_pend,
                                      seq_build_carray_finish,
                                      seq_build_carray_mark);
 
 static struct seq_build_ops
   sb_list_ops = seq_build_ops_init(seq_build_list_add,
                                    seq_build_list_pend,
+                                   seq_build_list_nconc,
                                    seq_build_list_finish,
                                    seq_build_obj_mark);
 
 static struct seq_build_ops
-  sb_finished_ops = seq_build_ops_init(0, 0, 0, seq_build_obj_mark);
+  sb_finished_ops = seq_build_ops_init(0, 0, 0, 0, seq_build_obj_mark);
 
 static void seq_build_convert_to_list(seq_build_t *bu, val list)
 {
@@ -1624,6 +1635,11 @@ void seq_pend(seq_build_t *bu, val items)
   bu->ops->pend(bu, items);
 }
 
+void seq_nconc(seq_build_t *bu, val items)
+{
+  bu->ops->nconc(bu, items);
+}
+
 val seq_finish(seq_build_t *bu)
 {
   if (bu->ops->finish)