Common Lisp: erreur "CDR LST devrait être une expression lambda"

Question

Je fais un programme qui accepte une liste et deux atomes et remplace atom-1 par atom-2 si atom-1 apparaît dans la liste.
Je fais la programmation dans un éditeur de texte à l'aide d'un système Ubuntu

Voici mon code:

#! /usr/bin/clisp 

(defun my-replace (lst x y) 
    (cond 
    ((eq lst nil) nil) 
    ((eq (cdr lst) nil) nil) 
    ((eq (car lst) x) (setq (car lst) y)) 
    (t (my-replace ((cdr lst) x y))))) 

Lorsque je tente d'exécuter ce, Clisp montre cette erreur:

*** - SYSTEM::%EXPAND-FORM: (CDR LST) should be a lambda expression

Je suis débutant en Lisp.
Dites-moi comment résoudre cette erreur.

Answer 1

Tout d'abord vous devez améliorer la mise en forme et le retrait:

(defun my-replace (lst x y) 
    (cond 
    ((eq lst nil) nil) 
    ((eq (cdr lst) nil) nil) 
    ((eq (car lst) x) (setq (car lst) y)) 
    (t (my-replace ((cdr lst) x y))))) 

Regardons le code:

(defun my-replace (lst x y) 
; in Common Lisp you can write LIST instead of LST 
; what are x and y? The naming is not very speaking. 

    (cond 
    ((eq lst nil) nil) 

    ((eq (cdr lst) nil) nil) ; why this clause? 

    ((eq (car lst) x) (setq (car lst) y)) 
    ; instead of SETQ use SETF 

    (t (my-replace ((cdr lst) x y))))) 
        ; here is a function call? why the extra parentheses 

Je me concentrerais d'abord sur une version qui est non destructive. Vous essayez d'écrire une version qui modifie de manière destructive la liste. Ne pas. Créez une nouvelle liste avec les remplacements effectués.

Si vous voulez écrire une version destructive, vous pouvez le faire, mais vous devez d'abord avoir les bases.

Answer 2

Modifier: Cette réponse indique une autre erreur évidente dans l'extrait. L'erreur dans le titre est due aux parens supplémentaires autour de (cdr lst) x y, le rendant ((cdr lst) x y), ce qui n'a de sens que si (cdr lst) est une expression lambda, et peut être appelée.

---

Normalement, si l'on veut lier quelque chose à une valeur, on utilise set. setq est une version spéciale de set, lorsque le premier argument est une valeur qutoed, donc au lieu d'écrire (set 'horse 123), vous devez écrire (setq horse 123).

Cependant, vous ne voulez pas lier un symbole à une valeur, vous voulez faire d'un élément d'une liste une valeur. C'est quand vous voulez utiliser setf.

(let ((lst (list 1 2 3))) 
    (setf (car lst) 4) 
    (princ lst)) ;; (4 2 3) 

Voir this excellente réponse pour plus d'informations.