écrire fonction ayant un nombre non fixe a l'avance d'arguments en LispWorks

Tout d'abord bonjour aux membres du forum ; je suis un tout nouveau venu.

Je fais la théorie de machines formelles capable de modifier leurs connexions et je programme en Le_Lisp depuis 1980 (sous win98 !!!)
Recemment j'ai decide de programmer en lisp sur un mac sous OSx et ai telecharge LispWorks personal.

Voici le problème que je me pose :

Il existe en Lisp (Le_Lisp et LispWork) des fonctions qui ont un nombre indéterminé d'arguments, exemple

(+ 2 3 4 5 .... 7) ramene la somme de ces nombres quelque soit le nombre d'arguments de la fonction "+", le nombre de ces nombres.

Pour écrire des programmes opérant sur des matrices de connexion,
je voudrais creer une fonction ou logique ayant un nombre quelconque d'arguments, sur l'ensemble (0, 1) et non sur l'ensemble (T, nil) comme c'est le cas avec Le_lisp et LispWorks.
pour être plus précis appelons cette fonction ou_logique, je voudrais pouvoir évaluer des expressions telles que (ou_logique 0 0 1 0 0 .... 0)
ou_logique donc admet comme arguments un nombre quelconque de 0 et de 1 et ramène 1 si et seulement si il y a un ou plusieurs "1" figurant parmi ces arguments et 0 dans tous les autres cas, c'est a dire quand tous les arguments sont égaux a "0".

Quelqu'un peut il m'écrire une defintion de cette fonction en LispWorks

Je vous remercie.


JPMoulin

Une telle fonction existe déjà en Common Lisp, c’est logior.

Mais c’est une vraie fonction. Elle évalue tous ses arguments avant de calculer le résultat. Par contre, or est paresseux : il n’évalue que le nombre des arguments qui suffit pour calculer le résultat. Donc,

Code:

---

1 2 3 4 5

CL-USER> (or t (error "erreur")) T CL-USER> (logior 1 (error "erreur")) erreur [Condition of type SIMPLE-ERROR]

---

C’est pourquoi or est un macro et ne pas une fonction.

Pour définir une fonction avec un nombre variable des arguments on emploie le keyword &rest. La valeur du symbole suivant dans le corps de la fonction sera la liste des arguments. Par exemple, soit

Code:

---

(defun f (x y &rest zs) ...)

---

alor si l’on appelle (f 1 2 3 4 5), la valeur de x sera 1, celle de y sera 2 et celle de z sera (3 4 5). Voilà un exemple :

Code:

---

1 2 3 4 5 6 7 8

(defun write-lines (&rest lines) (dolist (line lines) (write-line line)))   CL-USER> (write-lines "ligne 1" "ligne 2" "ligne 3") ligne 1 ligne 2 ligne 3

---

On peut utiliser &rest dans des macros aussi.

Si tu veux un macro paresseux équivalent à logior, le voilà :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

