Symbole, expression, variable..

[VDH-Bruno]

Bonsoir,

 

Voilà à l’occasion d’un petit exercice sur l’étude de quelques fonctions LISP, je m’aperçois que certaines notions ne sont pas encore totalement maitrisé concernant les symboles variable et autres expressions.. et ce malgré la lecture attentive de ce support de (gille).

 

Je vais essayer d’être le plus claire possible, j’espère ne pas vous perdre en route car je ne cerne pas facilement la notion qui me fait défaut (en espérant que cela soit plus évident pour vous).

 

L’exercice auquel je me suis livré : Ecrire une fonction symétrique de la fonction nth

 

Dans mon esprit et pour simplifier elle ne retournerait : que la position de la première occurrence de l'élément spécifié dans la liste, en comptant à partir de zéro.

 

Même si mon propos ne porte que sur l’interprétation des résultats je vous livre le code :

 

 (defun s-nth (E Lst)
 (if (member E Lst) ; si (member E Lst) est T continuer, sinon renvoi nil
   (- (length Lst) (length (member E Lst)))
 )
)

 

Pour que je puisse considérer la fonction comme symétrique, il faudrait qu’elle puisse réagir comme sa "parente", à savoir :

(nth 3 '("a" "b" "c" "b" "e")) retourne "b"

(nth 0 '("a" "b" "c" "b" "e")) retourne "a"

(nth 5 '("a" "b" "c" "b" "e")) retourne nil

 

Alors testons :

(s-nth "b" '("a" "b" "c" "b" "e")) retourne 1 (pas 3 normal je voulais la première occurrence)

(s-nth "a" '("a" "b" "c" "b" "e")) retourne 0

(s-nth "f" '("a" "b" "c" "b" "e")) retourne nil

 

Jusque pas de problème poursuivons :

(nth 1 '(/ = + - <)) renvoie =

(nth 3 '(a b c d e)) renvoie D

(s-nth '= '(/ = + - <)) renvoie 1

(s-nth d '(a b c d e)) renvoie nil

 

Problème les fonctions passe mais pas les symboles, la fonction n’est pas à proprement parlé symétrique, c’est pas un drame j’affinerai plus tard, pour l’instant j’analyse.. (ou du moins je tente)

 

Ce que je constate : Mon code repose sur l’utilisation de member, alors je teste :

(member "b" '("a" "b" "c" "b" "e")) ..revoie ("b" "c" "b" "e")

(member '= '(/ = + - <)) renvoie (= + - <)

 

Je suis content mais il n’y avait pas de raison que ce soit différent, poursuivons :

(member a '(a b c b e)) renvoie nil (probléme)

 

Je maîtrise pas encore bien toute les subtilités de langage, alors j’essaye cette forme:

(member 'a '(a b c b e)) renvoie (A B C B E)

 

Ca passe je suis heureux, donc re-teste de ma fonction avec cette syntaxe.

(s-nth 'd '(a b c d e)) renvoie 3

 

Super je suis content ma fonction est bien symétrique contrairement à ma première affirmation, par contre je découvre que je maîtrise pas encore bien toute la compréhension du quote ( ‘), Vous allez me dire ou est le problème, j’ai trouvé la bonne syntaxe, oui mais c’est par tâtonnement (ça devrai plus du moins pas sur ces notions) et c’est gênant pour qui veut prétendre allez plus loin.. (apply mapcar etc.…)

 

Alors je continu à expérimenter en attribuant cette fois ci des valeurs à mes symboles (ou variable, si je ne me trompe pas):

(setq a 10.0 b 11.0 c 12.0 e 14.0)

(s-nth b '(10.0 11.0 12.0 11.0 13.0)) renvoie 1

(s-nth 'b '(a b c b e)) renvoie 1

(s-nth b '(a b c b e)) renvoie nil

 

Et je fini par me mélanger les pinceaux et je n’arrive plus à interpréter clairement mes résultats, peut être qu’une bonne nuit de sommeil et la relecture de mon support me sera profitable ou mieux un avis éclairé pour me recadrer… Merci

 

Ps : Au passage dans mes tâtonnements j’ai tiqué sur (length nil) qui renvoie 0 et pas nil (car pour moi nil c’est rien et zéro quelque chose). En testant ( ) c.a.d. une liste sans élément cela m’a retourné nil, j’ai donc mieux compris l’histoire de (length nil) qui renvoie 0 <=> (length ()) qui renvoie 0 (ce qui est évident écrit sous cette forme), bon satisfait d’avoir au moins appris une chose.

 

[Tramber]

Je vais être tout simple :

 

(member a

Mettre la lettre a,là, toute seule, c'est comme demander qu'elle soit évaluée. Donc ca donne :

(member [valeur de a]

 

Pour la différence entre :

 

(nth 3 '(a b c d e))

et

(nth 3 (list a b c d e))

 

Je dirais qu'il faut le savoir, et ne plus y penser :cool:

 

A propos de ta remarque, sais-tu que (car nil) [et toute la famille] renvoie nil alors qu'on pourrait imaginer une erreur. Une bizarrerie ? une subtilité ? je ne sais pas.

[(gile)]

Salut,

 

C'est excellant ta façon de procéder, je te prédis de rapides progrès en LISP.

Tu expérimentes et trouves toi même les solutions :

(member a '(a b c b e)) renvoie nil

(member 'a '(a b c b e)) renvoie (A B C B E)

 

member retourne la liste à partir de la première occurrence de l'expression dans la liste.

a, b,c, d, e sont des symboles, donc des expressions évaluables sauf si elles sont "quotées".

 

Dans (member a '(a b c b e)) a est évaluée (nil si aucune valeur ne lui a été affectée) mais la liste '(a b c d e) ne l'est pas, elle ne contient que des symboles sans les évaluer et comme elle ne contient pas la valeur de a (nil) member retourne nil.

Dans (member 'a '(a b c b e)) la première occurrence du symbole a est le premier élément de la liste l'expression retourne (A B C B E).

 

(setq a 10.0 b 11.0 c 12.0 e 14.0)

(s-nth b '(10.0 11.0 12.0 11.0 13.0)) renvoie 1

(s-nth 'b '(a b c b e)) renvoie 1

(s-nth b '(a b c b e)) renvoie nil

 

(s-nth b '(a b c b e)) b est évalué, on a donc (s-nth 11.0 '(a b c d e)) comme précédemment, aucun des symboles de la liste n'est évalué parce que la liste est "quotée" 11.0 n'est ni 'a ni 'b, ni 'c...

Pour que s-nth retourne la position du symbole auquel la valeur 11.0 est affectée, il faut permettre l'évaluation des symbole, donc ne pas utiliser de liste quotée mais construire la liste avec la fonction list : (list a b c d e) retourne (10.0 11.0 12.0 14.0)

et :

(s-nth b (list a b c d e)) retourne 1

 

En espérant avoir été clair...

 

PS : la fonction prédéfinie vl-position fait la même chose que ta fonction s-nth.

[(gile)]

(car nil) [et toute la famille] renvoie nil alors qu'on pourrait imaginer une erreur. Une bizarrerie ? une subtilité ? je ne sais pas.

 

Ça s'explique par le fait que nil symbolise, entre autre, une liste vide : '() ce que semble avoir compris Bruno.

Ce qui est plus curieux c'est que nil soit à la fois une liste (vide) et un atom...

 

Extrait du topo sus-cité :

 

Le symbole nil est atypique en ce sens qu’il symbolise plusieurs concepts.

Il exprime la notion de vide : un symbole auquel aucune valeur n’est affectée est nil , une liste qui ne contient aucun élément est nil aussi.

Nil sert aussi pour exprimer le résultat Booléen faux (false) opposé à T vrai (true).

Bien que de type nil, nil est considéré à la fois comme une liste et comme un atome.

(type nil) retourne nil

(atom nil) retourne T

(listp nil) retourne T

[VDH-Bruno]

Ravi que vous aillez compris mes questions..

 

Tramber : Merci, et j’ignorais pour le (car nil) qui renvoie nil (bizarrement je n’avais pas encore testé :cool: ) mais cela me pose moins problème de compréhension.

 

(gile) : Ta réponse me semble on ne peut plus clair, bien que je ne me sente plus trop réceptif pour ce soir. Je regarderai plus dans le détail demain avant de passer le sujet en résolu. Pour vl-position merci également.

 

J’en profite au passage pour te remercier ici (car j’ai pas souhaité polluer le post) pour ce sujet

que je trouve excellent. Il m’aide beaucoup, je bute encore (mais je m’accroche) sur les chalenges vers lesquels tu m’as orienté..

 

Bonne soirée à tous

 

[VDH-Bruno]

Bonjour et bon apéttit,

 

Juste une chose avant de valider le sujet comme totalement résolu, voilà en méditant le paradoxe du nil évoqué entre Tramber et (gile) :

 

Ça s'explique par le fait que nil symbolise, entre autre, une liste vide : '() ce que semble avoir compris Bruno.

Ce qui est plus curieux c'est que nil soit à la fois une liste (vide) et un atom...

 

Une dernière réflexion m’est apparue, sur ces 2 différentes orthographes possibles :

 

La première qui me semble juste d’après les définitions qu’en donnent l’aide :

_$ (car '())

nil

_$ (cdr '())

nil

 

C’est la suivante qui me semble un peu plus suspect :

_$ (car ())

nil

_$ (cdr ())

nil

Bizarre d’un premier abord j’aurais plus vu une réponse du type :

; erreur: type d'argument incorrect: blabla

 

Sinon pour illustrer le paradoxe évoqué par (gille), je me suis servi des fonctions précédemment cités et je pense m’en être plutôt bien sortie.

 

Illustration :

 

Prenons une liste :

‘(1 2 3 4 5)

Extrayons son premier élément :

(car ‘(1 2 3 4 5)) retourne 1

Soumettons-le à la fonction length :

(length (car ‘(1 2 3 4 5))) retourne ; erreur: type d'argument incorrect: listp 1

Normal car length réclame une liste en argument alors que :

(type 1) retourne INT (Un nombre entier)

(atom 1) retourne T (Evaluer comme atom par l’interpréteur)

 

Par analogie avec une liste vide ‘() :

(cdr ‘()) retournerai nil (un nil de type liste)

(car ‘()) retournerai nil (un nil de type atome)

 

Ce qui se vérifierai par :

(listp (cdr ‘())) retourne T

(atom (car ‘())) retourne T

Si comme ne l’avais précisé (gille)

(type nil) retourne nil

(atom nil) retourne T

(listp nil) retourne T

 

Continuons malgré tout l’analogie et soumettons ces expressions à length :

(length (cdr ‘())) retourne 0

Normal je soumets une liste vide, alors que :

(length (car ‘())) retourne 0 (et non une erreur d’argument)

A comparer avec l’expression vu précédemment :

(length (car ‘(1 2 3 4 5))) retourne ; erreur: type d'argument incorrect: listp 1

 

Ceci illustre parfaitement à mon sens le paradoxe du nil à la fois atome et liste, sans différentiation de type entre un 'nil atome' et 'un nil liste'.

 

Merci à ceux qui ont eu le courage de me lire

[Edité le 7/10/2010 par VDH-Bruno]

 

[Edité le 7/10/2010 par VDH-Bruno]

[VDH-Bruno]

Bonjour,

 

Je me réponds à moi-même, concernant ma réflexion sur les 2 orthographes possible de nil

 

Pour ce faire, j’ai évalué les expressions suivantes :

_$ (type '())

nil

_$ (type ())

nil

Les deux écritures, sont reconnues comme appartenant au type nil qui est à la fois une liste (donc évaluable pour cdr et car) et un atome.

 

Pour conclure et résumer: les écritures possibles de nil sont les suivantes :

$ ()

nil

_$ '()

nil

_$ nil

nil

 

Ps : N’ayant plus de questions sur ce thème, je le considère comme résolu :) (et passe enfin à la suite.. :cool: )