Re: Basic List processing

Suppose I have:
>
(defvar *list*
   '((1 2)
     (3 4)
     (5 6)
     (1 7)))
>
>
Now, suppose I want the "keys" of the list, defined by the first element
of the list. Is there a Lisp function which is callable something like:
(keys *list* :key #'first) ; => '(1 3 5)
>
Suppose further that I want to accumulate totals based on keys. The
first element in the list is the key, and the second element in the list
is the value. Is there a Lisp function which is callable something like:
(accum *list*) ; => '( (1 9) (3 4) (5 6) )

 
What we can do is define a somewhat general function for processing this type
of associative list.
 
  (defun histogram (assoc-list reduce-func &rest reduce-args)
    (let ((hash (make-hash-table :test #'eql)))
      (loop for (key value) in assoc-list
            do (push value (gethash key hash)))
      (loop for key being the hash-keys of hash
            using (hash-value value-list)
            collect `(,key
                      ,(apply #'reduce reduce-func value-list reduce-args)))))
 
What HISTOGRAM does is collates the values that share the same key into
lists, and then it processes each list through REDUCE, so that you can
summarize the values using arbitrary arithmetic, not only addition.
 
Some tests:
 
Add:
 
 (histogram '((1 2) (3 4) (5 6) (1 7)) #'+)
 
 -> ((5 6) (3 4) (1 9))
 
Multiply:
 
 (histogram '((1 2) (3 4) (5 6) (1 7)) #'*)
 
 -> ((5 6) (3 4) (1 14))
 
Add, supplying initial value for each summation:
 
 (histogram '((1 2) (3 4) (5 6) (1 7)) #'+ :initial-value 100)
 
 -> ((5 106) (3 104) (1 109))

Gauche Scheme:

(define data '((a 2) (b 5) (a 4) (b 3) (c 9)))

(rlet1 result '()
  (dolist (xs data)
    (ainc! result (car xs) (last xs))))

((c . 9) (b . 8) (a . 6))

(rlet1 result '()
  (dolist (xs data)
    (ainc! result (car xs) (last xs) * 1)))

((c . 9) (b . 15) (a . 8))

(rlet1 result '()
  (dolist (xs data)
    (ainc! result (car xs) (last xs) + 7000)))

((c . 7009) (b . 7008) (a . 7006))

(rlet1 result '()
  (dolist (xs data)
    (ainc! result (car xs) (last xs) cons '())))

((c 9) (b 3 5) (a 4 2))


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)]))