Comment déclarer une variable ignorable?

Comment puis-je éviter les avertissements du compilateur d'octets Unused lexical variabledans les fonctions définies à l'aide de macros développées en defun?

Par exemple, macro defun-rcirc-commandin rcirc.el utilise la targetvariable qui n'est pas utilisée par plusieurs appels.

En Common Lisp je peux utiliser la ignorable déclaration: (declare (ignorable target)).

Mauvaises solutions:

• Ajoutez quelque chose comme (setq target target)à tous les utilisateurs defun-rcirc-commandqui n'utilisent pas target: cela nécessite de modifier de nombreuses invocations de macro.

• Préfixer la variable ignorable avec un trait de soulignement - _target- n'aide pas parce que cela _signifie ignore, non ignorable, c'est-à-dire, quand elle est utilisée, je reçois variable '_target' not left unused.

La façon dont je l'ai fait jusqu'à présent est d'ajouter un appel de la forme

(ignore <var>)

Cet appel de fonction sera optimisé, mais avant cela, le compilateur le considérera toujours comme une utilisation, donc l'avertissement "inutilisé" ne sera pas déclenché.

En regardant le code, il apparaît que la cible n'est pas destinée à être une variable globale mais transmise à la fonction créée lors de son appel. Si tel est le cas, il est préférable de le créer en tant que symbole local de la macro. Un exemple simple d'une macro qui crée une fonction qui accepte un argument et y ajoute 10:

(defmacro xxx (name)  
  ""
  (let ((target (make-symbol "target")))
  `(defun ,name (,target) (+ 10 ,target))))

Appel

(xxx hamster)

entraînera une fonction nommée hamster qui accepte un argument.

Ensuite, vous pouvez appeler

(hamster 5)

et il reviendra 15.

L'astuce consiste à créer un nouveau symbole qui servira d'argument à la nouvelle fonction.

ÉDITER:

J'ai toujours vu que si vous faites référence au symbole généré dans l'expression corporelle transmise, vous incluez le nom dans l'appel comme:

(defmacro xxx (name t2 &rest body)  
  ""
  (let ((t2-arg (make-symbol "target")))
  `(defun ,name (&optional ,t2-arg) 
     (let ((,t2 (or ,t2-arg 10)))
       ,@body))))

Ce qui transforme ensuite les appels en:

(xxx hamster target (+ target 20))

où

(hamster)

qui revient 30et

(hamster 20)

retourne 40.

Certes, cela me dérange toujours lorsque j'écris des macros de cette façon jusqu'à ce que je regarde l'utilisation dans laquelle il apparaît qu'un paramètre est déclaré et utilisé plus tard.