Envoyé par
shirohige
J'ai essayé:
1 2 3 4
|
(defun minandmax (list)
(print (mine (list)))
(print (maxe (list)))) |
Il existe une fonction qui s'appelle "list", qui construit et retourne une liste avec ses arguments.
Il n'est pas recommandé (un peu long d'entrer dans les détails) d'utiliser une variable qui a le même nom qu'une fonction.
Essaie de remplacer "list" par "lst" ou "l", pour voir ce que ça donne.
J'ai essayer de suprimer la '(' à la 3 eme ligne et donc de la rajouter à la fin mais ça m'a mis:
EVAL: too many parameters for special operator IF:
(IF (NULL (CDR LIST)) (CAR LIST) (SETQ RES (MAXE (CDR LIST)))
(IF (> RES (CAR LIST)) RES (CAR LIST)))
[EDIT]ATTENTION! J'ai tout mélangé!
(Honte à moi de n'avoir pas vérifié!
et merci à byjav de m'avoir corrigé! )
En Le_lisp et en emacs-lisp, le "if" a un "progn" implicite.
En Common Lisp et en Scheme, le "if" n'a pas de "progn" implicite.
PS: j'ai programmé en CL pendant ~ 5 ans (il y a 15 ans), en Le_lisp pendant ~20 ans et en emacs-lisp depuis ~30 ans (ceci explique peut-être cela!)
Hummm... Le dialecte de lisp que utilises n'est sûrement pas Common Lisp où l'on peut écrire:
(if <test> <then-expr> <else-expr1> ... <else-exprN>)
On appelle cette succession de <else-expr> un progn implicite (accepté par le "if" de CL d'emacs lisp, de Le_lisp et d'autres dialectes de lisp).
[/EDIT]
Comme le "if" de ton dialecte n'accepte pas les progn implicites (too many parameters), il faut donc utiliser un "progn" explicite:
(if <test> <then-expr> (progn <else-expr1> ... <else-exprN>))
Rq: on peut également utiliser "cond" où, normalement, chaque clause contient un test et un progn implicite.
Mais la meilleure solution est d'utiliser un "let", comme je l'ai proposé précédemment (lequel fait aussi un progn implicite).
Cette histoire de "progn" implicite est un peu dérangeante pour ceux qui ont appris un autre langage de programmation, comme C.
En C, on utilise des successions d'instructions qui sont autant de progn implicites.
Dans un langage fonctionnel comme lisp, il n'y a que des fonctions. Du coup, on peut avoir besoin d'une fonction pour décrire une "successions d'instructions". Cette fonction est "progn".
"progn" est une fonction (pour faire simple) qui évalue chacun de ses arguments et retourne la valeur retournée par le dernier argument.
(Rq: Elle n'a de sens que si les arguments avant le dernier font des "effets de bord", comme "setq". C'est une sorte d'entorse à la programmation purement fonctionnelle.)
Et, histoire de simplifier les choses, "defun", qui est l'une des premières fonctions que l'on apprend, fait justement un progn implicite. On peut remplacer:
(defun foo (x) (progn (print "x vaut:") (print x))) ; progn explicite
par
(defun foo (x) (print "x vaut:") (print x)) ; progn implicite (succession d'instructions (faisant des effets de bord))
Partager