Avisos em testes `cond` com `fboundp`, por quê?

O propósito desta macro não está muito claro para mim, mas acho que a questão sobre a natureza desses avisos pode ser abordada. Adicionei algumas notas sobre um possível redesenho no final da resposta.

A razão pela qual SBCL e CCL estão reclamando é que estão compilando código. A resposta CLISP interpreta o código. Se você abrir uma nova replicação SBCL e colocá-la evalno modo interpretado, a macro OP poderá ser invocada sem disparar avisos:

CL-USER> (setf *evaluator-mode* :interpret)
:INTERPRET
CL-USER> (defmacro cond-issue (&key (arg '(a b c)))
  (let ((arg-var (gensym "arg-var-")))
    `(let ((,arg-var (cond ((not (listp ',arg)) (list 'arg))
                           ((fboundp (car ',arg)) ,arg)
                           (t ',arg))))
       `(apply #'+ ,,arg-var))))
COND-ISSUE
CL-USER> (cond-issue :arg (e f g))
(APPLY #'+ (E F G))

Depois de evalvoltar ao modo compilado, os avisos aparecem:

CL-USER> (setf *evaluator-mode* :compile)
:COMPILE
CL-USER> (cond-issue :arg (e f g))
; in: COND-ISSUE :ARG
;     (E F G)
; 
; caught STYLE-WARNING:
;   undefined function: COMMON-LISP-USER::E
; 
; caught WARNING:
;   undefined variable: COMMON-LISP-USER::F
; 
; caught WARNING:
;   undefined variable: COMMON-LISP-USER::G
; 
; compilation unit finished
;   Undefined function:
;     E
;   Undefined variables:
;     F G
;   caught 2 WARNING conditions
;   caught 1 STYLE-WARNING condition
(APPLY #'+ (E F G))
CL-USER> (macroexpand-1 '(cond-issue :arg (e f g)))
(LET ((#:|arg-var-252|
       (COND ((NOT (LISTP '(E F G))) (LIST 'ARG))
             ((FBOUNDP (CAR '(E F G))) (E F G)) (T '(E F G)))))
  `(APPLY #'+ ,#:|arg-var-252|))

Observando a expansão da macro acima, pode-se observar que um ramo do código a ser compilado contém uma chamada de função com uma função indefinida e duas variáveis ​​indefinidas: ((FBOUNDP (CAR '(E F G))) (E F G)). O compilador está reclamando porque não consegue compilar este código. Eu acho que esse é o comportamento que você realmente deseja, ou seja, você provavelmente não deveria tentar contornar os avisos do compilador para funções e variáveis ​​indefinidas.

Considere algum código que deve ser compilado:

CL-USER> (cond-issue :arg (list 1 2))
(APPLY #'+ (1 2))
CL-USER> (macroexpand-1 '(cond-issue :arg (list 1 2)))
(LET ((#:|arg-var-258|
       (COND ((NOT (LISTP '(LIST 1 2))) (LIST 'ARG))
             ((FBOUNDP (CAR '(LIST 1 2))) (LIST 1 2)) (T '(LIST 1 2)))))
  `(APPLY #'+ ,#:|arg-var-258|))

Aqui o formulário (LIST 1 2)substituiu o anterior (E F G)e isso não representa nenhum problema para o compilador. Observe que o formulário resultante acima é (APPLY #'+ (1 2))e este não é um código lisp legal. Acho que a intenção era gerar (APPLY #'+ '(1 2))em vez disso. Além disso, a invocação (cond-issue :arg 42)produz resultados (APPLY #'+ (ARG))onde suspeito que (APPLY #'+ '(42))era desejado. Aqui está uma versão ligeiramente modificada que cond-issuecorrige esses problemas:

(defmacro cond-issue-fixed (&key (arg '(a b c)))
  (let ((arg-var (gensym "arg-var-")))
    `(let ((,arg-var (cond ((not (listp ',arg)) (list ',arg))
                           ((fboundp (car ',arg)) ,arg)
                           (t ',arg))))
       `(apply #'+ ',,arg-var))))

Novamente, acho que você não deveria tentar contornar esses avisos do compilador, mas como um experimento, e no espírito de consertar uma solução incompleta, você poderia agrupar uma cond-issuemacro que verifica os argumentos primeiro:

(defmacro cond-issue-check (&key (arg '(a b c)))
  `(when (every (lambda (item)
                  (or (boundp item)
                      (fboundp item)))
                (remove-if-not #'symbolp ',arg))
     (cond-issue-fixed :arg ,arg)))

Esta solução tem algumas ressalvas: boundpe fboundpverifica ligações no ambiente global, mas não pode inspecionar ligações locais (e não tenho certeza se existe uma maneira simples de fazer isso). Além disso, o wrapper rejeitará invocações de macro como acontece (cond-issue-check :arg 42)com um erro. O cond-issue-checkwrapper poderia ser aumentado para validar melhor a entrada, mas a definição atual deve ser suficiente para deixar claro. Agora seria um bom momento para questionar o propósito da macro, se ela precisa ser uma macro, e para revisitar o design.

CL-USER> (cond-issue-check :arg (e f g))
NIL
CL-USER> (cond-issue-check :arg (list 1 2))
(APPLY #'+ '(1 2))
CL-USER> (let ((a 1) (b 2))
           (cond-issue-check :arg (list a b)))
NIL

No exemplo final acima, o wrapper de verificação não pode determinar se as ligações locais para ae bestão vinculadas. O original, desembrulhado, cond-issuepode ser chamado quando ligações locais são necessárias, mas isso significa que avisos podem ser acionados para funções ou variáveis ​​não vinculadas.

De qualquer forma, a correção acima não interromperá todos os avisos de definições ausentes. Em geral, eu não recomendaria tentar suprimir esses tipos de avisos e não recomendaria usar cond-issue-check. Provavelmente é melhor deixar o compilador fazer o seu trabalho.

Redesenhando a Macro

Parece que o objetivo do OP é tomar como entrada formulários que descrevam outros formulários aos quais #'+podem ser aplicados e, a partir disso, criar formulários que não precisam ser válidos em seu ambiente atual. Se for esse o caso, aqui está um design alternativo.

(defmacro cond-something ((&rest args))
  `(if (and (symbolp ',(car `,args))
            (fboundp ',(car `,args)))
       `(apply #'+ ',,args)
       `(apply #'+ ',',args)))

Aqui, se o primeiro elemento de um formulário de entrada for um símbolo fbound, #'+será gerado um formulário que se aplica ao resultado da chamada do formulário de entrada. Caso contrário, será gerado um formulário que se aplica #'+a todos os argumentos.

Alguns exemplos de invocações:

CL-USER> (cond-something (42))
(APPLY #'+ '(42))
CL-USER> (eval *)
42
CL-USER> (cond-something (list 1 2 3))
(APPLY #'+ '(1 2 3))
CL-USER> (eval *)
6
CL-USER> (cond-something (mapcar (lambda (x) (* 2 x)) '(1 2 3 4 5)))
(APPLY #'+ '(2 4 6 8 10))
CL-USER> (eval *)
30
CL-USER> (cond-something (e f g))
(APPLY #'+ '(E F G))
CL-USER> (eval *)
; Evaluation aborted on #<TYPE-ERROR expected-type: NUMBER datum: E>.

Como mencionado anteriormente, fboundpinspeciona ligações globais, mas não consegue dizer se as variáveis ​​lexicais estão vinculadas a funções, ou seja, aquelas criadas com fletou labels. Aqui estão exemplos que mostram o uso de uma função global para a qual cond-somethinggera a saída esperada e o uso de uma função local para a qual cond-somethingnão geraria o código que se poderia ingenuamente esperar:

CL-USER> (defun g (x y) (list (* x y)))
G
CL-USER> (cond-something (g 2 3))
(APPLY #'+ '(6))
CL-USER> (flet ((f (x y) (list (* x y))))
           (cond-something (f 2 3)))
(APPLY #'+ '(F 2 3))

Adição:

CLISP também reclama:

CL-USER> (lisp-implementation-type)
"CLISP"

CL-USER> (defmacro cond-issue (&key (arg '(a b c)))
           (let ((arg-var (gensym "arg-var-")))
             `(let ((,arg-var (cond ((not (listp ',arg)) (list 'arg))
                                    ((fboundp (car ',arg)) ,arg)
                                    (t ',arg))))
                `(apply #'+ ,,arg-var))))
COND-ISSUE
CL-USER> (defun test () (cond-issue :arg (e f g)))
TEST

Agora vamos compilar a função `TEST:

CL-USER> (compile 'test)
WARNING: in TEST : Function E is not defined
WARNING: in TEST : F is neither declared nor bound,
         it will be treated as if it were declared SPECIAL.
WARNING: in TEST : G is neither declared nor bound,
         it will be treated as if it were declared SPECIAL.
TEST
3
3

Você então precisa olhar para a macroexpansão:

CL-USER> (pprint (macroexpand '(cond-issue :arg (e f g))))

(LET
 ((#:|arg-var-16322|
   (COND ((NOT (LISTP '(E F G))) (LIST 'ARG))
    ((FBOUNDP (CAR '(E F G))) (E F G)) (T '(E F G)))))
 (LIST 'APPLY '#'+ #:|arg-var-16322|))
; No value

Então veja a resposta por ad absurdum ...