@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@ignore
- Translation of GIT committish: 3c62ac104645533873bba800f7b0f371089f535a
+ Translation of GIT committish: e8c4826ed3fca952984600bcce60b53e76aff5d2
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.19.22"
@c Translators: Jean-Charles Malahieude
@cindex Scheme
@cindex GUILE
-@cindex Scheme, in-line code
-@cindex accessing Scheme
-@cindex evaluating Scheme
+@cindex Scheme, inclusion de code
+@cindex accéder à Scheme
+@cindex évaluation Scheme
@cindex LISP
LilyPond recourt abondamment au langage de programmation Scheme, tant au
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 « 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
-standard Scheme @qq{R5RS} est quant à lui disponible à la page
+Guile à la page @uref{http://www.gnu.org/software/guile/} ; le
+standard Scheme « R5RS » est quant à lui disponible à la page
@uref{http://www.schemers.org/Documents/Standards/R5RS/}.
@menu
@translationof Introduction to Scheme
Nous commencerons par nous intéresser à Scheme et à son fonctionnement,
-grâce à l'interpréteur GUILE. Une fois plus à l'aise avec Scheme, nous
+grâce à l'interpréteur Guile. Une fois plus à l'aise avec Scheme, nous
verrons comment ce langage peut s'intégrer à un fichier LilyPond.
@menu
@translationof Scheme sandbox
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
+La plupart des systèmes disposent d'un « bac à sable » Scheme pour
+effectuer des tests ; vous y accéderez en tapant @code{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
l'installation de LilyPond -- pour connaître le chemin complet d'accès à
ce répertoire, consultez @rlearning{Autres sources de documentation}.
-Les utilisateurs de Windows peuvent aussi prendre l'option @qq{Exécuter}
-à partir du menu @qq{Démarrer} puis taper @qq{guile}.
+Les utilisateurs de Windows peuvent aussi prendre l'option « Exécuter »
+à partir du menu « Démarrer » puis taper @code{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
Vous pouvez dès à présent saisir des expressions Scheme pour vous
-exercer. Si vous souhaitez pourvoir utiliser la bibliothèque GNU
+exercer. Si vous souhaitez pouvoir utiliser la bibliothèque GNU
@code{readline}, qui offre une ligne de commande plus élaborée,
consultez les informations contenues dans le fichier
@file{ly/scheme-sandbox.ly}. La bibliothèque @var{readline}, dans la
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)
Vous aurez remarqué que la valeur @code{2} et l'invite @code{guile}
apparaissent sur une même ligne. On peut améliorer la présentation à
l'aide de la procédure @code{newline} ou bien en affichant un caractère
-@qq{retour chariot}.
+« retour chariot ».
@lisp
guile> (display a)(newline)
@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)
@translationof Scheme simple data types
L'un des concepts de base de tout langage est la saisie de données,
-qu'il s'agisse de nombres, de chaînes de caractères, de listes etc.
+qu'il s'agisse de nombres, de chaînes de caractères, de listes, etc.
Voici les différents types de données Scheme simples utilisées
couramment dans LilyPond.
@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 su plusieurs lignes@tie{}:
+Une chaîne peut s'étendre sur plusieurs lignes :
@example
"ceci
@end table
-Il existe bien d'autres types de donnée Scheme, dont nous ne parlerons
+Il existe bien d'autres types de données Scheme, dont nous ne parlerons
pas ici. Vous en trouverez une liste exhaustive dans le guide de
référence de Guile, à la page
@uref{http://www.gnu.org/software/guile/manual/html_node/Simple-Data-Types.html}.
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
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)
@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 « 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@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 « correcte » se définit comme étant vide (représentée par
+@code{'()} et de longueur 0) 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")
Les listes ont une importance considérable en Scheme. Certains vont
d'ailleurs jusqu'à considérer Scheme comme un dialecte du lisp, où
-@qq{lisp} serait une abréviation de @qq{List Processing}. Il est vrai
+« lisp » serait une abréviation de « List Processing ». Il est vrai
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@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")))
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
guile>
@end lisp
+
@node Scheme et les calculs
@subsection Scheme et les calculs
@translationof Calculations in Scheme
@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}).
+a donc renvoyé l'erreur « Wrong type to apply: 1 » (@emph{Application
+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
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}@tie{}:
+@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
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)
@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
+un « 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))
@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
@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))
-... (+ (* 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
-Scheme dispose d'une procédure @code{if}@tie{}:
+
+@node if
+@unnumberedsubsubsec if
+@translationof if
+
+Scheme dispose d'une procédure @code{if} :
@example
(if expression-test expression-affirmative expression-négative)
@end example
@var{expression-test} est une expression qui renverra une valeur
-booléenne. Dans le cas où @var{expression-test} retourne @code{#t}, la
+booléenne. Dans le cas où @var{expression-test} retourne @code{#t}, la
procédure @code{if} renvoie la valeur de @var{expression-affirmative},
et celle de @var{expression-négative} dans le cas contraire.
@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}@tie{}:
+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
-Comme par exemple ici@tie{}:
+Comme par exemple ici :
@lisp
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
* 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::
expressions, tout comme le langage humain est structuré en mots et
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
+hauteurs, etc. -- ainsi que d'un analyseur syntaxique (appelé
+@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.
Le recours à un @emph{hash} pour mettre en exergue du Scheme est tout à
-fait approprié. Dès qu'il rencontre un @code{#}, l'analyseur lexical
+fait approprié. Dès qu'il rencontre un @code{#}, l'analyseur lexical
passe le relais au lecteur Scheme qui va alors déchiffrer l'intégralité
de l'expression Scheme -- ce peut être un identificateur, une expression
bornée par des parenthèses ou bien d'autres choses encore. Une fois
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'une 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))
@end example
Pour mémoire, vous noterez que les commentaires LilyPond (@code{%} ou
-@code{%@{ %@}}) ne peuvent s'utiliser dans du code Scheme, même si
+@code{%@{…%@}}) ne peuvent s'utiliser dans du code Scheme, même si
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
internes de LilyPond y compris les expressions musicales, aura pour
effet d'en recopier la valeur, les fonctions musicales n'ont pas pour
habitude de créer une copie du matériau qu'elles vont modifier. De
-fait, une expression musicale introduite par @code{#} de devrait pas
+fait, une expression musicale introduite par @code{#} ne devrait pas
contenir de matériau inexistant auparavant ou bien littéralement
recopié, mais plutôt une référence explicite.
@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 traLaLa @var{valeur Scheme de `@code{@dots{}}'})
@end example
Cela signifie que variables LilyPond et variables Scheme peuvent tout à
#(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
-vérifier ce qui vient après. Le @emph{parser} lit le @code{#} et
+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 « 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)) @}
+@dots{}
+$(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
+@dots{}
+@{ #@@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)
(ly:set-option 'point-and-click #f))
-...
+@dots{}
#(nopc)
@{ c'4 @}
@end example
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{}:
+pour la valeur associée. Voici comment procéder selon la syntaxe de
+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
-parlerons de @qq{propriétés} pour ces dernières, et de @qq{variables}
+parlerons de « propriétés » pour ces dernières, et de « variables »
pour les autres. Ainsi, l'objet hampe possède une propriété
@code{thickness}, alors que @code{vingtQuatre} est une variable.
@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
+Les fractions, telles 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}
+connaît pas les « fractions » négatives. Pour ces raisons, @code{2/4}
en LilyPond correspond à @code{(2 . 4)} en Scheme, et @code{#2/4} en
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
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
+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
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.
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é.
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 « 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
forme de propriétés. Par exemple, un @rinternals{NoteEvent} dispose des
propriétés @code{pitch} et @code{duration}, respectivement chargées de
stocker la hauteur et la durée de cette note. Les différentes
-propriétés sont répertoriées à la rubrique
-@rinternalsnamed{Music properties,Music properties}
+propriétés sont répertoriées à la rubrique @rinternals{Music properties}
de la référence des propriétés internes.
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 « 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}.
'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
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{}:
+le résultat des commandes @code{\display@{TRUC@}}, spécifier un
+port optionnel à utiliser pour la sortie :
@example
-lilypond file.ly >display.txt
+@{
+ \displayMusic #(open-output-file "display.txt") @{ c'4\f @}
+@}
@end example
-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{}:
+Ceci aura pour effet d'écraser tout fichier précédemment généré.
+Lorsque plusieurs expressions doivent être retranscrites, il suffit de
+faire appel à une variable pour le port puis de la réutiliser :
@example
@{
- $(with-output-to-file "display.txt"
- (lambda () #@{ \displayMusic @{ c'4\f @} #@}))
+ port = #(open-output-file "display.txt")
+ \displayMusic \port @{ c'4\f @}
+ \displayMusic \port @{ d'4 @}
+ #(close-output-port port)
@}
@end example
-L'information sera encore plus lisible après un peu de mise en
-forme@tie{}:
+La documentation de Guile fournit une description détaillée des ports.
+Clôturer un port n'est requis que si vous désirez consulter le fichier
+avant que LilyPond n'ait fini, ce dont nous ne nous sommes pas préoccupé
+dans le premier exemple.
+
+L'information sera encore plus lisible après un peu de mise en forme :
@example
(make-music 'SequentialMusic
(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
@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.
Nous abordons ici les propriétés @emph{music}, et non pas les propriétés
@emph{context} ou @emph{layout}.
-Partons de cet exemple simple@tie{}:
+Partons de cet exemple simple :
@example
someNote = c'
(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
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'>
(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
@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)))
(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
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
@end example
La hauteur de la note se modifie en définissant sa propriété
-@code{'pitch}@tie{}:
+@code{'pitch} :
@funindex \displayLilyMusic
(ly:make-pitch 0 1 0)) ;; set the pitch to d'.
\displayLilyMusic \someNote
===>
-d'
+d'4
@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
-Mauvaise nouvelle@tie{}! Les expressions @code{SlurEvent} doivent
-s'ajouter @qq{à l'intérieur} de la note -- dans sa propriété
+Mauvaise nouvelle ! Les expressions @code{SlurEvent} doivent
+s'ajouter « à 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'
(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?)
+doubleSlur = #(define-music-function (note) (ly:music?)
"Renvoie : @{ note ( note ) @}.
`note' est censé être une note unique."
(let ((note2 (ly:music-deep-copy note)))
@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
@noindent
n'est pas admis par LilyPond. Nous pourrions tout à fait contourner ce
-problème en attachant l'articulation à une @qq{fausse} note,
+problème en attachant l'articulation à un accord vide,
@example
-@{ << \musique s1*0-.-> @}
+@{ << \musique <> -. -> >> @}
@end example
@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
(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
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..."
+"Ajoute un accent@dots{}"
@end example
@noindent
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
répétitions se devait d'être une copie. Dans le cas contraire,
certaines bizarreries auraient pu survenir. Par exemple, la présence
d'un @code{\relative} ou d'un @code{\transpose}, après plusieurs
-répétitions du même élément, entraînerait des @qq{relativisations} ou
+répétitions du même élément, entraînerait des « relativisations » ou
transpositions en cascade. Si nous les assignons à une variable
musicale, l'enchaînement est rompu puisque la référence à @samp{\nom}
créera une nouvelle copie sans toutefois prendre en considération
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
lecture des fonctions propres à LilyPond, comme @code{music-map}, que ce
principe est toujours respecté.
-Revenons à nos moutons@dots{} Nous disposons maintenant d'un
-@code{note-event} que nous pouvons modifier, non pas grâce à un
-@code{ly:music-deep-copy}, mais plutôt en raison de notre précédente
-réflexion. Nous ajoutons @notation{l'accent} à la liste de ses
-propriétés @code{'articulations}.
+Revenons à nos moutons… Nous disposons maintenant d'un @code{note-event}
+que nous pouvons modifier, non pas grâce à un @code{ly:music-deep-copy},
+mais plutôt en raison de notre précédente réflexion. Nous ajoutons
+@notation{l'accent} à la liste de ses propriétés @code{'articulations}.
@example
(set! emplacement nouvelle-valeur)
@end example
La fonction @code{ly:music-property} permet d'accéder aux propriétés
-musicales -- les @code{'articulations}, @code{'duration}, @code{'pitch}
+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.
Nous pouvons à présent transformer la fonction @code{ajoute-accent} en
fonction musicale, à l'aide d'un peu d'enrobage syntaxique et mention du
-type de son unique argument @qq{réel}.
+type de son unique argument « réel ».
@example
-ajouteAccent = #(define-music-function (parser location note-event)
+ajouteAccent = #(define-music-function (note-event)
(ly:music?)
"Ajoute un accent (ArticulationEvent) aux articulations de `note-event',
qui est censé être une expression NoteEvent."
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}.
@ignore
@lilypond[quote,verbatim,ragged-right]
-padText = #(define-music-function (parser location padding) (number?)
+padText = #(define-music-function (padding) (number?)
#{
- \once \override TextScript #'padding = #padding
+ \once \override TextScript.padding = #padding
#})
-\relative c''' {
- c4^"piu mosso" b a b
+\relative {
+ c'''4^"piu mosso" b a b
\padText #1.8
c4^"piu mosso" d e f
\padText #2.6
@lilypond[quote,verbatim,ragged-right]
-tempoPadded = #(define-music-function (parser location padding tempotext)
- (number? string?)
+tempoPadded = #(define-music-function (padding tempotext)
+ (number? markup?)
#{
- \once \override Score.MetronomeMark #'padding = $padding
+ \once \override Score.MetronomeMark.padding = #padding
\tempo \markup { \bold #tempotext }
#})
-\relative c'' {
+\relative {
\tempo \markup { "Low tempo" }
- c4 d e f g1
- \tempoPadded #4.0 #"High tempo"
+ c''4 d e f g1
+ \tempoPadded #4.0 "High tempo"
g4 f e d c1
}
@end lilypond
Even music expressions can be passed in:
@lilypond[quote,verbatim,ragged-right]
-pattern = #(define-music-function (parser location x y) (ly:music? ly:music?)
+pattern = #(define-music-function (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