Avant d'en dire plus sur les listes, vous devez connaître la différence entre les 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 simple. Nous pouvons, par exemple, attribuer à la variable x la valeur 8 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 simple. 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. Noter 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
                   '("The 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 ("The 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 à 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. Eh 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 and cdr, qui retournent respectivement le premier élément et le reste la liste, selon la structure tête::queue mentionnée plus haut.

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 '("premier" 2 "troisième"))
      

qui est:

        "premier"
      

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 '("premier" 2 "troisième"))
      

retourne:

        (2 "troisième")
      

tandis que ce qui suit:

        (cdr '("seulement un"))
      

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

Pour avoir la liste de toutes les conventions de liste, référez-vous à l'Appendice, qui donne la liste de toutes les fonctions disponibles dans la version de Scheme utilisée par les Script-Fu.

Afins 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) )
                 )
              )
              ; placez ici votre code pour car/cdr
        )
      

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!