3.3. Listes, des listes et encore des listes

Après avoir vu les variables et les fonctions, abordons maintenant la difficile question des Listes Scheme.

3.3.1. Définir une Liste

Avant d’en dire plus sur les listes, vous devez connaître la différence entre les valeurs atomiques et les listes.

Vous avez déjà vu des valeurs atomiques quand nous avons initialisé des variables précédemment. Une valeur atomique est une variable qui a une valeur unique. Nous pouvons, par exemple, attribuer à la variable « x » la valeur unique 8 (et rien d’autre) par la déclaration suivante :

(let* ( (x 8) ) x)

(Nous avons ajouté l’expression x à la fin pour afficher la valeur attribuée à x, mais vous n’avez pas normalement à le faire. Notez comment opère let*, comme une fonction : la valeur de la dernière déclaration est la valeur retournée.)

Une variable peut aussi se référer à une liste de valeurs, plutôt qu’à une valeur unique. Pour attribuer à la variable x la liste de valeurs 1, 3, 5, nous devons taper :

(let* ( (x '(1 3 5))) x)

Essayez de taper les deux déclarations dans la Console de Script-Fu et voyez ce que ça donne. Avec la première, vous obtenez :

8

Et avec l’autre déclaration:

(1 3 5)

Le premier résultat vous informe que la variable x contient la valeur atomique 8. Le deuxième résultat signifie que la variable contient une liste de valeurs. Notez qu’il n’y a pas de virgule, ni dans la déclaration, ni dans l’affichage.

La syntaxe pour définir une liste de valeurs est :

'(a b c)

a, b, et c sont des littéraux. Nous avons utilisé l’apostrophe (') pour indiquer que ce qui suit dans les parenthèses est une liste de valeurs littérales, plutôt qu’une fonction ou une expression.

Une liste vide est définie comme suit :

'()

ou simplement :

()

Outre les valeurs atomiques, les listes peuvent contenir d’autres listes :

(let*
   (
        (x
           '("GIMP" (1 2 3) ("is" ("great" () ) ) )
        )
    )
    x
)
      

Notez qu’après la première apostrophe, vous n’avez plus besoin d’utiliser d’autres apostrophes lors de la définition des listes internes. Testez cette déclaration dans la Console de Script-Fu.

Vous verrez que le résultat n’est pas une suite de valeurs simples, mais plutôt la liste d’un littéral ("GIMP"), d’une liste (1 2 3), etc.

3.3.2. Comment se représenter les listes ?

Il est utile de penser que les listes sont composées d’une « tête » et d’une « queue ». La tête est le premier élément de la liste et le reste constitue la queue. Vous verrez pourquoi c’est important quand nous envisagerons la façon d’ajouter un/des élément(s) à une liste et comment accéder aux éléments de la liste.

3.3.3. Création de listes par concaténation (la fonction cons)

Une des fonctions que vous rencontrerez le plus souvent est la fonction cons. Elle prend une valeur et la positionne en tête de son second élément, une liste. Dans la section précédente, nous avons conseillé d’imaginer les listes comme constituées d’une tête et d’une queue. Et bien, la fonction cons ajoute un élément en tête de liste. Nous pouvons donc créer une liste comme suit :

(cons 1 '(2 3 4) )

Le résultat est la liste (1 2 3 4).

Vous pouvez aussi créer une liste d’un élément :

(cons 1 () )

Vous pouvez utiliser des variables préalablement déclarées à la place de tout littéral.

3.3.4. Définir une liste en utilisant la fonction list

Pour définir une liste composée de littéraux ou de variables préalablement déclarées, utilisez la fonction list :

(list 5 4 3 a b c)

Ceci composera et retournera une liste contenant les valeurs portées par les variables a, b et c. Par exemple :

        (let*  (
                  (a 1)
                  (b 2)
                  (c 3)
               )

               (list 5 4 3 a b c)
        )
      

Ce code crée la liste (5 4 3 1 2 3).

3.3.5. Accéder aux valeurs dans une liste

Pour accéder aux valeurs dans une liste, utilisez les fonctions car et cdr, qui retournent respectivement le premier élément et le reste la liste, selon la structure tête::queue mentionnée plus haut.

3.3.6. La fonction car

car retourne le premier élément de la liste (la tête). La liste ne doit pas être vide. Ce qui suit retourne donc le premier élément de la liste :

(car '("first" 2 "third"))

qui est :

"first"

3.3.7. La fonction cdr

cdr retourne le reste de la liste après le premier élément, c.-à-d. la queue de la liste. S’il n’y a qu’un seul élément dans la liste, elle retourne une liste vide.

(cdr '("first" 2 "third"))

retourne :

(2 "third")

tandis que ce qui suit :

(cdr '("one and only"))

retourne :

()

3.3.8. Accéder à d’autres éléments d’une liste

Bon, d’accord, nous pouvons accéder au premier élément et au reste d’une liste, mais comment accéder au nième élément d’une liste ? Il y a plusieurs façons d’accéder, par exemple, à la tête de la tête de la queue d’une liste (caadr), à la queue de la queue d’une liste (cddr), etc.

La convention de base est simple : a et d représentent la tête et la queue d’une liste. Ainsi

(car (cdr (car x) ) )

peut s’écrire :

(cadar x)

Afin d’acquérir quelque expérience des fonctions d’accession aux listes, essayez de taper ce qui suit (en une seule ligne si vous utilisez la console), et faites varier car et cdr pour accéder aux différents éléments de la liste :

        (let* (
                 (x  '( (1 2 (3 4 5) 6)  7  8  (9 10) )
                 )
              )
              : place your car/cdr code here
        )
      

Essayez d’accéder au troisième élément de la liste en utilisant seulement deux appels de fonction. Si vous faites ça, vous êtes en bonne voie pour devenir un Maître de Script-Fu !

[Note] Note

Dans Scheme, un point-virgule (;) indique un commentaire. L’interpréteur de Script-Fu l’ignore, ainsi que tout ce qui suit sur la même ligne. N’hésitez pas à multiplier les commentaires dans vos programmes, ce qui facilitera leur compréhension quand vous y reviendrez plus tard.