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)

où 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.

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.

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.

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).

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.

car returns the first element of the list (the head of the list). The list needs to be non-null (not empty). Thus, the following returns the first element of the list:

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

qui est :

"first"

cdr returns the remainder of the list after the first element (the tail of the list). If there is only one element in the list, it returns an empty list.

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

retourne :

(2 "third")

tandis que ce qui suit :

(cdr '("one and only"))

retourne :

()

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 !