@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@ignore
- Translation of GIT committish: 904ea9fed4c66f5b86f3ac6ffb9fa273f082f371
+ Translation of GIT committish: ea78e54687b8beb80958e55bcd3ddfbe90ab5967
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.15.20"
+@c \version "2.17.6"
@c Translators: Jean-Charles Malahieude
vous rendre sur @uref{http://@/www@/.schemers@/.org}.
Le Scheme utilisé par LilyPond repose sur l'implémentation GNU
-Guile@tie{}; celle-ci se base sur le standard Scheme @qq{R5RS}. Si
+Guile ; celle-ci se base sur le standard Scheme @qq{R5RS}. Si
votre but est d'apprendre Scheme au travers de LilyPond, sachez que
l'utilisation d'une autre implémentation ou d'un autre standard pourrait
être source de désagrément. Vous trouverez plus d'information sur
-GUILE à la page @uref{http://www.gnu.org/software/guile/}@tie{}; le
+GUILE à la page @uref{http://www.gnu.org/software/guile/} ; le
standard Scheme @qq{R5RS} est quant à lui disponible à la page
@uref{http://www.schemers.org/Documents/Standards/R5RS/}.
L'installation de LilyPond comprend l'implémentation GUILE de Scheme.
La plupart des systèmes disposent d'un @qq{bac à sable} Scheme pour
-effectuer des tests@tie{}; vous y accéderez en tapant @qq{guile} dans
+effectuer des tests ; vous y accéderez en tapant @qq{guile} dans
un terminal. Certains systèmes, notamment Windows, nécessitent d'avoir
auparavant créé la variable d'environnement @code{GUILE_LOAD_PATH} qui
devra pointer vers le répertoire @code{../usr/share/guile/1.8} de
à partir du menu @qq{Démarrer} puis taper @qq{guile}.
Néanmoins, tous les paquetages de LilyPond disposent d'un bac à sable
-Scheme, accessible par la commande@tie{}:
+Scheme, accessible par la commande :
@example
lilypond scheme-sandbox
@end example
@noindent
-Une fois le bac à sable actif, vous obtiendrez l'invite@tie{}:
+Une fois le bac à sable actif, vous obtiendrez l'invite :
@lisp
guile>
@end lisp
Une variable Scheme peut contenir n'importe quelle valeur valide en
Scheme, y compris une procédure Scheme.
-Une variable Scheme se crée avec la fonction @code{define}@tie{}:
+Une variable Scheme se crée avec la fonction @code{define} :
@lisp
guile> (define a 2)
@end lisp
L'évaluation d'une variable Scheme se réalise en saisissant le nom de
-cette variable à l'invite de Guile@tie{}:
+cette variable à l'invite de Guile :
@lisp
guile> a
@end lisp
Une variable Scheme s'affiche à l'écran à l'aide de la fonction
-@code{display}@tie{}:
+@code{display} :
@lisp
guile> (display a)
@end lisp
Après avoir créé une variable, vous pouvez en modifier la valeur grâce à
-un @code{set!}@tie{}:
+un @code{set!} :
@lisp
guile> (set! a 12345)
@end lisp
Vous quitterez proprement le bac à sable à l'aide de l'instruction
-@code{quit}@tie{}:
+@code{quit} :
@lisp
guile> (quit)
@funindex ##f
@item Nombres
-Les nombres se saisissent le plus communément@tie{}: @code{1} est le
+Les nombres se saisissent le plus communément : @code{1} est le
nombre (entier) un, alors que @w{@code{-1.5}} est un nombre à virgule
flottante (un nombre non entier).
@item Chaînes
Les chaînes de caractères sont bornées par des guillemets
-informatiques@tie{}:
+informatiques :
@example
"ceci est une chaîne"
@end example
-Une chaîne peut s'étendre sur plusieurs lignes@tie{}:
+Une chaîne peut s'étendre sur plusieurs lignes :
@example
"ceci
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
(@code{.}) et une autre espace. Le point n'est en aucune manière un
-séparateur décimal@tie{}; il s'agit de l'indicateur d'une paire.
+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.
@end lisp
Les deux éléments d'une paire peuvent être constitués de n'importe
-quelle valeur Scheme valide@tie{}:
+quelle valeur Scheme valide :
@lisp
guile> (cons #t #f)
@subheading Listes
-Autre structure de donnée commune en Scheme@tie{}: la liste
-(@emph{list}). Une liste se définit comme étant vide (représentée par
-@code{'()}) ou une paire dont le @code{cdr} est une liste.
+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
+une paire dont le @code{cdr} est une liste.
Il existe plusieurs méthodes pour créer une liste, la plus courante
-étant l'utilisation de la procédure @code{list}@tie{}:
+étant l'utilisation de la procédure @code{list} :
@lisp
guile> (list 1 2 3 "abc" 17.5)
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@tie{}:
+par des parenthèses à la suite d'une apostrophe :
@lisp
guile> '(17 23 "foo" "bar" "bazzle")
@subheading Listes associatives (alists)
-Il existe un type particulier de liste@tie{}: la @emph{liste
-associative} -- ou @emph{alist}. Une @emph{alist} permet de stocker des
-données dans le but de les réutiliser.
+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
+but de les réutiliser.
Une liste associative est une liste dont les éléments sont des paires.
Le @code{car} de chacun des éléments constitue une clé (@emph{key}) et
chaque @code{cdr} une valeur (@emph{value}). La procédure Scheme
@code{assoc} permet de retrouver une entrée de la liste
-associative@tie{}; son @code{cdr} en fournira la valeur@tie{}:
+associative ; son @code{cdr} en fournira la valeur :
@lisp
guile> (define mon-alist '((1 . "A") (2 . "B") (3 . "C")))
@end ignore
Scheme permet aussi d'effectuer des calculs. Il utilise alors un
-@emph{préfixe}. Additionner 1 et@tie{}2 s'écrira @w{@code{(+ 1 2)}} et
+@emph{préfixe}. Additionner 1 et 2 s'écrira @code{(+ 1 2)} et
non @math{1+2} comme on aurait pu s'y attendre.
@lisp
3
@end lisp
-Les calculs peuvent s'imbriquer@tie{}; le résultat d'une fonction peut
+Les calculs peuvent s'imbriquer ; le résultat d'une fonction peut
servir pour un autre calcul.
@lisp
13
@end lisp
-Ces calculs sont un exemple d'évaluation@tie{}: une expression telle que
-@w{@code{(* 3 4)}} est remplacée par sa valeur, soit @code{12}.
+Ces calculs sont un exemple d'évaluation : une expression telle que
+@code{(* 3 4)} est remplacée par sa valeur, soit @code{12}.
En matière de calcul, Scheme fait la différence entre des nombres entiers
ou non. Les calculs sur des nombres entiers seront exacts, alors que
s'il s'agit de nombres non entiers, les calculs tiendront compte de la
-précision mentionnée@tie{}:
+précision mentionnée :
@lisp
guile> (/ 7 3)
Le fait que le premier élément d'une expression Scheme sous forme de
liste ne soit pas un opérateur ou une procédure déclenchera une
-erreur de la part de l'interpréteur@tie{}:
+erreur de la part de l'interpréteur :
@lisp
guile> (1 2 3)
Vous pouvez constater que l'interpréteur a tenté de considérer @code{1}
comme étant un opérateur ou une procédure, ce qu'il n'a pu réaliser. Il
a donc renvoyé l'erreur @qq{Wrong type to apply: 1} (@emph{Application
-d'un type erroné@tie{}: 1}).
+d'un type erroné : 1}).
C'est pourquoi il est impératif, pour créer une liste, soit d'utiliser
l'opérateur consacré (@code{list}), soit de faire précéder la liste
@subheading Définition de procédures
En Scheme, on définit une procédure à l'aide de l'instruction
-@code{define}@tie{}:
+@code{define} :
@example
(define (nom-fonction argument1 argument2 ... argumentn)
@end example
Nous pourrions, par exemple, définir une procédure calculant la moyenne
-de deux nombres@tie{}:
+de deux nombres :
@lisp
guile> (define (moyenne x y) (/ (+ x y) 2))
Une fois la procédure définie, on l'appelle en la faisant suivre, dans
une liste, des arguments qui doivent l'accompagner. Calculons
-maintenant la moyenne de 3 et 12@tie{}:
+maintenant la moyenne de 3 et 12 :
@lisp
guile> (moyenne 3 12)
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
nécessité, le nom d'un prédicat se termine par un point
-d'interrogation@tie{}:
+d'interrogation :
@lisp
guile> (define (moins-de-dix? x) (< x 10))
@code{let}. Ceci aura pour effet de créer une série de liens, puis
d'évaluer en séquence les expressions susceptibles d'inclure ces
liens. La valeur renvoyée par un bloc @emph{let} est la valeur de
-retour de la dernière clause de ce bloc@tie{}:
+retour de la dernière clause de ce bloc :
@lisp
guile> (let ((x 2) (y 3) (z 4)) (display (+ x y)) (display (- z 4))
@subheading if
-Scheme dispose d'une procédure @code{if}@tie{}:
+Scheme dispose d'une procédure @code{if} :
@example
(if expression-test expression-affirmative expression-négative)
@subheading cond
Une autre manière d'introduire une condition en Scheme est d'utiliser
-l'instruction @code{cond}@tie{}:
+l'instruction @code{cond} :
@example
(cond (expression-test-1 expression-résultat-séquence-1)
(expression-test-n expression-résultat-séquence-n))
@end example
-Comme par exemple ici@tie{}:
+Comme par exemple ici :
@lisp
guile> (define a 6)
* Syntaxe Scheme dans LilyPond::
* Variables LilyPond::
* Saisie de variables et Scheme::
+* Import de code Scheme dans LilyPond::
* Propriétés des objets::
* Variables LilyPond composites::
* Représentation interne de la musique::
Une autre manière de faire appel à l'interpréteur Scheme à partir de
LilyPond consiste à introduire une expression Scheme par un caractère
-dollar au lieu d'un caractère dièse -- un@tie{}@code{$} au lieu
-d'un@tie{}@code{#}. En pareil cas, LilyPond évalue le code dès sa
-lecture par l'analyseur lexical, vérifie le type d'expression Scheme qui
-en résulte et détermine un type de jeton (l'un des @code{xxx_IDENTIFIER}
-de la grammaire) qui lui corresponde, puis en fait une copie qui servira
-à traiter la valeur de ce jeton. Lorsque la valeur de l'expression est
-@emph{void}, autrement dit une valeur Guile @code{*unspecified*}
-(pour @emph{non spécifiée}), aucune information n'est transmise à
-l'analyseur grammatical.
+dollar au lieu d'un caractère dièse -- un @code{$} au lieu
+d'un @code{#}. En pareil cas, LilyPond évalue le code dès sa lecture
+par l'analyseur lexical, vérifie le type d'expression Scheme qui en
+résulte et détermine un type de jeton (l'un des @code{xxx_IDENTIFIER} de
+la grammaire) qui lui corresponde, puis en fait une copie qui servira à
+traiter la valeur de ce jeton. Lorsque la valeur de l'expression est
+@emph{void}, autrement dit une valeur Guile @code{*unspecified*} (pour
+@emph{non spécifiée}), aucune information n'est transmise à l'analyseur
+grammatical.
C'est, en réalité, la manière dont LilyPond opère lorsque vous rappelez
une variable ou une fonction par son nom -- au travers d'un @code{\nom}
--, à la seule différence que sa finalité est déterminée par l'analyseur
-lexical de LilyPond sans consultation du lecteur Scheme@tie{}; le nom de
+lexical de LilyPond sans consultation du lecteur Scheme ; le nom de
la variable rappelée doit donc être en corrélation avec le mode LilyPond
actif à ce moment là.
L'immédiateté de l'opérateur @code{$} peut entraîner des effets
indésirables dont nous reparlerons à la rubrique
-@ref{Saisie de variables et Scheme}@tie{}; aussi est-il préférable
-d'utiliser un @code{#} dès que l'analyseur grammatical le supporte.
+@ref{Saisie de variables et Scheme} ; aussi est-il préférable
+d'utiliser un @code{#} dès que l'analyseur grammatical le supporte.
+Dans le cadre d'une expression musicale, une expression qui aura été
+créée à l'aide d'un @code{#} sera interprétée comme étant de la musique.
+Elle ne sera cependant pas recopiée avant utilisation. Si la structure
+qui l'abrite devait être réutilisée, un appel expicite à
+@code{ly:music-deep-copy} pourrait être requis.
+
+@funindex $@@
+@funindex #@@
+
+Les opérateurs @code{$@@} et @code{#@@} agissent comme des « colleurs de
+liste » : leur fonction consiste à insérer tous les éléments d'un liste
+dans le contexte environnant.
Examinons à présent du vrai code Scheme. Nous pouvons définir des
-procédures Scheme au milieu d'un fichier source LilyPond@tie{}:
+procédures Scheme au milieu d'un fichier source LilyPond :
@example
#(define (moyenne a b c) (/ (+ a b c) 3))
celui-ci se trouve au sein d'un fichier LilyPond. Ceci tient au fait
que l'expression Scheme est lue par l'interpréteur Guile, et en aucune
façon par l'analyseur lexical de LilyPond. Voici comment introduire des
-commentaires dans votre code Scheme@tie{}:
+commentaires dans votre code Scheme :
@example
; ceci n'est qu'une simple ligne de commentaire
Dans la suite de notre propos, nous partons du principe que les données
sont incluses dans un fichier musical, aussi toutes les expressions
-Scheme seront introduites par un@code{#}.
+Scheme seront introduites par un @code{#}.
Toutes les expressions Scheme de haut niveau incluses dans un fichier
LilyPond peuvent se combiner en une expression Scheme unique à l'aide de
-la clause @code{begin}@tie{}:
+la clause @code{begin} :
@example
#(begin
@end example
@noindent
-est convertie, en interne, en une définition Scheme@tie{}:
+est convertie, en interne, en une définition Scheme :
@example
(define traLaLa @var{valeur Scheme de `@code{... }'})
#(define twice
(make-sequential-music newLa))
-{ \twice }
+\twice
@end lilypond
@c Due to parser lookahead
Cet exemple est particulièrement intéressant. L'assignation
n'interviendra qu'une fois que l'analyseur grammatical aura l'assurance
-que rien du type de @code{\addlyrics} ne suit@tie{}; il doit donc
+que rien du type de @code{\addlyrics} ne suit ; il doit donc
vérifier ce qui vient après. Le @emph{parser} lit le @code{#} et
l'expression Scheme qui le suit @strong{sans} l'évaluer, de telle sorte
qu'il peut procéder à l'assignation, et @strong{ensuite} exécuter le
code Scheme sans problème.
-Cet exemple illustre la manière @qq{d'exporter} une expression musicale
-à partir des saisies et à destination de l'interpréteur Scheme.
-L'inverse est aussi réalisable@tie{}: en la plaçant derrière
-un@tie{}@code{$}, une valeur Scheme sera interprétée comme si elle avait
-été saisie en syntaxe LilyPond. Au lieu de définir @code{\twice}, nous
-aurions tout aussi bien pu écrire
+
+@node Import de code Scheme dans LilyPond
+@subsection Import de code Scheme dans LilyPond
+@translationof Importing Scheme in LilyPond
+
+@funindex $
+@funindex #
+
+L'exemple précédent illustre la manière @qq{d'exporter} une expression
+musicale à partir des saisies et à destination de l'interpréteur Scheme.
+L'inverse est aussi réalisable : en la plaçant derrière un @code{$}, une
+valeur Scheme sera interprétée comme si elle avait été saisie en
+syntaxe LilyPond. Au lieu de définir @code{\twice}, nous aurions tout
+aussi bien pu écrire
@example
...
-@{ $(make-sequential-music (list newLa)) @}
+$(make-sequential-music (list newLa))
@end example
Vous pouvez utiliser @code{$} suivi d'une expression Scheme partout où
Cette manière de procéder comporte cependant un inconvénient au niveau
de la temporisation. Si nous avions défini @code{newLa} avec un
-@code{$} plutôt qu'un@tie{#}, la définition Scheme suivante aurait
-échoué du fait que @code{traLaLa} n'était pas encore définie. Pour plus
+@code{$} plutôt qu'un @code{#}, la définition Scheme suivante aurait
+échoué du fait que @code{traLaLa} n'était pas encore défini. Pour plus
d'information quant au problème de synchronisation, voir la rubrique
@ref{Syntaxe Scheme dans LilyPond}.
-En tout état de cause, le @emph{parser} évalue le code Scheme en
-dernier. S'il ne doit être exécuté que plus tard, consultez la rubrique
-@ref{Fonctions Scheme fantômes}, ou stockez le dans une macro comme
-ici@tie{}:
+@funindex $@@
+@funindex #@@
+
+Une autre façon de procéder serait de recourir aux « colleurs de liste »
+@code{$@@} et @code{#@@} dont la fonction est d'insérer les éléments
+d'une liste dans le contexte environnant. Grâce à ces opérateurs, la
+dernière partie de notre fonction pourrait s'écrire ainsi :
+
+@example
+...
+@{ #@@newLa @}
+@end example
+
+Ici, chaque élément de la liste stockée dans @code{newLa} est pris à
+son tour et inséré dans la liste, tout comme si nous avions écrit
+
+@example
+@{ #(premier newLa) #(deuxième newLa) @}
+@end example
+
+Dans ces deux dernières formes, le code Scheme est évalué alors même que
+le code initial est en cours de traitement, que ce soit par le
+@emph{lexer} ou par le @emph{parser}. Si le code Scheme ne doit être
+exécuté que plus tard, consultez la rubrique
+@ref{Fonctions Scheme fantômes}, ou stockez le dans une procédure comme
+ici :
@example
#(define (nopc)
La modification d'une valeur pour une propriété donnée requiert
l'assignation d'une valeur de la liste associative, tant pour la clé que
la valeur associée. Voici comment procéder selon la syntaxe de
-LilyPond@tie{}:
+LilyPond :
@example
-\override Stem #'thickness = #2.6
+\override Stem.thickness = #2.6
@end example
Cette instruction ajuste l'apparence des hampes. Une entrée
@w{@code{'(thickness . 2.6)}} de la @emph{alist} est ajoutée à la liste
de la propriété de l'objet @code{Stem}. @code{thickness} devant
s'exprimer en unité d'épaisseur de ligne, les hampes auront donc une
-épaisseur de 2,6@tie{}ligne de portée, et à peu près le double de leur
+épaisseur de 2,6 ligne de portée, et à peu près le double de leur
épaisseur normale. Afin de faire la distinction entre les variables que
vous définissez au fil de vos fichiers -- tel le @code{vingtQuatre} que
nous avons vu plus haut -- et les variables internes des objets, nous
(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é
Les fractions, tel que LilyPond les utilise, sont aussi stockées sous
forme de @emph{paire}. Alors que Scheme est tout à fait capable de
représenter des nombres rationnels, vous conviendrez que, musicalement
-parlant, @samp{2/4} et @samp{1/2} ne se valent pas@tie{}; nous devrons
+parlant, @samp{2/4} et @samp{1/2} ne se valent pas ; nous devrons
donc pouvoir les distinguer. Dans le même ordre d'idée, LilyPond ne
connaît pas les @qq{fractions} négatives. Pour ces raisons, @code{2/4}
en LilyPond correspond à @code{(2 . 4)} en Scheme, et @code{#2/4} en
un ensemble de nombres compris entre un minimum (le @code{car}) et un
maximum (le @code{cdr}). Ces intervalles stockent l'étendue, tant au
niveau horizontal (X) que vertical (Y) des objets imprimables. En
-matière d'étendue sur les X, le @code{car} correspond à la coordonnée de
+matière d'étendue sur les X, le @code{car} correspond à la coordonnée de
l'extrémité gauche, et le @code{cdr} à la coordonnée de l'extrémité
-droite. En matière d'étendue sur les Y, le @code{car} correspond à la
+droite. En matière d'étendue sur les Y, le @code{car} correspond à la
coordonnée de l'extrémité basse, et le @code{cdr} à la coordonnée de
l'extrémité haute.
nombres rationnels représentant la longueur d'un objet musical par
rapport à la ronde.
-Un objet musical dispose de trois types@tie{}:
+Un objet musical dispose de trois types :
@itemize
@item
-un nom de musique@tie{}: Toute expression musicale a un nom. Par
-exemple, une note amène à un @rinternals{NoteEvent}, un
-@code{\simultaneous} à un @rinternals{SimultaneousMusic}. Une liste
-exhaustive des différentes expressions est disponible dans la référence
-des propriétés internes, à la rubrique @rinternals{Music expressions}.
+un nom de musique : Toute expression musicale a un nom. Par exemple,
+une note amène à un @rinternals{NoteEvent}, un @code{\simultaneous} à un
+@rinternals{SimultaneousMusic}. Une liste exhaustive des différentes
+expressions est disponible dans la référence des propriétés internes, à
+la rubrique @rinternals{Music expressions}.
@item
-un @qq{type} ou interface@tie{}: Tout nom de musique dispose de
+un @qq{type} ou interface : Tout nom de musique dispose de
plusieurs types ou interfaces. Ainsi, une note est tout à la fois un
@code{event}, un @code{note-event}, un @code{rhythmic-event} et un
@code{melodic-event}. Les différentes classes musicales sont
des propriétés internes.
@item
-un objet C++@tie{}: Tout objet musical est représenté par un objet de la
+un objet C++ : Tout objet musical est représenté par un objet de la
classe C++ @code{Music}.
@end itemize
Une expression composite est un objet musical dont les propriétés
contiennent d'autres objets musicaux. S'il s'agit d'une liste d'objets,
elle sera stockée dans la propriété @code{elements} d'un objet
-musical@tie{}; s'il n'y a qu'un seul objet @qq{enfant}, il sera stocké
+musical ; s'il n'y a qu'un seul objet @qq{enfant}, il sera stocké
dans la propriété @code{element}. Ainsi, par exemple, les enfants de
@rinternals{SequentialMusic} iront dans @code{elements}, alors que
l'argument unique de @rinternals{GraceMusic} ira dans @code{element}.
Par défaut, LilyPond affichera ces messages sur la console, parmi toutes
les autres informations. Vous pouvez, afin de les isoler et de garder
le résultat des commandes @code{\display@{TRUC@}}, rediriger la sortie
-vers un fichier@tie{}:
+vers un fichier :
@example
lilypond file.ly >display.txt
Un peu de Scheme combiné à notre code LilyPond, et les seules
informations qui nous intéressent se retrouveront directement dans un
-fichier indépendant@tie{}:
+fichier indépendant :
@example
@{
- $(with-output-to-file "display.txt"
+ #(with-output-to-file "display.txt"
(lambda () #@{ \displayMusic @{ c'4\f @} #@}))
@}
@end example
-L'information sera encore plus lisible après un peu de mise en
-forme@tie{}:
+L'information sera encore plus lisible après un peu de mise en forme :
@example
(make-music 'SequentialMusic
@funindex{\void}
La fonction @code{\displayMusic} renvoie la musique qu'elle
-affiche@tie{}; celle-ci sera donc aussi interprétée. L'insertion d'une
+affiche ; celle-ci sera donc aussi interprétée. L'insertion d'une
commande @code{\void} avant le @code{\displayMusic} permet de
s'affranchir de la phase d'interprétation.
L'objet @code{NoteEvent} est la représentation brute de @code{someNote}.
Voyons ce qui se passe lorsque nous plaçons ce @notation{c'} dans une
-construction d'accord@tie{}:
+construction d'accord :
@example
someNote = <c'>
@code{'elements} de @code{someNote}.
@code{\displayMusic} utilise la fonction @code{display-scheme-music}
-pour afficher la représentation en Scheme d'une expression musicale@tie{}:
+pour afficher la représentation en Scheme d'une expression musicale :
@example
#(display-scheme-music (first (ly:music-property someNote 'elements)))
@end example
La hauteur de la note est accessible au travers de la propriété
-@code{'pitch} de l'objet @code{NoteEvent}@tie{}:
+@code{'pitch} de l'objet @code{NoteEvent} :
@example
#(display-scheme-music
(ly:make-pitch 0 5 0))))
@end example
-Mauvaise nouvelle@tie{}! Les expressions @code{SlurEvent} doivent
+Mauvaise nouvelle ! Les expressions @code{SlurEvent} doivent
s'ajouter @qq{à l'intérieur} de la note -- dans sa propriété
@code{articulations}.
-Examinons à présent la saisie@tie{}:
+Examinons à présent la saisie :
@example
\displayMusic a'
@noindent
mais, pour les besoins de la démonstration, nous allons voir comment
réaliser ceci en Scheme. Commençons par examiner une saisie simple et
-le résultat auquel nous désirons aboutir@tie{}:
+le résultat auquel nous désirons aboutir :
@example
% saisie
note-event)
@end example
-La première ligne est la manière de définir une fonction en
-Scheme@tie{}: la fonction Scheme a pour nom @code{ajoute-accent} et elle
-comporte une variable appelée @code{note-event}. En Scheme, le type
-d'une variable se déduit la plupart de temps de par son nom -- c'est
-d'ailleurs une excellente pratique que l'on retrouve dans de nombreux
-autres langages.
+La première ligne est la manière de définir une fonction en Scheme : la
+fonction Scheme a pour nom @code{ajoute-accent} et elle comporte une
+variable appelée @code{note-event}. En Scheme, le type d'une variable
+se déduit la plupart de temps de par son nom -- c'est d'ailleurs une
+excellente pratique que l'on retrouve dans de nombreux autres langages.
@example
"Ajoute un accent..."
Vous pouvez vous demander pourquoi nous modifions directement
l'événement note plutôt que d'en manipuler une copie -- on pourrait
utiliser @code{ly:music-deep-copy} à cette fin. La raison en est qu'il
-existe un contrat tacite@tie{}: les fonctions musicales sont autorisées
+existe un contrat tacite : les fonctions musicales sont autorisées
à modifier leurs arguments -- ils sont générés en partant de zéro (comme
les notes que vous saisissez) ou déjà recopiés (faire référence à une
variable musicale avec @samp{\name} ou à de la musique issue
Cette fonction n'étant pas une fonction musicale à part entière, elle
peut s'utiliser dans d'autres fonctions musicales. Il est donc sensé de
-respecter le même contrat que pour les fonctions musicales@tie{}:
+respecter le même contrat que pour les fonctions musicales :
l'entrée peut être modifiée pour arriver à une sortie, et il est de la
responsabilité de l'appelant d'effectuer des copies s'il a réellement
besoin de l'argument dans son état originel. Vous constaterez, à la
musicales -- les @code{'articulations}, @code{'duration}, @code{'pitch}
etc. que @code{\displayMusic} nous a indiquées. La nouvelle valeur sera
l'ancienne propriété @code{'articulations}, augmentée d'un
-élément@tie{}: l'expression @code{ArticulationEvent}, que nous
+élément : l'expression @code{ArticulationEvent}, que nous
recopions à partir des informations de @code{\displayMusic}.
@example
@code{cons} permet d'ajouter un élément en tête de liste sans pour
autant modifier la liste originale. C'est exactement ce que nous
-recherchons@tie{}: la même liste qu'auparavant, plus la nouvelle
+recherchons : la même liste qu'auparavant, plus la nouvelle
expression @code{ArticulationEvent}. L'ordre au sein de la propriété
@code{'articulations} n'a ici aucune importance.
note-event)
@end example
-Par acquis de conscience, vérifions que tout ceci fonctione@tie{}:
+Par acquis de conscience, vérifions que tout ceci fonctione :
@example
\displayMusic \ajouteAccent c4
-
-
@ignore
@menu
* Tweaking with Scheme::
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''' {
@lilypond[quote,verbatim,ragged-right]
tempoPadded = #(define-music-function (parser location padding tempotext)
- (number? string?)
+ (number? markup?)
#{
- \once \override Score.MetronomeMark #'padding = $padding
+ \once \override Score.MetronomeMark.padding = #padding
\tempo \markup { \bold #tempotext }
#})
\relative c'' {
\tempo \markup { "Low tempo" }
c4 d e f g1
- \tempoPadded #4.0 #"High tempo"
+ \tempoPadded #4.0 "High tempo"
g4 f e d c1
}
@end lilypond
@lilypond[quote,verbatim,ragged-right]
pattern = #(define-music-function (parser location x y) (ly:music? ly:music?)
#{
- $x e8 a b $y b a e
+ #x e8 a b $y b a e
#})
\relative c''{
projects / lilypond.git / blobdiff