>> The only real difference is when you need to define a procedure where passing in `#f` means something distinct from an absent argument. In my opinion, it's a design mistake in the procedure if it needs to make that distinction.
>
> Perhaps in general, but there’s at least one case where it is useful… knowing which parameters were passed to give error messages that correspond to what the programmer wrote.  For example if you have this definition
>
> (define/kw (f str1 str2 (foo)) …)
>
> and str1 and str2 must be strings and foo can be anything, then you want the call
>
> (f "a-string" 'sym)
>
> to give the error message
>
> ERROR -- argument 2 of (f "a-string" 'sym) is not a string
>
> not the message
>
> ERROR -- argument 2 of (f "a-string" 'sym foo: #f) is not a string
>
> So in the case you want to give precise error messages you want to know if the caller supplied a value for a keyword parameter or relied on the default.  The issue is the same for optional positional parameters.

This is an interesting example. However, it's also complicated by
wrapper procedures.

The fundamental problem with wrappers is, you want to avoid having to
write things like this:

(define (wrapper)
   ...
   (cond ((and key3-supplied? key4-supplied?)
          (call/kw wrapped val1 val2 (key3 val3 key4 val4)))
         (key3-supplied?
          (call/kw wrapped val1 val2 (key3 val3)))
         (key4-supplied?
          (call/kw wrapped val1 val2 (key4 val4))
         (else
          (wrapped val1 val2))))

And instead have only one call to `wrapped`:

(define (wrapper)
   ...
   (let ((key3 (or ... default-key3))
         (key4 (or ... default-key4)))
     (call/kw wrapped val1 val2 (key3 val3 key4 val4))))

This is a lot more complicated with non-#f default values.

Also, in the presence of wrappers the distinction between which values
the programmer supplied and which they didn't supply is ambiguous. If
the programmer didn't supply a value, but the wrapper did on his behalf,
and the programmer is not familiar with the implementation of the
wrapper, did he really supply a value?

Effects like this occur in large programs, and this is what I mean by
all-#f default values being simpler to reason about and work with.