Coin Changer kata in Racket using List Comprehension

coin-changer.rkt

#lang racket
(require rackunit rackunit/text-ui)

(define (change-for coins amount)
  (for/list ([coin coins])
    (if (zero? amount)
        0
        (let ([change (quotient amount coin)])
         (set! amount (remainder amount coin))
         change))))

(run-tests
 (test-suite
  "coin changer tests"
  (let ([registers (list (list 1) (list 5 1) (list 25 10 5 1))])
    (test-case
     "given 0 coins it must return all 0 for each coin"
     (for-each
      (lambda (register)
        (check-true (andmap zero? (change-for register 0))))
      registers))
    (test-case
     "given register it must return coin amounts equal to number of different coin values in register"
     (for-each
      (lambda (register)
        (check-false (empty? register))
        (check-equal? (length register) (length (change-for register 1))))
      registers))
    (test-case
     "given amount between 0 and 4 and a register with pennies it must return pennies equal to amount"
     (for-each
      (lambda (register)
        (for-each
         (lambda (amount)
           (check-equal? (last (change-for register amount)) amount))
         (range 0 5)))
      registers)))
  (test-case
   "given nickels and pennies with amount > 10 it must return more than one nickel"
   (for-each
    (lambda (amount)
      (check > amount 5)
      (check > (first (change-for (list 5 1) amount)) 1))
    (range 10 100)))
  (test-case
   "given nickels and pennies it must return pennies equal to amount % 5"
   (for-each
    (lambda (amount)
      (check-equal? (last (change-for (list 5 1) amount)) (modulo amount 5) (~a "failed on amount " (~v amount))))
    (range 1 100)))
  (test-case
   "given full US register with 99 cents it must work"
   (check-equal? (change-for (list 25 10 5 1) 99) (list 3 2 0 4)))))