La fonction des étiquettes Lisp a été supprimée avant d'être utilisée

Question

J'essaie d'utiliser une fonction locale à l'aide d'étiquettes pour permettre à ma fonction de se répéter. Voici le code:

(defun my-replace (e1 e2 L) 
    "Perform a deep replace e1 with e2 in L." 
    (labels ((my-replace-rec (e1 e2 L) 
      "Used for recursion" 
      (cond ((endp L) nil) 
        ((equal (car L) e1) (cons e2 (cdr L))) 
        ((listp (car L)) (my-replace-rec e1 e2 (car L))) 
        (t (my-replace-rec e1 e2 (cdr L))))))) 
    (my-replace-rec e1 e2 L)) 

Lorsque je bave d'évaluer la fonction et essayer de l'exécuter:

; Note: Deleting unused function             
; (LABELS MY-REPLACE-REC)              
; ;                    

; Warning: This function is undefined:           
; MY-REPLACE-REC 

J'ai essayé de tenir dans la mesure du message d'erreur que je pouvais, mais je Je travaille avec Emacs (que je suis encore très nouveau à) et en essayant de coller à partir d'un petit tampon.

Pourquoi cela se produit-il? Il est défini et utilisé, mais il semble qu'il continue à être supprimé (soi-disant parce qu'il n'est pas utilisé) avant d'être utilisé.

Answer 1

Votre identification est désactivée. Voici votre code correctement identififiés règle:

(defun my-replace (e1 e2 L) 
    "Perform a deep replace e1 with e2 in L." 
    (labels ((my-replace-rec (e1 e2 L) 
       "Used for recursion" 
       (cond ((endp L) nil) 
        ((equal (car L) e1) (cons e2 (cdr L))) 
        ((listp (car L)) (my-replace-rec e1 e2 (car L))) 
        (t (my-replace-rec e1 e2 (cdr L)))))) 
      ;; empty labels body here.. 
     ) 
    ;; my-replace-rec is a global function expected to be defun-ed later 
    (my-replace-rec e1 e2 L)) 

labels fonctionnent comme let. Vous devez utiliser les objets créés dans le corps de labels et non après que la fonction a été détruite.

Avec let:

(let ((a 10)) 
    ; a exists here 
) 
; a doesn't esist anymore 

Avec labels

(labels ((name (arg) arg)) 
    ; the fcuntion exists here 
) 
;the function doesn't esist anymore 

Dans votre code vous faites my-replace-rec puis dans le corps d'étiquettes que vous ne rien et après la my-replace-rec est détruit vous l'appelez. Common Lisp n'a aucun avertissement à ce sujet car il s'attend à ce que vous le définissiez globalement plus tard. Cela ne se compare pas à la portée que vous n'avez pas utilisée.

En déplaçant la fin entre parenthèses afin que l'appel à my-replace-rec se fait dans les labels emacs ident correctement le code:

(defun my-replace (e1 e2 L) 
    "Perform a deep replace e1 with e2 in L." 
    (labels ((my-replace-rec (e1 e2 L) 
       "Used for recursion" 
       (cond ((endp L) nil) 
        ((equal (car L) e1) (cons e2 (cdr L))) 
        ((listp (car L)) (my-replace-rec e1 e2 (car L))) 
        (t (my-replace-rec e1 e2 (cdr L)))))) 
    (my-replace-rec e1 e2 L))) 

Maintenant, quand vous regardez votre code, il semble même que cela parce que vous avez l'a identifié comme si my-replace-rec était utilisé dans les étiquettes alors que l'éditeur et votre implémentation savaient que ce n'était pas le cas.