with-accumulators is better, bug fixed

There is a new 'by' option which allows a step with no optional
argument at all.

Author: tfeb

README.md

@@ -133,12 +133,13 @@ The simple form is `(accumulator operatior &optional initially)`.
 - `operator` is the operator corresponding to the accumulator: this denotes a function which can take either two or no arguments: it is called with no arguments to initialise the variable underlying the accumulator if there is no `initially` value (this is the only case it is called with no arguments), or with the current value of the accumulator and the thing to be accumulated when the local function is called to accumulate something.
 - `initially`, if given, is the initial value.  If it is not given the accumulator is initialised by calling the operator function with no arguments.
 
-The more general form is `(accumulator operator &key initially type returner)`.
+The more general form is `(accumulator operator &key initially type returner default by)`.
 
 - `accumulator`, `operator` and `initially` are the same as before.
 - `type` is a type specification which is used to declare the type of the underlying variable.
 - `returner` denotes a function of one argument which, if given, is called with the final value of the accumulator: its return value is used instead of the value of the accumulator.
 - `default`, if given, causes the accumulator function to have a single optional argument for which this expression provides the default value.
+- `by`, if given, means that the accumulator takes no arguments and steps the value by `by`.  `by` and `default` can't both be given.
 - There may be additional keyword arguments in future.
 
 An example: let's say you want to walk some cons tree counting symbols:
@@ -196,6 +197,16 @@ There is no single-accumulator special case: it didn't seem useful as you need t
 
 The accumulation operator and returner are *names* which denote functions, not functions: they can be either symbols or a lambda expressions, they can't be functions.  Specifically it needs to be the case that `(operator ...)` is a valid form.  That means that if you do want to use some function you'd need to provide an operator which was, for instance `(lambda (into val) (funcall f into val))`.
 
+Both `by` and `default` are forms which are evaluated at call time in the current lexical and dynamic environment (they're simply the defaults for arguments).  So this will return `3`:
+
+```lisp
+(let ((by 1))
+  (with-accumulators ((a + :by by))
+    (a)
+    (setf by 2)
+    (a)))
+```
+
 `with-accumulators` is very much newer than either of the other two macros, and may be more buggy.  It is certainly the case that new keywords may appear in accumulator specifications.
 
 `with-accumulators` can implement `collecting` or `with-collectors`:

VERSION

@@ -1 +1 @@
-8.6.0
+8.7.0

collecting.lisp

@@ -136,12 +136,14 @@ the argument to the accumulator function.  Its return value is the new
 value of the accumulator.
 
 The extensible specification is (name operator &key initially type
-returner).  In this case name, operator & initially mean exactly the
-same as previously, but type is a type specification for the variable
-which underlies the accumulator, and returner denotes a function of
-one argument, the final value of the accumulator, whose return value
-is used instead of the final value.  There may in future be additional
-keywords.
+returner default by).  In this case name, operator & initially mean
+exactly the same as previously, but type is a type specification for
+the variable which underlies the accumulator, and returner denotes a
+function of one argument, the final value of the accumulator, whose
+return value is used instead of the final value.  If default is given
+then the local function takes an optional argument whose default it
+is.  If by is given then it takes no arguments and this is the
+increment.  These two arguments are mutually exclusive.
 
 The local accumulator functions are declared inline, and return their
 argument.
@@ -164,56 +166,77 @@ values, possibly via the returner functions."
                                     (eql (first on) 'lambda)))
                      (error "the operator of accumulator ~S isn't a symbol or lambda"
                             a))
