In Common Lisp it is idiomatic for functions to allow their behavior to be overridden with keyword arguments.
So Lispers often write functions whose sole purpose is to call a function that takes keyword arguments, but with different defaults.
Since keyword arguments are processed from left to right, and the leftmost occurrence takes precedence, this is easy to do:
(hash-table-test (make-hash-table)) => EQL (defun make-equal-hash-table (&rest args &key &allow-other-keys) (apply #'make-hash-table :test 'equal args)) (hash-table-test (make-equal-hash-table)) => EQUAL
The downside is that the new default is fixed: the caller cannot override it.
(hash-table-test (make-equal-hash-table :test 'eql)) => EQUAL
Can we change the default, but still allow the new default to be overridden? Of course. The obvious way is to append the new default to the end of the argument list:
(defun make-equal-hash-table-v2 (&rest args &key &allow-other-keys) (apply #'make-hash-table (append args '(:test equal)))) (hash-table-test (make-equal-hash-table-v2)) => EQUAL (hash-table-test (make-equal-hash-table-v2 :test 'eql)) => EQL
Unfortunately this allocates a new list. Even SBCL is not smart enough to eliminate the allocation, as you can see from
; DE5: 488B3DA4FEFFFF MOV RDI, [RIP-348] ; '(:TEST EQUAL) ; DEC: 488B05A5FEFFFF MOV RAX, [RIP-347] ; #<SB-KERNEL:FDEFN SB-IMPL::APPEND2>
Of course you may not care about such minor allocations. But for situations where you do care, there is another way — one that involves no allocation.
To capture multiple values in Common Lisp, we generally use
(multiple-value-bind (x y z) (values 1 2 3) (+ x y z)) => 6
multiple-value-bind is just a macro; the actual special form that allows capturing multiple values is the much less frequently encountered
multiple-value-call. You could rewrite the above to use
(multiple-value-call (lambda (&optional x y z) (+ x y z)) (values 1 2 3)) => 6
multiple-value-call is more flexible than that, because it captures all the values returned from all the forms that are provided to it as arguments:
(multiple-value-call (lambda (&optional x y z) (+ x y z)) (values 1) (values 2 3)) => 6 (multiple-value-call (lambda (&optional x y z) (+ x y z)) (values 1 2) 3) => 6 (multiple-value-call (lambda (&optional x y z) (+ x y z)) 1 2 3) => 6
And this takes place entirely on the stack, without any allocations.
To complete the trick, besides
multiple-value-call, we need one other function,
values-list, which takes a list and returns it as multiple values:
(values-list '(1 2 3)) => 1, 2, 3
And now, with
values-list, we have everything we need to write wrapper functions that allow their new defaults to be overridden, without any allocation:
(defun make-equal-hash-table-v3 (&rest args &key &allow-other-keys) (multiple-value-call #'make-hash-table (values-list args) (values :test 'equal))) (hash-table-test (make-equal-hash-table-v3)) => EQUAL (hash-table-test (make-equal-hash-table-v3 :test 'eql)) => EQL
(To understand how the argument list is constructed, watch what happens when multiple-value-calling
(multiple-value-call #'list (values-list '(:test eql)) :test 'equal) => (:TEST EQL :TEST EQUAL)