[Résolu] (defun... (defun...)) ou (defun...)(defun...) ?

[DenisHen]

Bonjour à la communauté.
Aujourd'hui, je me pose une petite question, peut-être sans intérêts...
Quelle est la différence entre deux defun indivuduels et un defun en contenant un autre ?

(defun Prems ()
  ...
  ...
)
;*************************
(defun Prems ()
  ...
  (defun Deuz ()
  ...
  )
)

Et quels avantages  et inconvéniants ont les deux méthodes ?
Denis...

[(gile)]

Salut,

Des (defun ...) non imbiqués seront accessibles dès le chargement du fichier LISP

Un (defun ...) imbriqué dans un autre, n'est accessible qu'à partir du moment où le (defun ...) parent est exécuté.

Mais généralement, quand on imbrique un (defun ...) dans un autre, on le déclare aussi localement de manière à ce qu'il ne soit pas accessible en dehors du (defun ...) dans lequel il est déclaré.

[DenisHen]

Salut (gile) et merci pour cette précision.
Donc, une variable déclarée dans un defun ne l'est plus dans un defun imbriqué.
Je pensais qu'il y avait un interêt particulier. En fait, pas tellement.
Encore merci...

[(gile)]

il y a 2 minutes, DenisHen a dit :

Donc, une variable déclarée dans un defun ne l'est plus dans un defun imbriqué.

Je n'ai jamais dit ça, relis attentivement.

[DenisHen]

