Scheme Example: adding a debugging keyword

The topic came up on SISC users of how to add a debug keyword to the language. That is, a keyword, that when hit, will stop execution and allow you to inspect various variables.

The solution was then provided. I've tweaked that solution ever so slightly and ended up with:

 (define-syntax break
  (syntax-rules ()
    ((_ default-value (var ...))
     (begin
       (display (format "Debugging. Available lexical bindings: ~a\n" '(var ...)))
       (let ((child-env (make-child-environment (interaction-environment))))
         (putprop 'var child-env var) ...
         (let ((result (with-environment child-env (lambda () (repl)))))
           (display "Debugging ended.\n")
           (if (void? result) default-value result)))))

    ((_ var ...)
     (break => #f (var ...)))))

This new syntax is used like so:

(define (foo x)
  (let ((y (sqrt x)))
    (break x y) ; pause to look at x and y
    (/ x y)))

(define (bar x)
  (let ((y (sqrt x)))
    ; inspect x and y, return back y if you leave
    ; the repl by saying (exit). Otherwise, return
    ; value sent to exit - i.e. - (exit 100), returns 100.
    (/ x (break y (x y))))

I think this is so incredibly cool. In 13 lines of code I've added a debugging construct to the language that wasn't there before. How much Java would I had to write to support this? Even if I had wrestled with JPDA, how cleanly integrated would the resulting infrastructure be?

I suppose there are two ways to look at this: (1) What the?! Scheme doesn't even offer a debugger for the language. Or (2), Wow! You can really enhance Scheme easily. I suppose I'm focused on (2).

Thanks to Dominique Boucher who also highlighted this construct.