(defun ou-logique% (nombres) (cond ((null nombres) 1) ((null (rest nombres)) (first nombres)) (t (let ((premier-argument (gensym))) `(let ((,premier-argument ,(first nombres))) (if (not (zerop ,premier-argument)) ,premier-argument ,(ou-logique% (rest nombres))))))))   (defmacro ou-logique (&rest nombres) (ou-logique% nombres))   CL-USER> (ou-logique 0 0) 0 CL-USER> (ou-logique 0 1 0) 1 CL-USER> (ou-logique 1 (error "erreur") 0 0 0) 1

---

Bref, je veux que

Code:

---

(ou-logique a b c d)

---

(où a, b et c sont des expressions) équivaille à

Code:

---

1 2 3 4 5 6 7 8 9 10

(let ((toto a)) (if (not (zerop toto)) toto (let ((tata b)) (if (not (zerop tata)) tata (let ((titi c)) (if (not (zerop titi)) titi d)))))) (*)

---

(l’astérisque ne fait pas partie du code, il est là pour faire des références). De cette façon, si l’un des arguments n’est pas zéro, les arguments suivants ne sont pas évalués. La tâche du macro, c’est de construire la liste (*) à partir des arguments a, b, c et d. Pour faciliter la tâche, j’écris une fonction auxiliaire ou-logique% qui transforme la liste (a b c d) en (*). Il suffit d’employer une récursion très simple, parce que le calcul aura lieu pendent la compilation.

Pour définir le macro ou-logique, il ne reste qu’appliquer la fonction à la liste des arguments du macro.

Je peux, peut-être, expliquer plus en détail comment ça marche, mais les macros sont une matière plus avancée.

PS Il y a plusieures implémentations libres de Common Lisp. Clozure CL + Emacs + Slime doivent marcher sur un mac.

PPS 1980, c’est sérieux... :)

Bonjour

Je te remercie beaucoup du mal que tu t'es donne a répondre. La solution que tu donnes se rapproche beaucoup de cele que que j'ai trouvee hier soir.

Hier soir, je parcourais "GNU Emacs 24.1 Lisp Reference Manual" je suis tombe sur un exemple similaire a ce que je cherchais et a force de trifouillages, j'ai obtenu ce qui suis et qui répond a la question que je pose dans le primer message :

;fonction avec nombre argument non precise et marchant avec des 1 et des 0

Code:

---

1 2 3 4 5 6 7

(defun new_or (a &rest b) (setq liste (list a b)) (setq nliste (append (list (car liste)) (car (cdr liste)))) ; (print (list (car liste))) ; (print (car (cdr liste))) ; (print nliste) (if (member '1 nliste) 1 0))

---

les print avec les points virgules sont des trucs que je mets car j'ai mis longtemps a me debarasser du passage des arguments sous forme de liste ramener par &rest, j'espère que cette explication est claire

quand je tape

Citation:

---

(new_or 0 0 0 0 .... 0 0 0) cela ramene 0
(new_or 0 0 1 0 .... 0 0 0) cela ramene 1

---

ce qui répond bien a la question.

Je vois a ta réponse que j'aurais pu virer dans la liste des arguments a et ne garder que &rest. Je me suis complique la vie et ai écrit quelque chose d'assez laid.

En ce qui concerne les autres langages lisp sur mac, j'ai essaye et j'ai renonce assez vite pour ne pas dire presque immédiatement car on part tout de suite dans toute une série de manipulations informatiques avant d'avoir un truc qui marche effectivement qui pour le non informaticien que je suis paraissent un surcroit de problèmes, c'est pour cela que j'ai adopte LispWorks que j'ai pu utiliser immédiatement.

Je te remercie beaucoup encore une fois.

J-P Moulin

Re bonjour

je viens d'évaluer

Code:

---

1 2 3

(defun new_or ( &rest b) (setq liste b) (if (member '1 liste) 1 0))

---

j'ai une fonction ou sur l'ensemble {0, 1} qui ramène 1 si j'ai un ou plusieurs 1 parmi les arguments de new_or sinon 0

Merci

J-P Moulin

Bien, si tu ne veux pas qu’une fonction, je te conseille d’utuliser logior. C’est standard, c’est-à-dire, tous le monde la comprend et elle est probablement plus efficace et plus robuste qu’une fonction improvisée. C’est bit or, mais si tous les arguments n’ont qu’un bit chaqu’un, c’est ce qu’il te faut. Donc, la fonction or_new est seulement un exercise.

J’ai les remarques suivantes.

1. En Common Lisp, on n’utilise jamais d’underscores, mais plutot des traits d’union: new-or.

2. Un programme en Common Lisp est composé des S-expressions, c’est-à-dire des atoms et des listes. Chaque expression est évaluée, c’est-à-dire, elle ramène une valeur en effectuant, peut-être, des actions sécondaires (par exemple, l’entrée ou la sortie des données).

Un nombre, un charactère ou une chaîne littérale sont évalués à eux-mêmes. Ça veut dire que « 1 », par exemple, est une expression, dont la valeur est 1. Ou bien on peut écrire "salut" dans le REPL, et le résultat sera "salut".

Par contre, un symbole n’est pas par défaut évalué à lui-même. Un symbole est évalué à une valeur associée. Donc, si j’écris (sin x), ce n’est pas le sinus du symbole x que je veux obtenir, mais le sinus de la valeur associée à x. (Cependent, il y a des symboles qui sont évalués à eux-même : par exemple, « nil » ou les keywords tels comme :a, :b, etc.)

Il arrive qu’on ne veut pas évaluer une expression : par exemple, on veut travailler avec le symbole x plutôt qu’avec la valeur associée. Alors on met ' avant l’expression (ce qui est une abréviation de (quote x)). 'x est évalué au symbol x.

Donc, 1 et '1 est la même chose: « 1 » veut dire « évaluer le nombre 1 en obtenant 1 », alors que « '1 » signifie « ne pas évaluer le nombre 1 en obtenant la valeur littérale 1 ». D’habitude, on n’ecrit pas ' avant un nombre.

3. En Common Lisp, toutes les variables sont déclarées, et les operateurs d’affectation (tels comme setf, setq) changent les valeurs déjà existentes. Ainsi, le compilateur devait t’avertir que b était une variable indéfinie. D’habitude, on déclare les variables à l’aide de let, let* et ainsi de suite.

Donc, le code plus idiomatique serait

Code:

---

1 2 3

(defun new-or (&rest b) (let ((liste b)) (if (member 1 liste) 1 0)))

---

ce qui est équivalent à

Code:

---

1 2	(defun new-or (&rest b) (if (member 1 b) 1 0))

---

Citation:

---

En ce qui concerne les autres langages lisp sur mac, j'ai essaye et j'ai renonce assez vite pour ne pas dire presque immédiatement car on part tout de suite dans toute une série de manipulations informatiques avant d'avoir un truc qui marche effectivement qui pour le non informaticien que je suis paraissent un surcroit de problèmes, c'est pour cela que j'ai adopte LispWorks que j'ai pu utiliser immédiatement.

---

Lispworks, Clozure CL, SBCL et d’autres, c’est le même langage, Common Lisp. Il est assez facile d’écrire du code portable. Je comprends bien qu’un environnement de développement prêt à emploi est pratique, mais l’existence des alternatives libres est au moins rassurante. :) À propos, il existe aussi un environnement récent qui est libre, Portacle : https://shinmera.github.io/portacle/

Bonjour.

Je te remercie des tes explications.

En fait, j'ai appris Le_Lisp tout seul et je n'étais pas préoccupe par tout ce que tu m'expliques. J'avais hate de voir tourner les machines formelles que je venais de trouver et ai pris très vite la mauvaise habitude de taper des instructions jusqu'a ce que cela marche , ce que permet facilement un langage interprèté. Tout cela doit faire hérisser les cheveux des personnes compétentes et soucieuse de bonne programmation.

Merci

J-P Moulin

Citation:

---

Envoyé par JPMoulin

Hier soir, je parcourais "GNU Emacs 24.1 Lisp Reference Manual" je suis tombe sur un exemple similaire a ce que je cherchais
[snip]
En ce qui concerne les autres langages lisp sur mac, j'ai essaye et j'ai renonce assez vite pour ne pas dire presque immédiatement car on part tout de suite dans toute une série de manipulations informatiques avant d'avoir un truc qui marche effectivement qui pour le non informaticien que je suis paraissent un surcroit de problèmes, c'est pour cela que j'ai adopte LispWorks que j'ai pu utiliser immédiatement.

---

Bonjour JP,

je suis également sur mac depuis 1986.

J'ai programmé en LOGO sur Goupil en 1983, ainsi qu'en Le_Lisp depuis 1984 sous SMX, Multics, VAX/Unix, Mac (system 5), Sun, Sparc..., en Common Lisp/CLOS depuis 1987 sur Mac, Next, Sun, Sparc... et en emacs-lisp depuis 1983 sur Vax/Unix, Sun, Sparc, PC (windows ou linux) et mac.

Lorsque j'ai besoin de développer rapidement un prototype ne nécessitant pas d'interface sophistiquée, je le fais en emacs-lisp dans une fenêtre emacs. J'utilise M-x ielm RET qui fournit un toplevel emacs-lisp tout à fait convenable.