product/arithmetic each: missing block nil.

* stdlib/arith-each.tl (sys:vars-check): New function, copy
and pasted from each-prod.tl.
(sys:arith-each): New macro.
(sum-each, sum-each*, mul-each, mul-each*): Reworked using
sys:arith-each macro.  This macro uses logic borrowed from
a stripped-down expand-each in the compiler.

* stdlib/each-prod.tl (sys:expand-each-prod,
sys:expand-arith-each-prod*): Add the block nil around the
mapping call, taking care that the initialization forms
are evaluated outside of the block, and their values bound to
gensyms that then form the function arguments.

* txr.1: Document the missing requirements for all the
affected macros that there must be an anonymous block around
the body, which, if used, determines the return value.

1 files changed, 38 insertions, 31 deletions

diff --git a/txr.1 b/txr.1
index f2af420d..f7c9ae8c 100644
--- a/txr.1
+++ b/txr.1
@@ -17714,21 +17714,11 @@ the variable bindings, exactly the way
 alters the semantics of
 .codn each .
 
-Note: the following equivalences apply, except that the accumulator
-variable is a named by a unique, generated symbol.
-
-.verb
-  (sum-each (vars ...)  <-->  (let ((acc 0))
-    body ...)                   (each vars
-                                  (inc acc (progn body)))
-                                 acc)
-
-  (mul-each (vars ...)  <-->  (let ((acc 1))
-    body)                       (each vars
-                                  (set acc (* acc
-                                              (progn body))))
-                                acc)
-.brev
+The
+.metn body-form s
+are enclosed in an implicit anonymous block. If the forms terminate
+by returning from the anonymous block then these macros terminate
+with the specified value.
 
 .coNP Macros @, each-prod @ collect-each-prod and @ append-each-prod
 .synb
@@ -17758,24 +17748,36 @@ is analogous to that between the functions
 and
 .codn maprod .
 
-These macros can be understood as providing syntactic sugar according to the
-pattern established by the following equivalences:
+Like in the
+.code each
+operator family, the
+.metn body-form s
+are surrounded by an anonymous block. If these forms execute a return from
+this block, then these macros terminate with the specified return value.
+
+With one caveat noted below, these macros can be understood as providing
+syntactic sugar according to the pattern established by the following
+equivalences:
 
 .mono
-  (each-prod               (maprodo (lambda (x y)
-    ((x xinit)                        body)
-     (y yinit))       <-->          xinit
-    body)                           yinit)
-
-  (collect-each-prod       (maprod (lambda (x y)
-    ((x xinit)                       body)
-     (y yinit))       <-->         xinit
-    body)                          yinit)
-
-  (append-each-prod        (maprend (lambda (x y)
-    ((x xinit)                        body)
-     (y yinit))       <-->          xinit
-    body)                           yinit)
+  (each-prod               (block nil
+    ((x xinit)               (let ((#:gx xinit) (#:gy yinit))
+     (y yinit))       <-->     (maprodo (lambda (x y)
+    body)                                 body)
+                                        #:gx #:gy))
+
+  (collect-each-prod       (block nil
+    ((x xinit)               (let ((#:gx xinit) (#:gy yinit))
+     (y yinit))       <-->     (maprod (lambda (x y)
+    body)                                body)
+                                       #:gx #:gy))
+
+
+  (append-each-prod        (block nil
+    ((x xinit)               (let ((#:gx xinit) (#:gy yinit))
+     (y yinit))       <-->     (maprend (lambda (x y)
+    body)                                body)
+                                       #:gx #:gy))
 .onom
 
 However, note that each invocation of the
@@ -17880,6 +17882,11 @@ values of the variables, similarly to the
 .code each*
 operator.
 
+The
+.metn body-form s
+are surrounded by an implicit anonymous block. If these forms execute a return
+from this block, then these macros terminate with the specified return value.
+
 .TP* Examples:
 
 .verb