Après avoir vu les variables et les fonctions, abordons maintenant la difficile question des Listes Scheme.
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)
(We added the expression x
at the end to print out
the value assigned to x
—normally you won't
need to do this. Notice how let*
operates just like a
function: The value of the last statement is the value returned.)
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.
You should notice that the result returned is not a list of
single, atomic values; rather, it is a list of a literal
("GIMP")
, the list (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.
One of the more common functions you'll encounter is the cons function. It takes a value and places it to its second argument, a list. From the previous section, I suggested that you think of a list as being composed of an element (the head) and the remainder of the list (the tail). This is exactly how cons functions — it adds an element to the head of a list. Thus, you could create a list as follows:
(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 !
![]() |
Note |
---|---|
In Scheme, a semicolon ( |