J'avais mal compris, rien de tel qu'un petit essai (que j'aurais pu faire avant), on a donc :

(defun c:Prems ( / Pouette)
  (setq CaDepend "CaDepasse")
  (princ (strcat "\nPrems : CaDepend, " CaDepend))
  (Deuz)
  (defun Deuz ( / )
  (princ (strcat "\nDeuz : CaDepend, " CaDepend))
  (princ)
    )
  (princ)
)

Qui donne :

Commande: PREMS
Prems : CaDepend, CaDepasse
Deuz : CaDepend, CaDepasse
Commande:

Ca va m'être très utile ! !
Encore merci à toi.
Denis...

[(gile)]

Dans ma réponse, il n'est jamais question de variable. Tu ne lis pas attentivement...

 

 

[DenisHen]

Ce n'est pas parce-que tu ne l'as pas écris que je ne l'ai pas lu 😂😉.
Je plaisante, effectivement, tu n'en parles pas, je l'ai peut-être déduit ?
Ou je ne dois pas utiliser le bon terme alors, CaDepend n'est pas une variable ?
En tous cas, tu m'as appris quelque chose sans le savoir, c'est très fort.
Encore merci pour ton aide.

[(gile)]

Je parlais de déclarer localement la fonction imbriquée.

Exemple :

(defun f3 (/ f2)
  (defun f1 () (alert "f1") 1)
  (defun f2 () (alert "f2") 2)
  (f1)
  (f2)
   (alert "f3")
  3
)

Si tu charges ce LISP, tu ne peux pas appeler (f1) ni (f2) tant que tu n'as pas appelé (f3). Et après avoir appelé (f3), tu pourras appeler (f1) qui est globale, mais pas (f2) qui est locale.

Commande: (defun f3 (/ f2)
(_>   (defun f1 () (alert "f1") 1)
(_>   (defun f2 () (alert "f2") 2)
(_>   (f1)
(_>   (f2)
(_>    (alert "f3")
(_>   3
(_> )
F3

Commande: (f1)
; erreur: no function definition: F1

Commande: (f2)
; erreur: no function definition: F2

Commande: (f3)
3

Commande: (f1)
1

Commande: (f2)
; erreur: no function definition: F2

 

[DenisHen]

Wouaouw ! ! !
Alors là, je ne m'en serais jamais douté, qu'on pouvait déclarer des fonctions ! ! !
Je viens d'apprendre plusieurs choses :

1. je pensais que seules les fonctions avec un "c:" devant (ou gc: par exemple) pouvaient être lancées dans AutoCAD, maintenant, je sais qu'entre parenthèses c'est faisable,
2. j'étais persuadé que (defun f1 () (alert "f1") 1) planterait à cause du "1" en fin. Mais non... Ca remplace le (princ) qu'on place toujours en dernier ?
3. et le coup des variables (comme "CaDepend" vu plus haut).

Un super grand merci à toi ! !
Denis...

[(gile)]

il y a 41 minutes, DenisHen a dit :

je pensais que seules les fonctions avec un "c:" devant (ou gc: par exemple) pouvaient être lancées dans AutoCAD, maintenant, je sais qu'entre parenthèses c'est faisable

C'est que tu ne prends pas le temps de lire les documentations, Extrait de "Introduction à AutoLISp" :

 

il y a 43 minutes, DenisHen a dit :

j'étais persuadé que (defun f1 () (alert "f1") 1) planterait à cause du "1" en fin. Mais non... Ca remplace le (princ) qu'on place toujours en dernier ?

Idem, un programme LISP retourne le résultat de l'évaluation de la dernière expression (le nombre entier 1 dans ce cas.

[DenisHen]

Je l'avais bien lu, mais je ne pensais pas que juste un "1" pouvais "passer"...
Je pensais plus à un (princ 1) en fait.
Encore merci à toi pour toutes ces explications.

[(gile)]

Il y a 13 heures, DenisHen a dit :

Alors là, je ne m'en serais jamais douté, qu'on pouvait déclarer des fonctions ! ! !

On en avait pourtant déjà parlé. Voir ici ma réponse et celle de Luna.

[DenisHen]

Effectivement, je m'en souviens, mais je n'avais pas saisi son ampleur à l'époque (il y a 6 mois).
J'ai bien pigé maintenant avec ta démonstration plus haut.
Encore merci.

[Luna]

Le 14/02/2023 à 01:54, DenisHen a dit :

Je l'avais bien lu, mais je ne pensais pas que juste un "1" pouvais "passer"...
Je pensais plus à un (princ 1) en fait.
Encore merci à toi pour toutes ces explications

Coucou,

Pour le coup (et c'est tout l'intérêt d'une fonction d'ailleurs) c'est justement cette dernière expression interprétée par une fonction qui est importante ! Le (princ) en fin de programme, c'est très généralement en fin d'une commande (defun c:...) car on préfère éviter que la commande renvoie quelque chose en ligne de commande ou tout simplement nil. Donc le (princ) est uniquement là pour rendre la ligne de commande "muette" une fois une commande exécutée.

En revanche pour une fonction on veut toujours avoir un retour pour s'assurer du bon fonctionnement de celle-ci, ou bien pour nous renvoyer une valeur dont nous pourrions avoir besoin (un réel, un string, une liste, etc...). Un exemple simple : (list 1 2) renvoie (1 2), ce qui correspond bien à une valeur renvoyée par une fonction. Certaines fonctions renvoie des valeurs, d'autres renvoie simplement vrai ou faux (T ou nil) ou même des valeurs si vrai, nil sinon. Bref, dans l'exemple de (gile) ci-dessus c'était dans l'unique but de s'assurer en ligne de commande que la fonction s'est bien déroulée jusqu'au bout et précise le numéro de la fonction pour que tu comprennes l'ordre de déclaration 😉

La déclaration des variables et fonctions locales est primordiale et permet justement de réduire les erreurs ! Un autre exemple en parlant d'erreurs : dans de nombreux programmes aboutis, tu verras un (defun *error* ...) déclaré localement pour justement permettre de redéfinir localement la fonction *error* existante pour s'adapter au programme en cours sans reprogrammer la fonction existante et ainsi créer un problème ensuite. Mais, il est OBLIGATOIRE de la déclarer localement donc faire très attention avec chat !

Bisous, Luna

[DenisHen]

Chalut @Luna et merci de tes précisions.
Pour le (princ) en fin (ou rien) de fonction, j'ai bien pigé le truc, j'avais fais quelques petits tests.😉
Je suis en plein travail de "développement" (un bien grand mot pour les petites fonctions de mon petit niveau) en ce moment et je vais fortement m'intéresser à *error", car il est aussi important de savoir pourquoi ça plante, que de réattribuer les valeurs aux variables qu'on a modifiées telles qu'elles étaient avant.👍
Bisous, Denis.