@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@ignore
- Translation of GIT committish: ea78e54687b8beb80958e55bcd3ddfbe90ab5967
+ Translation of GIT committish: 0cde75024b6f1210b059c48b624e1026836c96aa
When revising a translation, copy the HEAD committish of the
version that you are working on. For details, see the Contributors'
Guide, node Updating translation committishes..
@end ignore
-@c \version "2.17.6"
+@c \version "2.17.11"
@c Translators: Jean-Charles Malahieude
utilise beaucoup les paires, listes, listes associatives et tables de
hachage.
-@subheading Paires
+@menu
+* Paires::
+* Listes::
+* Listes associatives (alists)::
+* Tables de hachage::
+@end menu
+
+
+@node Paires
+@unnumberedsubsubsec Paires
+@translationof Pairs
Le type de donnée composite fondamental est la paire (@code{pair}).
Comme son nom l'indique, il s'agit de lier deux valeurs, à l'aide de
@uref{http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-14.html#footnote_Temp_133}.
-@subheading Listes
+@node Listes
+@unnumberedsubsubsec Listes
+@translationof Lists
Autre structure de donnée commune en Scheme : la liste (@emph{list}).
Une liste se définit comme étant vide (représentée par @code{'()}) ou
que toute expression Scheme est une liste.
-@subheading Listes associatives (alists)
+@node Listes associatives (alists)
+@unnumberedsubsubsec Listes associatives (alists)
+@translationof Association lists (alists)
Il existe un type particulier de liste : la @emph{liste associative} --
ou @emph{alist}. Une @emph{alist} permet de stocker des données dans le
propriétés ou autres données.
-@subheading Tables de hachage
+@node Tables de hachage
+@unnumberedsubsubsec Tables de hachage
+@translationof Hash tables
Il s'agit d'une structure de données à laquelle LilyPond fait parfois
appel. Une table de hachage (@emph{hash table}) peut se comparer à une
issue de son exécution. Les procédures Scheme sont capables de
manipuler des variables qui ne sont pas définies en leur sein.
+@menu
+* Définition de procédures::
+* Prédicats::
+* Valeurs de retour::
+@end menu
-@subheading Définition de procédures
+
+@node Définition de procédures
+@unnumberedsubsubsec Définition de procédures
+@translationof Defining procedures
En Scheme, on définit une procédure à l'aide de l'instruction
@code{define} :
@end lisp
-@subheading Prédicats
+@node Prédicats
+@unnumberedsubsubsec Prédicats
+@translationof Predicates
Une procédure Scheme chargée de retourner une valeur booléenne s'appelle
un @qq{prédicat} (@emph{predicate}). Par convention, plutôt que par
@end lisp
-@subheading Valeurs de retour
+@node Valeurs de retour
+@unnumberedsubsubsec Valeurs de retour
+@translationof Return values
Une procédure Scheme doit toujours renvoyer une valeur de retour, en
l'occurrence la valeur de la dernière expression exécutée par cette
@subsection Scheme et les conditions
@translationof Scheme conditionals
-@subheading if
+@menu
+* if::
+* cond::
+@end menu
+
+
+@node if
+@unnumberedsubsubsec if
+@translationof if
Scheme dispose d'une procédure @code{if} :
@end lisp
-@subheading cond
+@node cond
+@unnumberedsubsubsec cond
+@translationof cond
Une autre manière d'introduire une condition en Scheme est d'utiliser
l'instruction @code{cond} :
phrases. LilyPond dispose d'un analyseur lexical (appelé @emph{lexer})
qui sait identifier les jetons -- nombres, chaînes, éléments Scheme,
hauteurs etc. -- ainsi que d'un analyseur syntaxique (appelé
-@emph{parser}) -- voir l'annexe @ruser{Grammaire de LilyPond}. Dès lors
+@emph{parser}) -- voir
+@rcontribnamed{LilyPond grammar, Grammaire de LilyPond}. Dès lors
que le programme sait quelle règle grammaticale particulière doit
s'appliquer, il exécute les consignes qui lui sont associées.
@subsection Variables LilyPond composites
@translationof LilyPond compound variables
-@subheading Décalages (@emph{offsets})
+@menu
+* Décalages (offsets)::
+* Fractions::
+* Étendues (extents)::
+* Propriété en alists::
+* Chaînes d'alist::
+@end menu
+
+
+@node Décalages (offsets)
+@unnumberedsubsubsec Décalages (@emph{offsets})
+@translationof Offsets
Les décalages (@emph{offset}) sur deux axes (coordonnées X et Y) sont
stockés sous forme de @emph{paires}. Le @code{car} de l'offset
le fichier @file{scm/lily-library.scm}.
-@subheading Fractions
+@node Fractions
+@unnumberedsubsubsec Fractions
+@translationof Fractions
Les fractions, tel que LilyPond les utilise, sont aussi stockées sous
forme de @emph{paire}. Alors que Scheme est tout à fait capable de
LilyPond correspond à @code{1/2} en Scheme.
-@subheading Étendues (@emph{extents})
+@node Étendues (extents)
+@unnumberedsubsubsec Étendues (@emph{extents})
+@translationof Extents
Les paires permettent aussi de stocker des intervalles qui représentent
un ensemble de nombres compris entre un minimum (le @code{car}) et un
d'assurer la cohérence du code.
-@subheading Propriété en @emph{alists}
+@node Propriété en alists
+@unnumberedsubsubsec Propriété en @emph{alists}
+@translationof Property alists
Les propriétés en @emph{alists} sont des structures de données
particulières à LilyPond. Il s'agit de listes associatives dont les
@code{'thickness}.
-@subheading Chaînes d'@emph{alist}
+@node Chaînes d'alist
+@unnumberedsubsubsec Chaînes d'@emph{alist}
+@translationof Alist chains
Une chaîne d'@emph{alist} est une liste contenant les listes
associatives d'une propriété.
'text
"f"))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))))
@end example
(make-music 'AbsoluteDynamicEvent
'text
"f"))
- 'duration (ly:make-duration 2 0 1 1)
+ 'duration (ly:make-duration 2 0 1/1)
'pitch (ly:make-pitch 0 0 0))))
@end example
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))
@end example
(list (make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))))
@end example
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))
@end example
'span-direction
-1))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 5 0))
(make-music
'span-direction
1))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 5 0))))
@end example
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 5 0))))
@end example
@translationof Adding articulation to notes (example)
Le moyen d'ajouter une articulation à des notes consiste à fusionner
-deux expressions musicales en un même contexte, comme nous l'avons vu à
-la rubrique @ruser{Création d'un contexte}. L'option de réaliser
+deux expressions musicales en un même contexte. L'option de réaliser
nous-mêmes une fonction musicale à cette fin nous offre l'avantage de
pouvoir alors ajouter une articulation, telle qu'une instruction de
doigté, individuellement à l'une des notes d'un accord, ce qui est
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch -1 0 0))))
=====
'articulation-type
"accent"))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch -1 0 0))
@end example