@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@ignore
- Translation of GIT committish: ea78e54687b8beb80958e55bcd3ddfbe90ab5967
+ Translation of GIT committish: e6e64de1da49ff8c6005daa5fd81adc8387b2668
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.16.0"
+@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
@lisp
guile> (define mypair (cons 123 "hello there")
-... )
+@dots{} )
guile> (car mypair)
123
guile> (cdr mypair)
@noindent
-Note : @code{cdr} se prononce @qq{couldeur}, comme l'indiquent Sussman et
+Note : @code{cdr} se prononce @qq{couldeur}, comme l'indiquent Sussman et
Abelson -- voir
@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} :
@example
-(define (nom-fonction argument1 argument2 ... argumentn)
+(define (nom-fonction argument1 argument2@dots{} argumentn)
expression-scheme-qui-donnera-une-valeur-en-retour)
@end example
@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
@lisp
guile> (let ((x 2) (y 3) (z 4)) (display (+ x y)) (display (- z 4))
-... (+ (* x y) (/ z x)))
+@dots{} (+ (* x y) (/ z x)))
508
@end lisp
@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} :
@example
(cond (expression-test-1 expression-résultat-séquence-1)
(expression-test-2 expression-résultat-séquence-2)
- ...
+ @dots{}
(expression-test-n expression-résultat-séquence-n))
@end example
guile> (define a 6)
guile> (define b 8)
guile> (cond ((< a b) "a est plus petit que b")
-... ((= a b) "a égale b")
-... ((> a b) "a est plus grand que b"))
+@dots{} ((= a b) "a égale b")
+@dots{} ((> a b) "a est plus grand que b"))
"a est plus petit que b"
@end lisp
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.
est convertie, en interne, en une définition Scheme :
@example
-(define traLaLa @var{valeur Scheme de `@code{... }'})
+(define traLaLa @var{valeur Scheme de `@code{@dots{}}'})
@end example
Cela signifie que variables LilyPond et variables Scheme peuvent tout à
aussi bien pu écrire
@example
-...
+@dots{}
$(make-sequential-music (list newLa))
@end example
dernière partie de notre fonction pourrait s'écrire ainsi :
@example
-...
+@dots{}
@{ #@@newLa @}
@end example
#(define (nopc)
(ly:set-option 'point-and-click #f))
-...
+@dots{}
#(nopc)
@{ c'4 @}
@end example
LilyPond :
@example
-\override Stem #'thickness = #2.6
+\override Stem.thickness = #2.6
@end example
Cette instruction ajuste l'apparence des hampes. Une entrée
@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
(coordonnée Y).
@example
-\override TextScript #'extra-offset = #'(1 . 2)
+\override TextScript.extra-offset = #'(1 . 2)
@end example
Cette clause affecte la paire @code{(1 . 2)} à la propriété
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
-Une séquence musicale @code{@{ ... @}} se voit attribuer le nom de
+Une séquence musicale @code{@{ @dots{} @}} se voit attribuer le nom de
@code{SequentialMusic}, et les expressions qu'elle contient sont
enregistrées en tant que liste dans sa propriété @code{'elements}. Une
note est représentée par un objet @code{NoteEvent} -- contenant les
(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
-- de telle sorte que les deux notes constituent la séquence -- puis
d'ajouter un @code{SlurEvent} à la propriété @code{'articulations} de
chacune d'elles, et enfin réaliser un @code{SequentialMusic} de ces deux
-@code{EventChords}. En tenant compte du fait que, dans le cadre d'un
-ajout, une propriété non définie est lue @code{'()} (une liste vide),
-aucune vérification n'est requise avant d'introduire un nouvel élément
-en tête de la propriété @code{articulations}.
+éléments @code{NoteEvent}. En tenant compte du fait que, dans le cadre
+d'un ajout, une propriété non définie est lue @code{'()} (une liste
+vide), aucune vérification n'est requise avant d'introduire un nouvel
+élément en tête de la propriété @code{articulations}.
@example
doubleSlur = #(define-music-function (parser location note) (ly:music?)
@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
impossible dans le cadre d'une simple fusion de musique indépendante.
-Un @code{$variable} au milieu de la notation @code{#@{...#@}} se
+Un @code{$variable} au milieu de la notation @code{#@{ @dots{} #@}} se
comporte exactement comme un banal @code{\variable} en notation LilyPond
traditionnelle. Nous savons déjà que
(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
excellente pratique que l'on retrouve dans de nombreux autres langages.
@example
-"Ajoute un accent..."
+"Ajoute un accent@dots{}"
@end example
@noindent
We have seen how LilyPond output can be heavily modified using
commands like
-@code{\override TextScript #'extra-offset = ( 1 . -1)}. But
+@code{\override TextScript.extra-offset = ( 1 . -1)}. But
we have even more power if we use Scheme. For a full explanation
of this, see the @ref{Scheme tutorial}, and
@ref{Interfaces for programmers}.
@lilypond[quote,verbatim,ragged-right]
padText = #(define-music-function (parser location padding) (number?)
#{
- \once \override TextScript #'padding = #padding
+ \once \override TextScript.padding = #padding
#})
\relative c''' {
tempoPadded = #(define-music-function (parser location padding tempotext)
(number? markup?)
#{
- \once \override Score.MetronomeMark #'padding = #padding
+ \once \override Score.MetronomeMark.padding = #padding
\tempo \markup { \bold #tempotext }
#})
projects / lilypond.git / blobdiff