Re: Traduction

[Valentin Villenave]

Le 3 novembre 2008 18:39, Viviane Sourdine <address@hidden> a écrit :
> Bonjour,

Bonjour,

> Pour y voir un peu plus clair dans les commandes complexes, je me suis
> lancée tout doucement dans la traduction du tutoriel Scheme et du chapitre
> 12.

Saine attitude, malheureusement peut-être prématurée : cette partie
doit être entièrement réécrite dans les mois à venir. Auquel cas la
traduction deviendrait caduque.

> Interfaces pour programmeurs:
>
>     Vue d'ensemble des fonctions musicales:
>
>         Faire une fonction qui substitue une variable au code LilyPond est
> facile. La forme générale de ces fonctions est:

Omission : "into"

 ===> "une fonction qui remplace une variable par du code LilyPond "

>     function = #(define-music-function (parser location var1 var2... )
>                           (var1-type? var2-type?...)
>                #(
>                 ... music...
>             #})
>
>     A cet endroit un petit exemple serait le bienvenu ;-) , d'autant plus
> que je n'ai pas trouvé dans mon dictionnaire le mot "parser", et que je ne
> comprends pas ce que vient faire une accolade juste après le dernier signe #


Personellement, je traduis par "parseur". Mais en l'occurence, il ne
faut _pas_ traduire du tout : (parser location) est *la* syntaxe
canonique d'une music-function.

Les #{ #} servent à inclure du code LilyPond traditionnel à
l'intérieur d'une expression Scheme. J'y reviens dans un instant.

> argi               "ith" variable      Comment traduire argi et  "ith"
> (peut-être argument i où
>                                             i remplace n'importe quoi?)
> argi-type?       type de variable  (i?)
> ...music...      Entrée normale LilyPond, utilisant les variables comme
> #$var1.

OK pour remplacer la lettre i par la lettre n, comme le suggère Jean-Côme.

> Les types d'entrées suivants peuvent être utilisés comme variables dans une
> fonction musicale. Cette liste n'est pas exhaustive; voir d'autres
> documentations spécifiques à propos du Scheme pour plus de types de
> variables.

Les "types" suivants [laissez tomber "input", traduisez-le par un verbe]

> Type d'entrées        argi-type? notation
> Entier                                       integer?
> Float (nombre décimal)              number?    Dictionnaire pour "float" :
> flotteur,
>                                                radeau, bouchon, char ;-)...
> Je mets quoi?

Décimal.

> Chaines de caractères (mots)    string?

Oui, chaîne de caractères.

> Markup                                    markup?    Quelle traduction pour
> markup?

markup. Je sais qu'on a traduit par "étiquettes" dans la doc française
mais je pense qu'on va revenir au terme markup.

> Expression musicale                 ly:music?
> Une paire de variables               pair?

Paire de nombres, il me semble.

> Les arguments  "parser" et "location" (emplacement?) sont obligatoires, et
> sont utilisés dans quelques situations plus poussées. L'argument "parser"
> est utilisé pour accéder à la valeur d'une autre variable LilyPond.
> L'argument "location" est utilisé pour (spécifier?) "l'origine" de
> l'expression musicale qui est construite par la fonction musique, afin que,
> en cas d'une erreur de syntaxe, LilyPond puisse prévenir l'utilisateur de
> regarder dans le fichier d'entrée une place appropriée.

Ça me paraît très bien. (sans traduire "parser" et "location", encore une fois)

Le principe d'une music-function (fonction de substitution) est le suivant :

si je veux souvent mettre des hampes en couleur, je peux utiliser un raccourci :

rouge = {
  \once \override Stem #'color = #(rgb-color 1 0 0)
}

Par contre, si je veux faire un raccourci pour faire des triolets,
cela ne marchera pas :

triolet = {
  \times 2/3
}

car la construction \times 2/3 se rattache directement aux notes qui
la suivent : elle prend un _argument_.

je vais donc devoir créer une fonction qui remplacera
\triolet { des notes}
par
\times 2/3 {les mêmes notes}


Donc, allons-y :

triolet =
#(define-music-function (parser location mes-notes) (ly:music?)
#{ \times 2/3 $mes-notes #})

et voilà :

\triolet  {do re mi}

Le premier # indique à LilyPond que cette fonction n'est pas à
intérpréter comme de la musique normale, mais comme du code Scheme.
les parenthèses délimitent les différentes expressions Scheme.
le #{ #} délimite le fragment de code que LilyPond va insérer.

Je vous invite à jeter un coup d'oeil, par exemple, à ce snippet qui
reprend mon exemple (c'est celui-là même qui m'a appris à coder ces
fonctions) :
http://lsr.dsi.unimi.it/LSR/Item?id=328

Et pour la traduction, encore une fois, pas d'urgence. par contre, si
vous voulez reformuler ces explications de façon plus simple et
progressive (en français ou en anglais), cela me sera utile lorsque
l'on réécrira ce chapitre -- il y a des chances pour que ce soit moi
qui m'y colle, d'ailleurs.

Cordialement,
Valentin