1.1.4 Types de données Scheme composites

Scheme prend aussi en charge des types de données composites. LilyPond utilise beaucoup les paires, listes, listes associatives et tables de hachage.

Paires

Le type de donnée composite fondamental est la paire (pair). Comme son nom l’indique, il s’agit de lier deux valeurs, à l’aide de l’opérateur cons.

 
guile> (cons 4 5)
(4 . 5)
guile>

Vous aurez noté que la paire s’affiche sous la forme de deux éléments bornés par des parenthèses et séparés par une espace, un point (.) et une autre espace. Le point n’est en aucune manière un séparateur décimal ; il s’agit de l’indicateur d’une paire.

Vous pouvez aussi saisir littéralement les valeurs d’une paire, en la faisant précéder d’une apostrophe.

 
guile> '(4 . 5)
(4 . 5)
guile>

Les deux éléments d’une paire peuvent être constitués de n’importe quelle valeur Scheme valide :

 
guile> (cons #t #f)
(#t . #f)
guile> '("blah-blah" . 3.1415926535)
("blah-blah" . 3.1415926535)
guile>

Les premier et second éléments de la paire sont accessibles à l’aide des procédures Scheme car et cdr.

 
guile> (define mypair (cons 123 "hello there")
... )
guile> (car mypair)
123
guile> (cdr mypair)
"hello there"
guile>

Note : cdr se prononce « couldeur », comme l’indiquent Sussman et Abelson – voir http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-14.html#footnote_Temp_133.

Listes

Autre structure de donnée commune en Scheme : la liste (list). Une liste se définit comme étant vide (représentée par '()) ou une paire dont le cdr est une liste.

Il existe plusieurs méthodes pour créer une liste, la plus courante étant l’utilisation de la procédure list :

 
guile> (list 1 2 3 "abc" 17.5)
(1 2 3 "abc" 17.5)

Comme vous le remarquez, une liste s’affiche sous la forme d’une suite d’éléments séparés par une espace, bornée par des parenthèses. Contrairement à une paire, il n’y a pas de point entre les éléments.

Vous pouvez aussi saisir directement une liste en entourant ses éléments par des parenthèses à la suite d’une apostrophe :

 
guile> '(17 23 "foo" "bar" "bazzle")
(17 23 "foo" "bar" "bazzle")

Les listes ont une importance considérable en Scheme. Certains vont d’ailleurs jusqu’à considérer Scheme comme un dialecte du lisp, où « lisp » serait une abréviation de « List Processing ». Il est vrai que toute expression Scheme est une liste.

Listes associatives (alists)

Il existe un type particulier de liste : la liste associative – ou alist. Une alist permet de stocker des données dans le but de les réutiliser.

Une liste associative est une liste dont les éléments sont des paires. Le car de chacun des éléments constitue une clé (key) et chaque cdr une valeur (value). La procédure Scheme assoc permet de retrouver une entrée de la liste associative ; son cdr en fournira la valeur :

 
guile> (define mon-alist '((1  . "A") (2 . "B") (3 . "C")))
guile> mon-alist
((1 . "A") (2 . "B") (3 . "C"))
guile> (assoc 2 mon-alist)
(2 . "B")
guile> (cdr (assoc 2 mon-alist))
"B"
guile>

LilyPond recourt abondamment aux alists pour stocker des propriétés ou autres données.

Tables de hachage

Il s’agit d’une structure de données à laquelle LilyPond fait parfois appel. Une table de hachage (hash table) peut se comparer à une matrice ou un tableau dont l’index peut être n’importe quel type de valeur Scheme et ne se limitant pas à des nombres entiers.

Les tables de hachage sont un moyen plus efficace que les listes associatives lorsqu’il s’agit d’enregistrer de nombreuses données qui ne changeront que peu fréquemment.

La syntaxe permettant de créer une table de hachage peut paraître complexe, mais vous en trouverez de nombreux exemples dans les sources de LilyPond.

 
guile> (define h (make-hash-table 10))
guile> h
#<hash-table 0/31>
guile> (hashq-set! h 'cle1 "valeur1")
"valeur1"
guile> (hashq-set! h 'key2 "valeur2")
"valeur2"
guile> (hashq-set! h 3 "valeur3")
"valeur3"

La procédure hashq-ref permet de récupérer une valeur dans la table de hachage.

 
guile> (hashq-ref h 3)
"valeur3"
guile> (hashq-ref h 'cle2)
"valeur2"
guile>

La procédure hashq-get-handle permet de retrouver à la fois une clé et sa valeur. Cette procédure a l’avantage de renvoyer #f lorsque la clé n’existe pas.

 
guile> (hashq-get-handle h 'cle1)
(cle1 . "valeur1")
guile> (hashq-get-handle h 'zut)
#f
guile>

Autres langues : English, deutsch, español.
About automatic language selection.

LilyPond — Extension des fonctionnalités