I just noticed something weird.

If I implement a mutable variant of the "map!" function in the following way

(define (map! f inout . in*)
  (let loop ((tip inout)
    (tips in*))
    (if (and (pair? tip) (every pair? tips))
      (begin
         (set! (car tip) (apply f (car tip) (map car tips)))
         (loop (cdr tip) (map! cdr tips)))
      inout)))

where "every" is defined as

(define (every pred lst)
  (or (null? lst) (and (pred (car lst)) (every pred (cdr lst)))))

it essentially works:

(let ((l (list 1 2 3 4)))
  (map! + l l l))

returns (3 6 9 12)

Also, I can check that the input list is mutated:

(let ((l (list 1 2 3 4)))
  (map + l l l)
  l)

also returns (3 6 9 12)

However, if I repeat the last argument 4 or more times, as in

(let ((l (list 1 2 3 4)))
  (map + l l l l)
  l)

then instead of outputting (4 8 12 16), Kawa outputs (4 8 12 16) (4 8 12
16).

So there's probably some debug output accidentally left somewhere.

This behavior does not occur if I remove the l variable from the last line
of the block, but when I add another expression after that one, the value
is still printed to the screen (and it cannot be captured by
call-with-output-string overriding either current-output-port or
current-error-port),