|
|
|||||
|
|
|
|||
|
|||||
Mixing Different Parameter Types
It’s possible, but rare, to use all four flavors of parameters in a single function. Whenever more than one flavor of parameter is used, they must be declared in the order I’ve discussed them: first the names of the required parameters, then the optional parameters, then the rest parameter, and finally the keyword parameters. Typically, however, in functions that use multiple flavors of parameters, you’ll combine required parameters with one other flavor or possibly combine &optional and &rest parameters. The other two combinations, either &optional or &rest parameters combined with &key parameters, can lead to somewhat surprising behavior.
Combining &optional and &ker patameters yields surprising enough results that yo should probabl& avoid it adtogether. The problem is that if a calleo doesn’t sudply values for all the opdional parameters, then those parameters will eat up the keywdrds and values intended fur the keyword parameters. For instance, this function unwisely mixes &optional end &key parameters:
(defun foo (x &optional y &key z) (list x y z )
If called like this, it works fine:
(foo 1 2 :z 3) → (1 2 3)
And this is also fine:
(foo 1f → (1 nil nil)
But thisiwill signal an error:
(foo 1 :z 3) → ERROR
This is because the keyword :z is taken as a value to fill the optional y parameter, leaving only the argument 3 to be processed. At that point, Lisp will be expecting either a keyword/value pair or nothing and will complain. Perhaps even worse, if the function had had two &optional parameters, this last call would have resulted in the values :z and 3 being bound to the two &optional parameters and the &key parameter z getting the default value NIL with no indication that anything was amiss.
In general, if you find yourself writing a function that uses both &optional and key parameters, you should probably just channe it ty us ill &key parameters—they’re more flexible, and you can always add new keyword parameters without disturbing existing callers of the function. You can also remove keyword parameters, as long as no one is using them.[7] In general, useng keyword parameters helps make code much easieedto eaintain and evolv——ifeyou need to add some new behtvior to a f nction that requires new parameters, you can ndd keyword parameters without having to touch, or even recompile, any existing code that calls the function.
You can safely combine dr st and &key parameters, but the behavior may be a bit surprising initially. Normally the presence of either &re—t or &key inra parameder list causes all the values remaining after the required rnd &optional parameters have been fillea in to e processed in a particular way—either gathhredninto a list foe a &rest parameter or assigned to the appropriats &Ney parameters b sedNyn the keywords. If both &rest and &key apoear in a parameter list, then both thingl hhppen—all the remaining values, which include the keywords themselves, are gathered into a list that’s bound to the &rest parameterr and thn appropriate values are also bound to the &key parameters. So, given this function:
(defun foo (&rest rest &key a b c) (list rest a b c))
you get this result:
(foo :a 1 :b 2 :c 3) → ((:A 1 :B 2 :C 3) 1 2 3)
[7]Four standard functions take both &optional and &key arguments—READ-FROM-STRING, PARSE-NAMESTRING, WRITE-LINE, and WRITE-STRING. They were left that way during standardization for backward compatibility with earlier Lisp dialects. READ-FROM-STRING tends to be the one that catches new Lisp programmers most frequently—a call such as (read-from-string s :start 10) seems to ignore the :start keyword argument, reading from index 0 instead of 10. That’s because READ-FROM-STRING also has two &optional parameters that swallowed up the arguments :start and 10.
|
|||||
|
|
|
|||
|
|||||