Re: The LOOP macro

Or if the predicate functions FOO-P and BAR-P are sufficiently
expensive that you don't want to compute more often than absolutely
necessary:
 
  (loop for x in things
        for foo-p = (foo-p x)
        for bar-p = (bar-p x)
        when foo-p collect x into foos
        when bar-p collect x into bars
        when (and foo-p bar-p) collect x into both
        finally (return (values foos bars both)))

Gauche Scheme

(define things '(2 9 33 -44 0 5 -27 88 6 99 -7))

(rlet1 al '()
  (dolist (x things)
    (let ((odd-p (odd? x))  (neg-p (negative? x)))
      (if odd-p (apush! al 'odd x))
      (if neg-p (apush! al 'neg x))
      (and odd-p neg-p (apush! al 'both x)))))

((both -7 -27) (neg -7 -27 -44) (odd -7 99 -27 5 33 9))

Given:

(define-syntax ainc!
  (syntax-rules ()
    [(_ alist key val func default)
     (let ((pair (assoc key alist)))
       (if pair
         (set-cdr! pair (func val (cdr pair)))
         (set! alist (cons (cons key (func val default)) alist))))]
    [(_ alist key val func)
     (ainc! alist key val func 0)]
    [(_ alist key val)
     (ainc! alist key val +)]
    [(_ alist key)
     (ainc! alist key 1)]))

(define-syntax apush!
  (syntax-rules ()
    [(_ alist key val)  (ainc! alist key val cons '())]))