有没有办法将解构绑定与 &rest 一起使用？

Question

I have a function that uses &rest which returns a list of the varying amount of args to the function.

I open break lists up with destructuring bind (db). However, db is useful for when the number of variables are known.

What is the best way to break up an &rest list where the number of values vary most of the time?

Answer 1

Here's a simple example of Trivia for pattern matching:

(defun foo (&rest rest)
  (trivia:match rest
    ((list* a b c _)
     (values :got-a-b-c a b c))))

CL-USER> (foo :a :b :c :and :foo)
:GOT-A-B-C
:A
:B
:C

list* allows to pattern-match on a list of varying length. More precisely:

Both list and list* patterns check if the object is of type list, has the same length and then matches the contents to the subpatterns. list* also checks the elements against the subpatterns, however the last pattern is matched against nthcdr of the list.

https://lispcookbook.github.io/cl-cookbook/pattern_matching.html

Answer 2

If you don't know the number of things you wish to bind you can't possibly solve this problem because the number of variables is unknown until runtime.

So the only possible case you can solve is where the number of elements in the list is constrained in some way: in particular it needs to have a maximum number of 'interesting' elements that you want to bind variables to at one time. In that case you can either use a matching macro of some kind, or if your requirements are simpler just use destructuring-bind :

(defun foo (&rest args)
  (destructuring-bind (&optional (a nil ap) (b nil bp) (c nil cp) &rest extras) args
    (unless (null extras)
      (error "too many args"))
    ... use AP, BP, CP to know if one, two or three arguments were
    ... provided, and A, B, C to know what they were.
    ...))

More generally you might want a matching macro. Another answer has already mentioned Trivia, but destructuring-match provides a case -like variant of destructuring-bind :

(defun foo (&rest args)
  (destructuring-match args
    ((a &optional (b 0))
     (+ a b))
    ((a b c)
     (+ a (- b c)))
    (otherwise
     (error "need between 1 and 3 arguments"))))

However the above version of foo can actually be happily be dealt with by just destructuring-bind :

(defun foo (&rest args)
  (destructuring-bind (a &optional (b 0) (c 0)) args
    (+ a (- b c))))

The only difference here is that you don't get to control the error case. destructuring-match is really intended for pulling apart much more complex structures in macros.