¿Cómo declaro una variable ignorable?

10

¿Cómo evito las advertencias del compilador de bytes Unused lexical variableen las funciones definidas mediante macros expandibles defun?

Por ejemplo, macro defun-rcirc-commandin rcirc.el usa la targetvariable que no es utilizada por varias invocaciones.

En Common Lisp puedo usar el ignorable declaración: (declare (ignorable target)).

Malas soluciones:

  • Agregue algo similar (setq target target)a todos los usuarios defun-rcirc-commandque no utilizan target: eso requiere modificar muchas invocaciones de macro.

  • Prefijar la variable ignorable con un guión bajo - _target- no ayuda porque _significa ignore, no ignorable, es decir, cuando se usa, obtengo variable '_target' not left unused.

compilation warning sds
fuente
Prefijarlos con un guión bajo debería hacerlo.
politza
@politza: _ significa ignorar, no ignorable
sds
1
¿Desea modificar la macro para resolver el problema? Probablemente podría simplemente poner un (ignore VAR)argumento para cada argumento defun antes de la expansión, @ body que probablemente silenciará los errores.
Jordon Biondo

Respuestas:

13

La forma en que lo he hecho hasta ahora es agregar una llamada de la forma

(ignore <var>)

Esta llamada de función se optimizará, pero antes de eso, el compilador lo contará como un uso, por lo que no se activará la advertencia "no utilizada".

Stefan
fuente
-1

Al observar el código, parece que el objetivo no está destinado a ser una variable global, sino que se pasa a la función creada cuando se llama. Si ese es el caso, es mejor crearlo como un símbolo local para la macro. Un ejemplo simple de una macro que crea una función que acepta un argumento y le agrega 10:

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

Vocación

(xxx hamster)

resultará en una función llamada hamster que acepta un argumento.

Entonces puedes llamar 

(hamster 5)

y volverá 15.

El truco es crear un nuevo símbolo que actuará como argumento para la nueva función.

EDITAR:

Siempre he visto que si te estás refiriendo al símbolo generado en la expresión del cuerpo pasado, incluyes el nombre en la llamada como:

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

Que luego convierte las llamadas en:

(xxx hamster target (+ target 20))

dónde 

(hamster)

que vuelve 30y

(hamster 20)

vuelve 40.

Es cierto que esto siempre me molesta cuando escribo macros de esta manera hasta que miro el uso en el que parece que se declara un parámetro y luego se usa.

M Smith
fuente
2
El cuerpo de la función se pasa a la macro y debe poder hacer referencia a él target. IOW, su excelente sugerencia no es aplicable en este caso específico.
sds