Fonction, routine, sous-routine ?

[Aleck_Ultimate]

Bonjour à tous.

 

J'aimerais clarifier un point de sémantique qui me pause problème quant on parle de LISP :

 

Pour moi (defun c:command) = commande = fonction = routine

et (defun commande) = fonction = routine = sous-fonction = sous-routine.

 

C'est un truc que je n'arrive pas à définir avec certitude d'après ce que je lit de-çi de-là, et je ne suis même pas sûr que tout le monde se range à la même convention.

 

Pourrais-je avoir un peut de vos lumières ?

 

Merci.

[bonuscad]

Bonjour,

Pour moi, il n'y a pas de règles précises.

Mais pour ma part je suis ces conventions:

 

Une sous fonction doit être appelée avec ses arguments et ses variables locales déclarée.

(defun sous-fonction ( arg1 arg2 ... / varloc1 varloc2) .....)

Pour moi c'est dans ce sens qu'elle est utile.

Une fonction faisant office de commande doit être définie avec seulement ses variables globales/locales

(defun C:ma-commande ( / var1 var2) ...) Donc elle ne fait pas appel à des arguments est peut être appelée directement en ligne de commande par ma-commande

On peut aussi l'appeler en ligne de commande comme ceci:

(C:ma-commande), si on l’appelle ainsi elle pourrait très bien avoir des arguments s'ils étaient définis.

Ainsi (C:ma-commande arg1 arg2 ...) serait possible, mais pas ma-commande arg1 arg2 en ligne de commande . Bien que cela soit possible, c'est incongru de définir une fonction principale comme ceci.

C'est pour ça que je dis qu'il n'y pas de règles.

 

Une sous-fonction peut très bien être appelé en dehors d'un lisp en ligne de commande, il suffit de connaitre le nombre d'arguments et leur nature (s'il y en a, car une fonction peut très bien être sans arguments), ainsi par exemple:

(sous-fonction "toto" 12345) peut être évaluée en ligne de commande si arg1 est de nature chaine et arg2 de nature entier.

Comme (sous-fonction) si il n'y pas d'arguments.

En dernier il y a aussi la fonction anonyme (lambda), celle ci n'est évalué qu'UNE seule fois, elle ne reste pas en mémoire elle peut avoir des arguments ou pas. Exemple:

((lambda (x y) (princ (/ (1+ (sqrt x)) y)) (prin1)) 5 2) ->1.61803, les arguments sont ici 5 et 2

si on change les arguments lors d'un appel suivant.:

((lambda (x y) (princ (/ (1+ (sqrt x)) y)) (prin1)) 7 2) -> 1.82288 pour 7 et 2

 

Pas trop embrouillé?

[(gile)]

Salut,

 

Question vocabulaire, en LISP (langage fonctionnel), une fonction stricto sensu c'est aussi bien :

c:foo dans (defun c:foo ...),

bar dans (defun bar ...),

lambda, defun, car, ...

La première est une fonction qui définit une commande (FOO).

La seconde est une fonction définie par l'utilisateur.

Les autres sont des fonctions prédéfinies.

Mais à proprement parler, il n'existe pas de "sous-fonction".

 

En informatique, une routine (un anglicisme, il me semble) désigne une fonction (une procédure) qui fait partie d'un programme plus large. En LISP, c'est typiquement une fonction définie par l'utilisateur du type :

(defun bar ([args...]) ...)

parfois appelée "sous-routine" (ce qui est un pléonasme) ou (improprement) "sous-fonction".

[Aleck_Ultimate]

Merci beaucoup.

 

Je croie que je vais simplement me fixer sur (defun c:fonction) = commande et (defun fonction) = routine.

[Patrick_35]

Salut

 

Pour ma part, une routine = fonction ou commande.

Une sous-routine ou sous-fonction est une fonction interne à la fonction/commande. En aucun cas, je n'ai accès directement à une sous-fonction. C'est dans la même logique des variables globales/locales.

 

Par exemple

(defun c:fonction(/ s_fonction1 s_fonction2)
 (defun s_fonction1()
   ....
 )

 (defun s_fonction2()
   ....
 )

 ....
)

 

@+

[Aleck_Ultimate]

Aï aï aï...

 

Je sent qu'on est parti sur un débat du type de "mode classique ou ruban".

 

Effectivement c'est un peut comme le français : y'a la règle et y'a l'usage. Ca me plais bien de parler de routine pour un (defun fonction) global et de sous-routine pour un (defun fonction) local.

 

EDIT : correction des thermes de local et globales dont je n'avais utilisé que des synonymes non standardisés

[(gile)]

En LISP, comme dans les autres langages utilisant la programmation fonctionnelle que je connais, les fonctions sont des objets dit "de première classe" ce qui signifie qu'on peut les manipuler comme tous les types de base (entiers, réels, chaînes, etc.). Par exemple, on peut les passer en argument d'une autre fonction (dite "d'ordre supérieur"), les définir ou les annihiler avec setq exactement comme une "variable". En F# (ou Ocaml) par exemple, il n'y a qu'une seule fonction : let pour assigner une valeur à un symbole, cette valeur peut aussi bien être un type primitif ou une fonction (let est à la fois équivalent à setq et à defun).

Donc pour les fonctions, comme pour les "variables", je trouve plus pertinent de parler de fonctions locales ou globales suivant que leur portée est limitée à une autre fonction ou pas.

 

(defun foo (arg ...) ...)     ; fonction globale

(defun c:cmd (/ bar ...) ...) ; commande définie en LISP (fonction globale)
 (defun bar (arg ...) ...)   ; fonction locale à c:cmd
 (foo ...)
 (bar ...)
)

[DenisHen]

...En informatique, une routine (un anglicisme, il me semble) désigne une fonction (une procédure) qui fait partie d'un programme plus large...

Ce que j'en ai compris, c'est qu'un LiSP (procédure) est une routine d'AutoCAD (programme plus large)... ?

Et une sous-routine, une "petite" routine appelée par une routine (ou plusieurs), avec ou sans arguments... De ce fait :

(defun c:Rout1 ()
 code
)

(defun c:Rout1 ()
 code
 (defun SousRout ()
 Code
 (SousRout)
   ) 
 SuiteCode
)

Qui reviendrait au même que :

(defun c:Rout1 ()
 code
 (SousRout1)
 (SousRout2 "Arg")
)
(defun SousRout1 ( / )
 Code
 )
(defun SousRout2 (Arg / )
 Code
 )

Mais dans ce dernier cas, SousRout1 et SousRout2 peuvent être appelées par d'autre "routines"...

Je me trompe ?