Common Lisp let function

Question

Je commence juste à programmer en Common Lisp et à revenir sur les programmes que j'ai codés lors de mes cours précédents pour apprendre et j'ai de la difficulté à comprendre le problème dans mon code.

(defun input-1() 
     (defvar *message* (read-line)) 
     (defvar *a-value* (parse-integer(read-line))) 
     (defvar *b-value* (parse-integer(read-line)))) 

(defun alphabet (list " " "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" 
     "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z")) 

(defun alphabet-num (list 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 
      20 21 22 23 24 25 26 27 28 29)) 
;(defun inverse (value) 
; (let ((x 0)) 
; (loop while (< x 29) 
; (print x)))) 

(defun inverse (value) 
     (dotimes (x 28) 
      (when (equal (mod (* x value) 29) 1) 
      (return-from inverse x)))) 

(defun get-int (string) 
    (getf (position string alphabet) alphabet-num)) 

(defun get-string (int) 
    (getf (position int alphabet) alphabet)) 

(defun cipher-calc (character) 
    (let ((c-int (get-int character)) 
    (f-char "")) 
    (setf c-int (* *a-value* (- c-int *b-value*))) 
    (setf f-char (get-string (mod (abs c-int) 29))))) 

Cependant, je reçois cette erreur

; in: DEFUN CIPHER-CALC 
;  (* *A-VALUE* (- C-INT *B-VALUE*)) 
; 
; caught WARNING: 
; undefined variable: *A-VALUE* 

;  (- C-INT *B-VALUE*) 
; 
; caught WARNING: 
; undefined variable: *B-VALUE* 

;  (GET-INT CHARACTER) 
; 
; caught STYLE-WARNING: 
; undefined function: GET-INT 

;  (GET-STRING (MOD (ABS C-INT) 29)) 
; 
; caught STYLE-WARNING: 
; undefined function: GET-STRING 
; 
; compilation unit finished 
; Undefined functions: 
;  GET-INT GET-STRING 
; Undefined variables: 
;  *A-VALUE* *B-VALUE* 
; caught 2 WARNING conditions 
; caught 2 STYLE-WARNING conditions 

Je trouve difficile à croire que vous ne pouvez pas appeler une fonction à l'intérieur d'un bloc let, donc je suppose que je fais une erreur. Tout autre conseil sur mon code serait le bienvenu.

Answer 1

Votre code:

(defun input-1() 
    (defvar *message* (read-line)) 
    (defvar *a-value* (parse-integer(read-line))) 
    (defvar *b-value* (parse-integer(read-line)))) 

DEFVAR est censé être utilisé sur le haut niveau et pas à l'intérieur d'une fonction. Dans ce cas, les variables seront définies lors de l'exécution de la fonction. Mais lorsque vous compilez, évaluez ou chargez une telle fonction, la variable n'est pas définie. Ainsi, le compilateur avertira plus tard que dans votre code, ces variables ne sont pas définies.

Lorsque DEFVAR est utilisé au niveau supérieur, alors Lisp reconnaît qu'il existe des définitions de variables.

(defvar *message*) 
(defvar *a-value*) 
(defvar *b-value*)) 

(defun input-1() 
    (setf *message* (read-line)) 
    (setf *a-value* (parse-integer (read-line))) 
    (setf *b-value* (parse-integer (read-line)))) 

Answer 2

defvar ne fait pas ce que vous pensez qu'il fait. Il s'assure que la variable existe et si elle n'existe pas, elle le lie au second argument. Ainsi:

(defvar *test* 5) 
(defvar *test* 10) ; already exist, has no effect 
*test* ; ==> 5 

Ce que vous pouvez faire est de les définir comme celui-ci sur le haut de votre fichier et utilisez setf dans votre fonction:

(defvar *message*) 

(defun input-1() 
     (setf *message* (read-line)) 
     ...) 

Après tout réglage est ce que vous faites. Vous mélangez des fonctions et des variables avec alphabet. Ici vous pouvez utiliser defparameter. Il est comme defvar mais il écrasera toujours lorsque vous chargez le fichier: [? Quelle est la différence entre l'utilisation de « laisser » et « var » de déclarer une variable]

(defparameter *alphabet* (list " " "a" "b" ...))