-                   `(name ,name on ,on init ,init)))
+                   `(name ,name on ,on init ,init arglist (it))))
                 (otherwise
                  (destructuring-bind (name on &key
                                            (initially `(,on))
-                                           (type nil)
-                                           (returner nil)
-                                           (default nil defaultp)) a
+                                           (type nil typep)
+                                           (returner nil returnerp)
+                                           (default nil defaultp)
+                                           (by nil byp)) a
                    (unless (symbolp name)
                      (error "the name of accumulator ~S isn't a symbol" a))
                    (unless (or (symbolp on)
                                (and (consp on)
                                     (eql (first on) 'lambda)))
                      (error "the operator of accumulator ~S~
 isn't a symbol or lambda expression" a))
-                   (unless (or (symbolp returner)
-                               (and (consp returner)
-                                    (eql (first returner) 'lambda)))
-                     (error "the return operator of accumulator ~S~
-isn't a symbol of lambda expression" a))
-                   `(name ,name on ,on init ,initially
-                          type ,type returner ,returner
-                          arglist ,(if defaultp `(&optional (it ,default)) '(it)))))))
+                   (when returnerp
+                     (unless (or (symbolp returner)
+                                 (and (consp returner)
+                                      (eql (first returner) 'lambda)))
+                       (error "the return operator of accumulator ~S~
+isn't a symbol of lambda expression" a)))
+                   (when (and defaultp byp)
+                     (error "default and by can't both be given in ~S" a))
+                   (let ((p `(name ,name on ,on init ,initially
+                                   arglist ,(cond
+                                             (byp `(&aux (it ,by)))
+                                             (defaultp `(&optional (it ,default)))
+                                             (t '(it))))))
+                     (when typep
+                       (setf (getf p 'type) type))
+                     (when returnerp
+                       (setf (getf p 'returner) returner))
+                     p)))))
              (t
               (error "hopeless accumulator ~S" a))))
-         (getter (property &optional (default nil))
-           (lambda (plist)
-             (getf plist property default))))
+         (getp (plist p)
+           (let* ((d (load-time-value (cons nil nil)))
+                  (v (getf plist p d)))
+                   (if (eq v d)
+                       (values nil nil)
+                     (values v t)))))
     (let* ((parsed (mapcar #'parse-accumulator accumulators))
-           (names (mapcar (getter 'name) parsed))
-           (inits (mapcar (getter 'init) parsed))
-           (types (mapcar (getter 'type) parsed))
-           (returners (mapcar (getter 'returner) parsed))
-           (arglists (mapcar (getter 'arglist) parsed))
-           (ons (mapcar (getter 'on) parsed))
-           (vns (mapcar (lambda (name) (make-symbol (symbol-name name)))
-                        names)))
-      `(let ,(mapcar #'list vns inits)
-         ,@(mapcan (lambda (v tp)
-                     (if tp `((declare (type ,tp ,v))) '()))
-                   vns types)
-         (flet ,(mapcar (lambda (name on vn arglist)
-                          `(,name ,arglist (setf ,vn (,on ,vn it)) it))
-                        names ons vns arglists)
-           (declare (inline ,@names))
+           (vars (mapcar (lambda (p)
+                            (make-symbol (symbol-name (getf p 'name))))
+                          parsed)))
+      `(let ,(mapcar (lambda (p v)
+                       `(,v ,(getp p 'init)))
+                     parsed vars)
+         ,@(mapcan (lambda (p v)
+                     (multiple-value-bind (type typep) (getp p 'type)
+                       (if typep `((declare (type ,type ,v))) '())))
+                   parsed vars)
+         (flet ,(mapcar (lambda (p v)
+                          (let ((arglist (getp p 'arglist))
+                                (on (getp p 'on))
+                                (name (getp p 'name)))
+                            `(,name ,arglist (setf ,v (,on ,v it)) it)))
+                        parsed vars)
+           (declare (inline ,@(mapcar (lambda (p)
+                                        (getp p 'name))
+                                      parsed)))
            ,@forms)
-         (values ,@(mapcar (lambda (vn returner)
-                             (if returner
-                                 `(,returner ,vn)
-                               vn))
-                           vns returners))))))
+         (values ,@(mapcar (lambda (p v)
+                             (multiple-value-bind (returner returnerp) (getp p 'returner)
+                               (if returnerp
+                                   `(,returner ,v)
+                                 v)))
+                           parsed vars))))))
+
+(with-accumulators ((s + :by 1))
+  (s))
 
 ;;;; Something more like Interlisp-D's DOCOLLECT / ENDCOLLECT / TCONC
 ;;; See interlisp.org/docs/IRM.pdf

test/test-collecting.lisp

@@ -25,6 +25,15 @@
     (equal '(1 3))
     (equal '(2 4))))
 
+(define-test ("org.tfeb.hax.collecting" "accumulators")
+  (is = 1 (with-accumulators ((a +)) (a 1)))
+  (is = 1 (with-accumulators ((a + :initially 1))))
+  (is = 1 (with-accumulators ((a + :returner 1+))))
+  (is = 1 (with-accumulators ((a + :by 1)) (a)))
+  (is = 1 (with-accumulators ((a + :default 1)) (a)))
+  (is = 1 (with-accumulators ((a + :default 1)) (a 1)))
+  (is = 1 (with-accumulators ((a + :type fixnum)) (a 1))))
+
 (define-test ("org.tfeb.hax.collecting" "collectors")
   (let ((c (make-collector)))
     (collect-into c 1)