Question

“define a procedure ‘reduce-per-key’ which a procedure reducef and a list of associations in which each key is paired with a list. The output is a list of the same structure except that each key is now associated with the result of applying reducef to its associated list”

I’ve already written ‘map-per-key’ and ‘group-by-key’ :

(define (map-per-key mapf lls)
  (cond
    [(null? lls) '()]
    [else (append (mapf (car lls))(map-per-key mapf (cdr lls)))]))

---

(define (addval kv lls)
  (cond
    [(null? lls) (list (list (car kv)(cdr kv)))]
    [(eq? (caar lls) (car kv)) 
     (cons (list (car kv) (cons (cadr kv) (cadar lls)))(cdr lls))]
    [else (cons (car lls)(addval kv (cdr lls)))]))

(define (group-by-key lls)
  (cond
    [(null? lls) '()]
    [else (addval (car lls) (group-by-key (cdr lls)))]))

how would I write the next step, ‘reduce-per-key’ ? I’m also having trouble determining if it calls for two arguments or three.

so far, I’ve come up with:

(define (reduce-per-key reducef lls)
  (let loop ((val (car lls))
             (lls (cdr lls)))
    (if (null? lls) val
        (loop (reducef val (car lls)) (cdr lls)))))

however, with a test case such as:

(reduce-per-key
   (lambda (kv) (list (car kv) (length (cadr kv))))
   (group-by-key
     (map-per-key (lambda (kv) (list kv kv kv)) xs)))

I receive an incorrect argument count, but when I try to write it with three arguments, I also receive this error. Anyone know what I’m doing wrong?

Answer 1

Your solution is a lot more complicated than it needs to be, and has several errors. In fact, the correct answer is simple enough to make unnecessary the definition of new helper procedures. Try working on this skeleton of a solution, just fill-in the blanks:

(define (reduce-per-key reducef lls)
  (if (null? lls)        ; If the association list is empty, we're done
      <???>              ; and we can return the empty list.
      (cons (cons <???>  ; Otherwise, build a new association with the same key 
                  <???>) ; and the result of mapping `reducef` on the key's value
            (reduce-per-key <???> <???>)))) ; pass reducef, advance the recursion

Remember that there’s a built-in procedure for mapping a function over a list. Test it like this:

(reduce-per-key (lambda (x) (* x x))
                '((x 1 2) (y 3) (z 4 5 6)))

> '((x 1 4) (y 9) (z 16 25 36))

Notice that each association is composed of a key (the car part) and a list as its value (the cdr part). For example:

(define an-association '(x 3 6 9))
(car an-association)
> 'x       ; the key
(cdr an-association)
> '(3 6 9) ; the value, it's a list

As a final thought, the name reduce-per-key is a bit misleading, map-per-key would be a lot more appropriate as this procedure can be easily expressed using map … but that’s left as an exercise for the reader.

UPDATE:

Now that you’ve found a solution, I can suggest a more concise alternative using map:

(define (reduce-per-key reducef lls)
  (map (lambda (e) (cons (car e) (map reducef (cdr e))))
       lls))