1 @c -*- coding: utf-8; mode: texinfo; documentlanguage: es -*-
4 Translation of GIT committish: 3025442087de8dd3f88736290887ced86e360c25
6 When revising a translation, copy the HEAD committish of the
7 version that you are working on. For details, see the Contributors'
8 Guide, node Updating translation committishes..
13 @node Tutorial de Scheme
14 @appendix Tutorial de Scheme
15 @translationof Scheme tutorial
19 @cindex Scheme, código en línea
20 @cindex acceder a Scheme
21 @cindex evaluar Scheme
24 LilyPond utiliza el lenguaje de programación Scheme, tanto como
25 parte de la sintaxis del código de entrada, como para servir de
26 mecanismo interno que une los módulos del programa entre sí. Esta
27 sección es una panorámica muy breve sobre cómo introducir datos en
28 Scheme. Si quiere saber más sobre Scheme, consulte
29 @uref{http://@/www@/.schemers@/.org}.
31 LilyPond utiliza la implementación GNU Guile de Scheme, que está
32 basada en el estándar @qq{R5RS} del lenguaje. Si está aprendiendo
33 Scheme para usarlo con LilyPond, no se recomienda trabajar con una
34 implementación distinta (o que se refiera a un estándar
35 diferente). Hay información sobre Guile en
36 @uref{http://www.gnu.org/software/guile/}. El estándar de Scheme
37 @qq{R5RS} se encuentra en
38 @uref{http://www.schemers.org/Documents/Standards/R5RS/}.
41 * Introducción a Scheme::
42 * Scheme dentro de LilyPond::
43 * Construir funciones complicadas::
46 @node Introducción a Scheme
47 @section Introducción a Scheme
48 @translationof Introduction to Scheme
50 Comenzaremos con una introducción a Scheme. Para esta breve
51 introducción utilizaremos el intérprete GUILE para explorar la
52 manera en que el lenguaje funciona. Una vez nos hayamos
53 familiarizado con Scheme, mostraremos cómo se puede integrar el
54 lenguaje en los archivos de LilyPond.
58 * Cajón de arena de Scheme::
59 * Variables de Scheme::
60 * Tipos de datos simples de Scheme::
61 * Tipos de datos compuestos de Scheme::
62 * Cálculos en Scheme::
63 * Procedimientos de Scheme::
64 * Condicionales de Scheme::
67 @node Cajón de arena de Scheme
68 @subsection Cajón de arena de Scheme
69 @translationof Scheme sandbox
71 La instalación de LilyPond incluye también la de la implementación
72 Guile de Scheme. Sobre casi todos los sistemas puede experimentar
73 en una @qq{caja de arena} de Scheme abriendo una ventana del
74 terminal y tecleando @q{guile}. En algunos sistemas, sobre todo
75 en Windows, podría necesitar ajustar la variable de entorno
76 @code{GUILE_LOAD_PATH} a la carpeta @code{../usr/share/guile/1.8}
77 dentro de la instalación de LilyPond (para conocer la ruta
78 completa a esta carpeta, consulte @rlearning{Otras fuentes de
79 información}). Como alternativa, los usuarios de Windows pueden
80 seleccionar simplemente @q{Ejecutar} del menú Inicio e introducir
83 Sin embargo, está disponible un cajón de arena de Scheme listo
84 para funcionar con todo LilyPond cargado, con esta instrucción de
87 lilypond scheme-sandbox
91 Una vez está funcionando el cajón de arena, verá un indicador del
98 Podemos introducir expresiones de Scheme en este indicador para
99 experimentar con Scheme. Si quiere usar la biblioteca readline de
100 GNU para una más cómoda edición de la línea de órdenes de Scheme,
101 consulte el archivo @file{ly/scheme-sandbox.ly} para más
102 información. Si ya ha activado la biblioteca readline para las
103 sesiones de Guile interactivas fuera de LilyPond, debería
104 funcionar también en el cajón de arena.
106 @node Variables de Scheme
107 @subsection Variables de Scheme
108 @translationof Scheme variables
110 Las variables de Scheme pueden tener cualquier valor válido de
111 Scheme, incluso un procedimiento de Scheme.
113 Las variables de Scheme se crean con @code{define}:
120 Las variables de Scheme se pueden evaluar en el indicador del
121 sistema de guile, simplemente tecleando el nombre de la variable:
129 Las variables de Scheme se pueden imprimir en la pantalla
130 utilizando la función display:
138 Observe que el valor @code{2} y el indicador del sistema
139 @code{guile} se muestran en la misma línea. Esto se puede evitar
140 llamando al procedimiento de nueva línea o imprimiendo un carácter
144 guile> (display a)(newline)
146 guile> (display a)(display "\n")
151 Una vez que se ha creado una variable, su valor se puede modificar
155 guile> (set! a 12345)
161 @node Tipos de datos simples de Scheme
162 @subsection Tipos de datos simples de Scheme
163 @translationof Scheme simple data types
165 El concepto más básico de un lenguaje son sus tipos de datos:
166 números, cadenas de caracteres, listas, etc. He aquí una lista de
167 los tipos de datos que son de relevancia respecto de la entrada de
172 Los valores Booleanos son Verdadero y Falso. Verdadero en Scheme es
173 @code{#t} y Falso es @code{#f}.
178 Los números se escriben de la forma normal, @code{1} es el número
179 (entero) uno, mientras que @w{@code{-1.5}} es un número en coma
180 flotante (un número no entero).
183 Las cadenas se encierran entre comillas:
189 Las cadenas pueden abarcar varias líneas:
198 y los caracteres de nueva línea al final de cada línea se
199 incluirán dentro de la cadena.
201 Los caracteres de nueva línea también se pueden añadir mediante la
202 inclusión de @code{\n} en la cadena.
205 "esto\nes una\ncadena de varias líneas"
209 Las comillas dobles y barras invertidas se añaden a las cadenas
210 precediéndolas de una barra invertida. La cadena @code{\a dijo
211 "b"} se introduce como
219 Existen más tipos de datos de Scheme que no se estudian aquí.
220 Para ver un listado completo, consulte la guía de referencia de
222 @uref{http://www.gnu.org/software/guile/manual/html_node/Simple-Data-Types.html}.
224 @node Tipos de datos compuestos de Scheme
225 @subsection Tipos de datos compuestos de Scheme
226 @translationof Scheme compound data types
228 También existen tipos de datos compuestos en Scheme. Entre los
229 tipos más usados en la programación de LilyPond se encuentran las
230 parejas, las listas, las listas-A y las tablas de hash.
235 * Listas asociativas (listas-A)::
240 @unnumberedsubsubsec Parejas
243 El tipo fundacional de datos compuestos de Scheme es la
244 @code{pareja}. Como se espera por su nombre, una pareja son dos
245 valores unidos en uno solo. El operador que se usa para formar
246 una pareja se llama @code{cons}.
254 Observe que la pareja se imprime como dos elementos rodeados por
255 paréntesis y separados por un espacio, un punto (@code{.}) y otro
256 espacio. El punto @emph{no es} un punto decimal, sino más bien un
259 Las parejas también se pueden introducir como valores literales
260 precediéndolos de un carácter de comilla simple o apóstrofo.
268 Los dos elementos de una pareja pueden ser cualquier valor válido
274 guile> '("bla-bla" . 3.1415926535)
275 ("bla-bla" . 3.1415926535)
279 Se puede accede al primero y segundo elementos de la pareja
280 mediante los procedimientos de Scheme @code{car} y @code{cdr},
284 guile> (define mipareja (cons 123 "Hola")
286 guile> (car mipareja)
288 guile> (cdr mipareja)
295 Nota: @code{cdr} se pronuncia "could-er", según Sussman y Abelson,
297 @uref{http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-14.html#footnote_Temp_133}
300 @unnumberedsubsubsec Listas
303 Una estructura de datos muy común en Scheme es la
304 @emph{lista}. Formalmente, una lista @q{bien hecha} se define como
305 la lista vacía, representada como @code{'()} y con longitud cero,
306 o bien como una pareja cuyo @code{cdr} es a su vez una lista más
309 Existen muchas formas de crear listas. Quizá la más común es con
310 el procedimiento @code{list}:
313 guile> (list 1 2 3 "abc" 17.5)
317 La representación de una lista como elementos individuales
318 separados por espacios y encerrada entre paréntesis es realmente
319 una forma compacta de las parejas con punto que constituyen la
320 lista, donde el punto e inmediatamente un paréntesis de apertura
321 se suprimen junto al paréntesis de cierre correspondiente. Sin
322 esta compactación, la salida habría sido
324 (1 . (2 . (3 . ("abc" . (17.5 . ())))))
327 De igual forma que con la salida, una lista puede escribirse
328 (después de haber añadido un apóstrofo para evitar su
329 interpretación como una llamada de función) como una lista literal
330 encerrando sus elementos entre paréntesis:
333 guile> '(17 23 "fulano" "mengano" "zutano")
334 (17 23 "fulano" "mengano" "zutano")
337 Las listas son una parte fundamental de Scheme. De hecho, Scheme
338 se considera un dialecto de Lisp, donde @q{lisp} es una
339 abreviatura de @q{List Processing} (proceso de listas). Todas las
340 expresiones de Scheme son listas.
343 @node Listas asociativas (listas-A)
344 @unnumberedsubsubsec Listas asociativas (listas-A)
345 @translationof Association lists (alists)
347 Un tipo especial de listas son las @emph{listas asociativas} o
348 @emph{listas-A}. Se puede usar una lista-A para almacenar datos
349 para su fácil recuperación posterior.
351 Las listas-A son listas cuyos elementos son parejas. El
352 @code{car} de cada elemento se llama @emph{clave}, y el @code{cdr}
353 de cada elemento se llama @emph{valor}. El procedimiento de
354 Scheme @code{assoc} se usa para recuperar un elemento de la
355 lista-A, y @code{cdr} se usa para recuperar el valor:
358 guile> (define mi-lista-a '((1 . "A") (2 . "B") (3 . "C")))
360 ((1 . "A") (2 . "B") (3 . "C"))
361 guile> (assoc 2 mi-lista-a)
363 guile> (cdr (assoc 2 mi-lista-a))
368 Las listas-A se usan mucho en LilyPond para almacenar propiedades
373 @unnumberedsubsubsec Tablas de hash
374 @translationof Hash tables
376 Estructuras de datos que se utilizan en LilyPond de forma
377 ocasional. Una tabla de hash es similar a una matriz, pero los
378 índices de la matriz pueden ser cualquier tipo de valor de Scheme,
381 Las tablas de hash son más eficientes que las listas-A si hay una
382 gran cantidad de datos que almacenar y los datos cambian con muy
385 La sintaxis para crear tablas de hash es un poco compleja, pero
386 veremos ejemplos de ello en el código fuente de LilyPond.
389 guile> (define h (make-hash-table 10))
392 guile> (hashq-set! h 'key1 "val1")
394 guile> (hashq-set! h 'key2 "val2")
396 guile> (hashq-set! h 3 "val3")
400 Los valores se recuperan de las tablas de hash mediante
404 guile> (hashq-ref h 3)
406 guile> (hashq-ref h 'key2)
411 Las claves y los valores se recuperan como una pareja con
412 @code{hashq-get-handle}. Ésta es la forma preferida, porque
413 devuelve @code{#f} si no se encuentra la clave.
416 guile> (hashq-get-handle h 'key1)
418 guile> (hashq-get-handle h 'frob)
423 @node Cálculos en Scheme
424 @subsection Cálculos en Scheme
425 @translationof Calculations in Scheme
428 Todo el tiempo hemos estado usando listas. Un cálculo, como @code{(+
429 1 2)} también es una lista (que contiene el símbolo @code{+} y los
430 números 1 y@tie{}2). Normalmente, las listas se interpretan como
431 cálculos, y el intérprete de Scheme sustituye el resultado del
432 cálculo. Para escribir una lista, detenemos la evaluación. Esto se
433 hace precediendo la lista por un apóstrofo @code{'}. Así, para los
434 cálculos no usamos ningún apóstrofo.
436 Dentro de una lista o pareja precedida de apóstrofo, no hay necesidad
437 de escribir ningún apóstrofo más. Lo siguiente es una pareja de
438 símbolos, una lista de símbolos y una lista de listas respectivamente:
442 #'(staff clef key-signature)
447 Scheme se puede usar para hacer cálculos. Utiliza sintaxis
448 @emph{prefija}. Sumar 1 y@tie{}2 se escribe como @code{(+ 1 2)} y
449 no como el tradicional @math{1+2}.
456 Los cálculos se pueden anidar; el resultado de una función se
457 puede usar para otro cálculo.
464 Estos cálculos son ejemplos de evaluaciones; una expresión como
465 @code{(* 3 4)} se sustituye por su valor @code{12}.
467 Los cálculos de Scheme son sensibles a las diferencias entre
468 enteros y no enteros. Los cálculos enteros son exactos, mientras
469 que los no enteros se calculan con los límites de precisión
479 Cuando el intérprete de Scheme encuentra una expresión que es una
480 lista, el primer elemento de la lista se trata como un
481 procedimiento a evaluar con los argumentos del resto de la lista.
482 Por tanto, todos los operadores en Scheme son operadores prefijos.
484 Si el primer elemento de una expresión de Scheme que es una lista
485 que se pasa al intérprete @emph{no es} un operador o un
486 procedimiento, se produce un error:
495 <unnamed port>:52:1: In expression (1 2 3):
496 <unnamed port>:52:1: Wrong type to apply: 1
501 Aquí podemos ver que el intérprete estaba intentando tratar el 1
502 como un operador o procedimiento, y no pudo hacerlo. De aquí que
503 el error sea "Wrong type to apply: 1".
505 Así pues, para crear una lista debemos usar el operador de lista,
506 o podemos precederla de un apóstrofo para que el intérprete no
517 Esto es un error que puede aparecer cuando trabaje con Scheme
521 La misma asignación se puede hacer también completamente en Scheme,
524 #(define veintiCuatro (* 2 doce))
527 @c this next section is confusing -- need to rewrite
529 El @emph{nombre} de una variable también es una expresión, similar a
530 un número o una cadena. Se introduce como
537 @cindex comillas en Scheme
539 El apóstrofo @code{'} evita que el intérprete de Scheme sustituya
540 @code{veintiCuatro} por @code{24}. En vez de esto, obtenemos el
541 nombre @code{veintiCuatro}.
545 @node Procedimientos de Scheme
546 @subsection Procedimientos de Scheme
547 @translationof Scheme procedures
549 Los procedimientos de Scheme son expresiones de Scheme ejecutables
550 que devuelven un valor resultante de su ejecución. También pueden
551 manipular variables definidas fuera del procedimiento.
554 * Definir procedimientos::
556 * Valores de retorno::
559 @node Definir procedimientos
560 @unnumberedsubsubsec Definir procedimientos
561 @translationof Defining procedures
563 Los procedimientos se definen en Scheme con @code{define}:
566 (define (nombre-de-la-función arg1 arg2 ... argn)
567 expresión-de-scheme-que-devuelve-un-valor)
570 Por ejemplo, podemos definir un procedimiento para calcular la
574 guile> (define (media x y) (/ (+ x y) 2))
576 #<procedure media (x y)>
579 Una vez se ha definido un procedimiento, se llama poniendo el
580 nombre del procedimiento dentro de una lista. Por ejemplo,
581 podemos calcular la media de 3 y 12:
590 @unnumberedsubsubsec Predicados
591 @translationof Predicates
593 Los procedimientos de Scheme que devuelven valores booleanos se
594 suelen llamar @emph{predicados}. Por convenio (pero no por
595 necesidad), los nombres de predicados acaban en un signo de
599 guile> (define (menor-que-diez? x) (< x 10))
600 guile> (menor-que-diez? 9)
602 guile> (menor-que-diez? 15)
607 @node Valores de retorno
608 @unnumberedsubsubsec Valores de retorno
609 @translationof Return values
611 Los procedimientos de Scheme siempre devuelven un valor de
612 retorno, que es el valor de la última expresión ejecutada en el
613 procedimiento. El valor de retorno puede ser cualquier valor de
614 Scheme válido, incluso una estructura de datos compleja o un
617 A veces, el usuario quiere tener varias expresiones de Scheme
618 dentro de un procedimiento. Existen dos formas en que se pueden
619 combinar distintas expresiones. La primera es el procedimiento
620 @code{begin}, que permite evaluar varias expresiones, y devuelve
621 el valor de la última expresión.
624 guile> (begin (+ 1 2) (- 5 8) (* 2 2))
628 La segunda forma de combinar varias expresiones es dentro de un
629 bloque @code{let}. Dentro de un bloque let, se crean una serie de
630 ligaduras o asignaciones, y después se evalúa una secuencia de
631 expresiones que pueden incluir esas ligaduras o asignaciones. El
632 valor de retorno del bloque let es el valor de retorno de la
633 última sentencia del bloque let:
636 guile> (let ((x 2) (y 3) (z 4)) (display (+ x y)) (display (- z 4))
637 @dots{} (+ (* x y) (/ z x)))
642 @node Condicionales de Scheme
643 @subsection Condicionales de Scheme
644 @translationof Scheme conditionals
652 @unnumberedsubsubsec if
655 Scheme tiene un procedimiento @code{if}:
658 (if expresión-de-prueba expresión-de-cierto expresión-de-falso)
661 @var{expresión-de-prueba} es una expresión que devuelve un valor
662 booleano. Si @var{expresión-de-prueba} devuelve @code{#t}, el
663 procedimiento @code{if} devuelve el valor de la
664 @var{expresión-de-cierto}, en caso contrario devuelve el valor de
665 la @var{expresión-de-falso}.
670 guile> (if (> a b) "a es mayor que b" "a no es mayor que b")
671 "a no es mayor que b"
676 @unnumberedsubsubsec cond
679 Otro procedimiento condicional en Scheme es @code{cond}:
682 (cond (expresión-de-prueba-1 secuencia-de-expresiones-resultante-1)
683 (expresión-de-prueba-2 secuencia-de-expresiones-resultante-2)
685 (expresión-de-prueba-n secuencia-de-expresiones-resultante-n))
693 guile> (cond ((< a b) "a es menor que b")
694 ... ((= a b) "a es igual a b")
695 ... ((> a b) "a es mayor que b"))
699 @node Scheme dentro de LilyPond
700 @section Scheme dentro de LilyPond
701 @translationof Scheme in LilyPond
704 * Sintaxis del Scheme de LilyPond::
705 * Variables de LilyPond::
706 * Variables de entrada y Scheme::
707 * Importación de Scheme dentro de LilyPond::
708 * Propiedades de los objetos::
709 * Variables de LilyPond compuestas::
710 * Representación interna de la música::
713 @node Sintaxis del Scheme de LilyPond
714 @subsection Sintaxis del Scheme de LilyPond
715 @translationof LilyPond Scheme syntax
719 El intérprete Guile forma parte de LilyPond, lo que significa que
720 se puede incluir Scheme dentro de los archivos de entrada de
721 LilyPond. Existen varios métodos para incluir Scheme dentro de
724 La manera más sencilla es utilizar el símbolo de
725 almohadilla@tie{}@code{#} antes de una expresión de Scheme.
727 Ahora bien, el código de entrada de LilyPond se estructura en
728 elementos y expresiones, de forma parecida a cómo el lenguaje
729 humano se estructura en palabras y frases. LilyPond tiene un
730 analizador léxico que reconoce elementos indivisibles (números
731 literales, cadenas de texto, elementos de Scheme, nombres de nota,
732 etc.), y un analizador que entiende la sintaxis, la Gramática de
733 LilyPond (@rcontrib{LilyPond grammar}). Una vez que sabe que se
734 aplica una regla sintáctica concreta, ejecuta las acciones
737 El método del símbolo de almohadilla@tie{}@code{#} para incrustar
738 Scheme se adapta de forma natural a este sistema. Una vez que el
739 analizador léxico ve un símbolo de almohadilla, llama al lector de
740 Scheme para que lea una expresión de Scheme completa (que puede
741 ser un identificador, una expresión encerrada entre paréntesis, o
742 algunas otras cosas). Después de que se ha leído la expresión de
743 Scheme, se almacena como el valor de un elemento @code{SCM_TOKEN}
744 de la gramática. Después de que el analizador sintáctico ya sabe
745 cómo hacer uso de este elemento, llama a Guila para que evalúe la
746 expresión de Scheme. Dado que el analizador sintáctico suele
747 requerir un poco de lectura por delante por parte del analizador
748 léxico para tomar sus decisiones de análisis sintáctico, esta
749 separación de lectura y evaluación entre los analizadores léxico y
750 sintáctico es justamente lo que se necesita para mantener
751 sincronizadas las ejecuciones de expresiones de LilyPond y de
752 Scheme. Por este motivo se debe usar el símbolo de
753 almohadilla@tie{}@code{#} para llamar a Scheme siempre que sea
756 Otra forma de llamar al intérprete de Scheme desde LilyPond es el
757 uso del símbolo de dólar@tie{}@code{$} en lugar de la almohadilla
758 para introducir las expresiondes de Scheme. En este caso,
759 LilyPond evalúa el código justo después de que el analizador
760 léxico lo ha leído. Comprueba el tipo resultante de la expresión
761 de Scheme y después selecciona un tipo de elemento (uno de los
762 varios elementos @code{xxx_IDENTIFIER} dentro de la sintaxis) para
763 él. Crea una @emph{copia} del valor y la usa como valor del
764 elemento. Si el valor de la expresión es vacío (El valor de Guile
765 de @code{*unspecified*}), no se pasa nada en absoluto al
766 analizador sintáctico.
768 Éste es, de hecho, el mismo mecanismo exactamente que LilyPond
769 emplea cuando llamamos a cualquier variable o función musical por
770 su nombre, como @code{\nombre}, con la única diferencia de que el
771 nombre viene determinado por el analizador léxico de LilyPond sin
772 consultar al lector de Scheme, y así solamente se aceptan los
773 nombres de variable consistentes con el modo actual de LilyPond.
775 La acción inmediata de @code{$} puede llevar a alguna que otra
776 sorpresa, véase @ref{Importación de Scheme dentro de LilyPond}.
777 La utilización de @code{#} donde el analizador sintáctico lo
778 contempla es normalmente preferible. Dentro de las expresiones
779 musicales, aquellas que se crean utilizando @code{#} @emph{se
780 interprentan} como música. Sin embargo, @emph{no se copian} antes
781 de ser utilizadas. Si forman parte de alguna estructura que aún
782 podría tener algún uso, quizá tenga que utilizar explícitamente
783 @code{ly:music-deep-copy}.
787 También existen los operadores de @q{división de listas}
788 @code{$@@} y @code{#@@} que insertan todos los elementos de una
789 lista dentro del contexto circundante.
791 Ahora echemos un vistazo a algo de código de Scheme real. Los
792 procedimientos de Scheme se pueden definir dentro de los archivos
793 de entrada de LilyPond:
796 #(define (media a b c) (/ (+ a b c) 3))
799 Observe que los comentarios de LilyPond (@code{%} y @code{%@{
800 %@}}) no se pueden utilizar dentro del código de Scheme, ni
801 siquiera dentro de un archivo de entrada de LilyPond, porque es el
802 intérprete Guile, y no el analizador léxico de LilyPond, el que
803 está leyendo la expresión de Scheme. Los comentarios en el Scheme
804 de Guile se introducen como sigue:
807 ; esto es un comentario de una línea
810 Esto es un comentario de bloque (no anidable) estilo Guile
811 Pero se usan rara vez por parte de los Schemers
812 y nunca dentro del código fuente de LilyPond
816 Durante el resto de esta sección, supondremos que los datos se
817 introducen en un archivo de música, por lo que añadiremos una
818 almohadilla@tie{}@code{#} al principio de cada una de las
819 expresiones de Scheme.
821 Todas las expresiones de Scheme del nivel jerárquico superior
822 dentro de un archivo de entrada de LilyPond se pueden combinar en
823 una sola expresión de Scheme mediante la utilización del operador
829 (define menganito 1))
833 @node Variables de LilyPond
834 @subsection Variables de LilyPond
835 @translationof LilyPond variables
837 Las variables de LilyPond se almacenan internamente en la forma de
838 variables de Scheme. Así,
851 Esto significa que las variables de LilyPond están disponibles
852 para su uso dentro de expresiones de Scheme. Por ejemplo,
856 veintiCuatro = (* 2 doce)
860 lo que daría lugar a que el número @emph{24} se almacenase dentro
861 de la variable @code{veintiCuatro} de LilyPond (y de Scheme).
863 El lenguaje Scheme permite la modificación de expresiones
864 complejas in situ y LilyPond hace uso de esta @q{modificación in
865 situ} al usar funciones musicales. Pero cuando las expresiones
866 musicales se almacenan dentro de variables en lugar de ser
867 introducidas directamente, lo que habitualmente se espera cuando
868 se pasan a funciones musicales sería que el valor original quedase
869 intacto. Así pues, cuando se referencia una variable musical con
870 la barra invertida (como @code{\veintiCuatro}), LilyPond crea una
871 copia del valor musical de tal variable para utilizarla dentro de
872 la expresión musical circundante, en lugar de usar el valor de la
873 variable directamente.
875 Por ello, las expresiones musicales de Scheme escritas con la
876 sintasis de almohadilla @code{#} deberían utilizarse para
877 cualquier material creado @q{partiendo de cero} (o que se ha
878 copiado explícitamente) en lugar de utilizarse para referenciar
883 @ref{Sintaxis del Scheme de LilyPond}.
885 @node Variables de entrada y Scheme
886 @subsection Variables de entrada y Scheme
887 @translationof Input variables and Scheme
889 El formato de entrada contempla la noción de variables: en el
890 siguiente ejemplo, se asigna una expresión musical a una variable
891 con el nombre @code{traLaLa}.
894 traLaLa = @{ c'4 d'4 @}
899 También hay una forma de ámbito: en el ejemplo siguiente, el
900 bloque @code{\layout} también contiene una variable
901 @code{traLaLa}, que es independiente de la @code{\traLaLa}
905 traLaLa = @{ c'4 d'4 @}
906 \layout @{ traLaLa = 1.0 @}
910 En efecto, cada archivo de entrada constituye un ámbito, y cada
911 bloque @code{\header}, @code{\midi} y @code{\layout} son ámbitos
912 anidados dentro del ámbito de nivel superior.
914 Tanto las variables como los ámbitos están implementados en el
915 sistema de módulos de GUILE. A cada ámbito se adjunta un módulo
916 anónimo de Scheme. Una asignación de la forma:
919 traLaLa = @{ c'4 d'4 @}
923 se convierte internamente en una definición de Scheme:
926 (define traLaLa @var{Valor Scheme de `@code{@dots{}}'})
929 Esto significa que las variables de LilyPond y las variables de
930 Scheme se pueden mezclar con libertad. En el ejemplo siguiente,
931 se almacena un fragmento de música en la variable @code{traLaLa},
932 y se duplica usando Scheme. El resultado se importa dentro de un
933 bloque @code{\score} por medio de una segunda variable
937 traLaLa = { c'4 d'4 }
939 #(define newLa (map ly:music-deep-copy
940 (list traLaLa traLaLa)))
942 (make-sequential-music newLa))
947 @c Due to parser lookahead
949 En realidad, éste es un ejemplo bastante interesante. La
950 asignación solo tiene lugar después de que el analizador
951 sintáctico se ha asegurado de que no sigue nada parecido a
952 @code{\addlyrics}, de manera que necesita comprobar lo que viene a
953 continuación. Lee el símbolo @code{#} y la expresión de Scheme
954 siguiente @emph{sin} evaluarla, de forma que puede proceder a la
955 asignación, y @emph{posteriormente} ejecutar el código de Scheme
958 @node Importación de Scheme dentro de LilyPond
959 @subsection Importación de Scheme dentro de LilyPond
960 @translationof Importing Scheme in LilyPond
964 El ejemplo anterior muestra cómo @q{exportar} expresiones
965 musicales desde la entrada al intérprete de Scheme. Lo contrario
966 también es posible. Colocándolo después de @code{$}, un valor de
967 Scheme se interpreta como si hubiera sido introducido en la
968 sintaxis de LilyPond. En lugar de definir @code{\twice}, el
969 ejemplo anterior podría también haberse escrito como
973 $(make-sequential-music newLa)
976 Podemos utilizar @code{$} con una expresión de Scheme en cualquier
977 lugar en el que usaríamos @code{\@var{nombre}} después de haber
978 asignado la expresión de Scheme a una variable @var{nombre}. Esta
979 sustitución se produce dentro del @q{analizador léxico}, de manera
980 que LilyPond no llega a darse cuenta de la diferencia.
982 Sin embargo, existe un inconveniente, el de la medida del tiempo.
983 Si hubiésemos estado usando @code{$} en vez de @code{#} para
984 definir @code{newLa} en el ejemplo anterior, la siguiente
985 definición de Scheme habría fracasado porque @code{traLaLa} no
986 habría sido definida aún. Para ver una explicación de este
987 problema de momento temporal, véase @ref{Sintaxis del Scheme de
992 Un conveniente aspecto posterior pueden ser los operadores de
993 @q{división de listas} @code{$@@} y @code{#@@} para la inserción
994 de los elementos de una lista dentro del contexto circundante.
995 Utilizándolos, la última parte del ejemplo se podría haber escrito
1003 Aquí, cada elemento de la lista que está almacenado en
1004 @code{newLa} se toma en secuencia y se inserta en la lista, como
1005 si hubiésemos escrito
1008 @{ #(first newLa) #(second newLa) @}
1011 Ahora bien, en todas esas formas, el código de Scheme se evalúa en
1012 el momento en que el código de entrada aún se está procesando, ya
1013 sea en el analizador léxico o en el analizador sintáctico. Si
1014 necesitamos que se ejecute en un momento posterior, debemos
1015 consultar @ref{Funciones de Scheme vacías}, o almacenarlo dentro
1016 de un procedimiento:
1020 (ly:set-option 'point-and-click #f))
1029 No es posible mezclar variables de Scheme y de LilyPond con la
1030 opción @option{--safe}.
1033 @node Propiedades de los objetos
1034 @subsection Propiedades de los objetos
1035 @translationof Object properties
1037 Las propiedades de los objetos se almacenan en LilyPond en forma
1038 de cadenas de listas-A, que son listas de listas-A. Las
1039 propiedades se establecen añadiendo valores al principio de la
1040 lista de propiedades. Las propiedades se leen extrayendo valores
1043 El establecimiento de un valor nuevo para una propiedad requiere
1044 la asignación de un valor a la lista-A con una clave y un valor.
1045 La sintaxis de LilyPond para hacer esto es la siguiente:
1048 \override Stem.thickness = #2.6
1051 Esta instrucción ajusta el aspecto de las plicas. Se añade una
1052 entrada de lista-A @code{'(thickness . 2.6)} a la lista de
1053 propiedades de un objeto @code{Stem}. @code{thickness} se mide a
1054 partir del grosor de las líneas del pentagrama, y así estas plicas
1055 serán @code{2.6} veces el grosor de las líneas del pentagrama.
1056 Esto hace que las plicas sean casi el doble de gruesas de lo
1057 normal. Para distinguir entre las variables que se definen en los
1058 archivos de entrada (como @code{veintiCuatro} en el ejemplo
1059 anterior) y las variables de los objetos internos, llamaremos a
1060 las últimas @q{propiedades} y a las primeras @q{variables.} Así,
1061 el objeto plica tiene una propiedad @code{thickness} (grosor),
1062 mientras que @code{veintiCuatro} es una variable.
1064 @cindex propiedades frente a variables
1065 @cindex variables frente a propiedades
1067 @c todo -- here we're getting interesting. We're now introducing
1068 @c LilyPond variable types. I think this deserves a section all
1071 @node Variables de LilyPond compuestas
1072 @subsection Variables de LilyPond compuestas
1073 @translationof LilyPond compound variables
1079 * Listas-A de propiedades::
1080 * Cadenas de listas-A::
1084 @node Desplazamientos
1085 @unnumberedsubsubsec Desplazamientos
1086 @translationof Offsets
1088 Los desplazamientos bidimensionales (coordenadas X e Y) se
1089 almacenan como @emph{parejas}. El @code{car} del desplazamiento
1090 es la coordenada X, y el @code{cdr} es la coordenada Y.
1093 \override TextScript.extra-offset = #'(1 . 2)
1096 Esto asigna la pareja @code{(1 . 2)} a la propiedad
1097 @code{extra-offset} del objeto TextScript. Estos números se miden
1098 en espacios de pentagrama, y así esta instrucción mueve el objeto
1099 un espacio de pentagrama a la derecha, y dos espacios hacia
1102 Los procedimientos para trabajar con desplazamientos están en
1103 @file{scm/lily-library.scm}.
1106 @unnumberedsubsubsec Fracciones
1107 @subheading Fractions
1109 Las fracciones tal y como se utilizan por parte de LilyPond se
1110 almacenan, de nuevo, como @emph{parejas}, esta vez de enteros sin
1111 signo. Mientras que Scheme es capaz de representar números
1112 racionaes como un tipo nativo, musicalmente @samp{2/4} y
1113 @samp{1/2} no son lo mismo, y necesitamos poder distinguir entre
1114 ellos. De igual forma, no existe el concepto de @q{fracciones}
1115 negativas en LilyPond. Así pues, @code{2/4} en LilyPond significa
1116 @code{(2 . 4)} en Scheme, y @code{#2/4} en LilyPond significa
1117 @code{1/2} en Scheme.
1121 @unnumberedsubsubsec Dimensiones
1122 @translationof Extents
1124 Las parejas se usan también para almacenar intervalos, que
1125 representan un rango de números desde el mínimo (el @code{car})
1126 hasta el máximo (el @code{cdr}). Los intervalos se usan para
1127 almacenar las dimensiones en X y en Y de los objetos imprimibles.
1128 Para dimensiones en X, el @code{car} es la coordenada X de la
1129 parte izquierda, y el @code{cdr} es la coordenada X de la parte
1130 derecha. Para las dimensiones en Y, el @code{car} es la
1131 coordenada inferior, y el @code{cdr} es la coordenada superior.
1133 Los procedimientos para trabajar con intervalos están en
1134 @file{scm/lily-library.scm}. Se deben usar estos procedimientos
1135 siempre que sea posible, para asegurar la consistencia del código.
1138 @node Listas-A de propiedades
1139 @unnumberedsubsubsec Listas-A de propiedades
1140 @translationof Property alists
1142 Una lista-A de propiedades es una estructura de datos de LilyPond
1143 que es una lista-A cuyas claves son propiedades y cuyos valores
1144 son expresiones de Scheme que dan el valor deseado de la
1147 Las propiedades de LilyPond son símbolos de Scheme, como por
1148 ejemplo @code{'thickness}.
1151 @node Cadenas de listas-A
1152 @unnumberedsubsubsec Cadenas de listas-A
1153 @translationof Alist chains
1155 Una cadena de listas-A es una lista que contiene listas-A de
1158 El conjunto de todas las propiedades que se aplican a un grob se
1159 almacena por lo general como una cadena de listas-A. Para poder
1160 encontrar el valor de una propiedad determinada que debería tener
1161 un grob, se busca por todas las listas-A de la cadena, una a una,
1162 tratando de encontrar una entrada que contenga la clave de la
1163 propiedad. Se devuelve la primera entrada de lista-A que se
1164 encuentre, y el valor es el valor de la propiedad.
1166 El procedimiento de Scheme @code{chain-assoc-get} se usa
1167 normalmente para obtener los valores de propiedades.
1169 @node Representación interna de la música
1170 @subsection Representación interna de la música
1171 @translationof Internal music representation
1173 Internamente, la música se representa como una lista de Scheme.
1174 La lista contiene varios elementos que afectan a la salida
1175 impresa. El análisis sintáctico es el proceso de convertir la
1176 música de la representación de entrada de LilyPond a la
1177 representación interna de Scheme.
1179 Cuando se analiza una expresión musical, se convierte en un
1180 conjunto de objetos musicales de Scheme. La propiedad definitoria
1181 de un objeto musical es que ocupa un tiempo. El tiempo que ocupa
1182 se llama @emph{duración}. Las duraciones se expresan como un
1183 número racional que mide la longitud del objeto musical en
1186 Un objeto musical tiene tres clases de tipos:
1189 nombre musical: Cada expresión musical tiene un nombre. Por
1190 ejemplo, una nota lleva a un @rinternals{NoteEvent}, y
1191 @code{\simultaneous} lleva a una @rinternals{SimultaneousMusic}.
1192 Hay una lista de todas las expresiones disponibles en el manual de
1193 Referencia de funcionamiento interno, bajo el epígrafe
1194 @rinternals{Music expressions}.
1197 @q{type} (tipo) o interface: Cada nombre musical tiene varios
1198 @q{tipos} o interfaces, por ejemplo, una nota es un @code{event},
1199 pero también es un @code{note-event}, un @code{rhythmic-event}, y
1200 un @code{melodic-event}. Todas las clases de música están
1201 listadas en el manual de Referencia de funcionamiento interno,
1202 bajo el epígrafe @rinternals{Music classes}.
1205 objeto de C++: Cada objeto musical está representado por un objeto
1206 de la clase @code{Music} de C++.
1209 La información real de una expresión musical se almacena en
1210 propiedades. Por ejemplo, un @rinternals{NoteEvent} tiene
1211 propiedades @code{pitch} y @code{duration} que almacenan la altura
1212 y la duración de esa nota. Hay una lista de todas la propiedades
1213 disponibles en el manual de Referencia de funcionamiento interno,
1214 bajo el epígrafe @rinternals{Music properties}.
1216 Una expresión musical compuesta es un objeto musical que contiene
1217 otros objetos musicales dentro de sus propiedades. Se puede
1218 almacenar una lista de objetos dentro de la propiedad
1219 @code{elements} de un objeto musical, o un único objeto musical
1220 @q{hijo} dentro de la propiedad @code{element}. Por ejemplo,
1221 @rinternals{SequentialMusic} tiene su hijo dentro de
1222 @code{elements}, y @rinternals{GraceMusic} tiene su argumento
1223 único dentro de @code{element}. El cuerpo de una repetición se
1224 almacena dentro de la propiedad @code{element} de
1225 @rinternals{RepeatedMusic}, y las alternativas dentro de
1228 @node Construir funciones complicadas
1229 @section Construir funciones complicadas
1230 @translationof Building complicated functions
1232 Esta sección explica cómo reunir la información necesaria para
1233 crear funciones musicales complicadas.
1236 * Presentación de las expresiones musicales::
1237 * Propiedades musicales::
1238 * Duplicar una nota con ligaduras (ejemplo)::
1239 * Añadir articulaciones a las notas (ejemplo)::
1243 @node Presentación de las expresiones musicales
1244 @subsection Presentación de las expresiones musicales
1245 @translationof Displaying music expressions
1247 @cindex almacenamiento interno
1248 @cindex imprimir expresiones musicales
1249 @cindex representación interna, impresión de
1250 @cindex displayMusic
1251 @funindex \displayMusic
1253 Si se está escribiendo una función musical, puede ser muy
1254 instructivo examinar cómo se almacena internamente una expresión
1255 musical. Esto se puede hacer con la función musical
1256 @code{\displayMusic}.
1260 \displayMusic @{ c'4\f @}
1265 imprime lo siguiente:
1275 'AbsoluteDynamicEvent
1279 (ly:make-duration 2 0 1/1)
1281 (ly:make-pitch 0 0 0))))
1284 De forma predeterminada, LilyPond imprime estos mensajes sobre la
1285 consola junto al resto de los mensajes. Para separar estos
1286 mensajes y guardar el resultado de @code{\display@{LOQUESEA@}},
1287 puede especificar que se use un puerto de salida opcional:
1291 \displayMusic #(open-output-file "display.txt") @{ c'4\f @}
1295 Esto sobreescribe el archivo de salida anterior cada vez ques e
1296 llama; si necesitamos escribir más de una expresión, debemos usar
1297 una variable para el puerto y reutilizarla:
1300 port = #(open-output-file "display.txt")
1301 \displayMusic \port @{ c'4\f @}
1302 \displayMusic \port @{ d'4 @}
1303 #(close-output-port port)
1307 El manual de Guile describe los puertos detalladamente. Solo es
1308 realmente necesario cerrar el puerto si necesitamos leer el
1309 archivo antes de que LilyPond termine; en el primer ejemplo, no
1310 nos hemos molestado en hacerlo.
1312 Un poco de reformateo hace a la información anterior más fácil de
1316 (make-music 'SequentialMusic
1318 (make-music 'NoteEvent
1319 'articulations (list
1320 (make-music 'AbsoluteDynamicEvent
1323 'duration (ly:make-duration 2 0 1/1)
1324 'pitch (ly:make-pitch 0 0 0))))
1327 Una secuencia musical @code{@{ @dots{} @}} tiene el nombre
1328 @code{SequentialMusic}, y sus expresiones internas se almacenan
1329 coma una lista dentro de su propiedad @code{'elements}. Una nota
1330 se representa como un objeto @code{NoteEvent} (que almacena las
1331 propiedades de duración y altura) con información adjunta (en este
1332 caso, un evento @code{AbsoluteDynamicEvent} con una propiedad
1333 @code{"f"} de texto) almacenada en su propiedad
1334 @code{articulations}.
1338 @code{\displayMusic} devuelve la música que imprime en la consola,
1339 y por ello se interpretará al tiempo que se imprime en la consola.
1340 Para evitar la interpretación, escriba @code{\void} antes de
1341 @code{\displayMusic}.
1343 @node Propiedades musicales
1344 @subsection Propiedades musicales
1345 @translationof Music properties
1348 TODO -- make sure we delineate between @emph{music} properties,
1349 @emph{context} properties, and @emph{layout} properties. These
1350 are potentially confusing.
1357 \displayMusic \someNote
1362 (ly:make-duration 2 0 1/1)
1364 (ly:make-pitch 0 0 0))
1367 El objeto @code{NoteEvent} es la representación de
1368 @code{someNote}. Sencillo. ¿Y si ponemos el c' dentro de un
1373 \displayMusic \someNote
1381 (ly:make-duration 2 0 1/1)
1383 (ly:make-pitch 0 0 0))))
1386 Ahora el objeto @code{NoteEvent} es el primer objeto de la
1387 propiedad @code{'elements} de @code{someNote}.
1389 La función @code{display-scheme-music} es la función que se usa
1390 por parte de @code{\displayMusic} para imprimir la representación
1391 de Scheme de una expresión musical.
1394 #(display-scheme-music (first (ly:music-property someNote 'elements)))
1399 (ly:make-duration 2 0 1/1)
1401 (ly:make-pitch 0 0 0))
1404 Después se accede a la altura de la nota a través de la propiedad
1405 @code{'pitch} del objeto @code{NoteEvent}:
1408 #(display-scheme-music
1409 (ly:music-property (first (ly:music-property someNote 'elements))
1412 (ly:make-pitch 0 0 0)
1415 La altura de la nota se puede cambiar estableciendo el valor de
1416 esta propiedad @code{'pitch}.
1418 @funindex \displayLilyMusic
1421 #(set! (ly:music-property (first (ly:music-property someNote 'elements))
1423 (ly:make-pitch 0 1 0)) ;; establecer la altura a d'.
1424 \displayLilyMusic \someNote
1430 @node Duplicar una nota con ligaduras (ejemplo)
1431 @subsection Duplicar una nota con ligaduras (ejemplo)
1432 @translationof Doubling a note with slurs (example)
1434 Supongamos que queremos crear una función que convierte una
1435 entrada como @code{a} en @code{@{ a( a) @}}. Comenzamos
1436 examinando la representación interna de la música con la que
1440 \displayMusic@{ a'( a') @}
1453 (ly:make-duration 2 0 1/1)
1455 (ly:make-pitch 0 5 0))
1464 (ly:make-duration 2 0 1/1)
1466 (ly:make-pitch 0 5 0))))
1469 La mala noticia es que las expresiones @code{SlurEvent} se deben
1470 añadir @q{dentro} de la nota (dentro de la propiedad
1471 @code{articulations}).
1473 Ahora examinamos la entrada.
1481 (ly:make-duration 2 0 1/1)
1483 (ly:make-pitch 0 5 0))))
1486 Así pues, en nuestra función, tenemos que clonar esta expresión
1487 (de forma que tengamos dos notas para construir la secuencia),
1488 añadir @code{SlurEvent} a la propiedad @code{'articulations} de
1489 cada una de ellas, y por último hacer una secuencia
1490 @code{SequentialMusic} con los dos elementos @code{NoteEvent}.
1491 Para añadir a una propiedad, es útil saber que una propiedad no
1492 establecida se lee como @code{'()}, la lista vacía, así que no se
1493 requiere ninguna comprobación especial antes de que pongamos otro
1494 elemento delante de la propiedad @code{articulations}.
1498 doubleSlur = #(define-music-function (note) (ly:music?)
1499 "Return: @{ note ( note ) @}.
1500 `note' is supposed to be a single note."
1501 (let ((note2 (ly:music-deep-copy note)))
1502 (set! (ly:music-property note 'articulations)
1503 (cons (make-music 'SlurEvent 'span-direction -1)
1504 (ly:music-property note 'articulations)))
1505 (set! (ly:music-property note2 'articulations)
1506 (cons (make-music 'SlurEvent 'span-direction 1)
1507 (ly:music-property note2 'articulations)))
1508 (make-music 'SequentialMusic 'elements (list note note2))))
1512 @node Añadir articulaciones a las notas (ejemplo)
1513 @subsection Añadir articulaciones a las notas (ejemplo)
1514 @translationof Adding articulation to notes (example)
1516 La manera fácil de añadir articulación a las notas es mezclar dos
1517 expresiones musicales en un solo contexto. Sin embargo,
1518 supongamos que queremos escribir una función musical que lo haga.
1519 Esto tiene la ventaja adicional de que podemos usar esa función
1520 musical para añadir una articulación (como una instrucción de
1521 digitación) a una nota única dentro de un acorde, lo cual no es
1522 posible si nos limitamos a mezclar fragmentos de música
1525 Una @code{$variable} dentro de la notación @code{#@{@dots{}#@}} es
1526 como una @code{\variable} normal en la notación clásica de
1527 LilyPond. Sabemos que
1534 no funciona en LilyPond. Podríamos evitar este problema
1535 adjuntando la articulación a un acorde vacío,
1538 @{ << \music <> -. -> >> @}
1542 pero a los efectos de este ejemplo, aprenderemos ahora cómo
1543 hacerlo en Scheme. Empezamos examinando nuestra entrada y la
1553 (ly:make-duration 2 0 1/1)
1555 (ly:make-pitch -1 0 0))))
1568 (ly:make-duration 2 0 1/1)
1570 (ly:make-pitch -1 0 0))
1573 Vemos que una nota (@code{c4}) se representa como una expresión
1574 @code{NoteEvent}. Para añadir una articulación de acento, se debe
1575 añadir una expresión @code{ArticulationEvent} a la propiedad
1576 @code{articulations} de la expresión @code{NoteEvent}.
1578 Para construir esta función, empezamos con
1581 (define (add-accent note-event)
1582 "Add an accent ArticulationEvent to the articulations of `note-event',
1583 which is supposed to be a NoteEvent expression."
1584 (set! (ly:music-property note-event 'articulations)
1585 (cons (make-music 'ArticulationEvent
1586 'articulation-type "accent")
1587 (ly:music-property note-event 'articulations)))
1591 La primera línea es la forma de definir una función en Scheme: el
1592 nombre de la función es @code{add-accent}, y tiene una variable
1593 llamada @code{note-event}. En Scheme, el tipo de variable suele
1594 quedar claro a partir de su nombre (¡esto también es una buena
1595 práctica en otros lenguajes de programación!)
1598 "Add an accent@dots{}"
1602 es una descripción de lo que hace la función. No es estrictamente
1603 necesaria, pero de igual forma que los nombres claros de variable,
1604 es una buena práctica.
1606 Se preguntará por qué modificamos el evento de nota directamente
1607 en lugar de trabajar sobre una copia (se puede usar
1608 @code{ly:music-deep-copy} para ello). La razón es un contrato
1609 silencioso: se permite que las funciones musicales modifiquen sus
1610 argumentos; o bien se generan partiendo de cero (como la entrada
1611 del usuario) o están ya copiadas (referenciar una variable de
1612 música con @samp{\name} o la música procedente de expresiones de
1613 Scheme inmediatas @samp{$(@dots{})} proporcionan una copia). Dado
1614 que sería ineficiente crear copias innecesarias, el valor devuelto
1615 de una función musical @emph{no} se copia. Así pues, para cumplir
1616 dicho contrato, no debemos usar ningún argumento más de una vez, y
1617 devolverlo cuenta como una vez.
1619 En un ejemplo anterior, hemos construido música mediante la
1620 repetición de un argumento musical dado. En tal caso, al menos
1621 una repetidión tuvo que ser una copia de sí misma. Si no lo
1622 fuese, podrían ocurrir cosas muy extrañas. Por ejemplo, si usamos
1623 @code{\relative} o @code{\transpose} sobre la música resultante
1624 que contiene los mismos elementos varias veces, estarían sujetos
1625 varias veces a la relativización o al transporte. Si los
1626 asignamos a una variable de música, se rompe el curso porque hacer
1627 referencia a @samp{\name} creará de nuevo una copia que no retiene
1628 la identidad de los elementos repetidos.
1630 Ahora bien, aun cuando la función anterior no es una función
1631 musical, se usará normalmente dentro de funciones musicales. Así
1632 pues, tiene sentido obedecer el mismo convenio que usamos para las
1633 funciones musicales: la entrada puede modificarse para producir la
1634 salida, y el código que llama es responsable de crear las copias
1635 si aún necesita el propio argumento sin modificar. Si observamos
1636 las propias funciones de LilyPond como @code{music-map}, veremos
1637 que se atienen a los mismos principios.
1639 ¿En qué punto nos encontramos? Ahora tenemos un @code{note-event}
1640 que podemos modificar, no a causa de la utilización de
1641 @code{ly:music-deep-copy} sino por una explicación muy
1642 desarrollada. Añadimos el acento a su propiedad de lista
1643 @code{'articulations}.
1646 (set! place new-value)
1649 Aquí, lo que queremos establecer (el @q{place}) es la propiedad
1650 @code{'articulations} de la expresión @code{note-event}.
1653 (ly:music-property note-event 'articulations)
1656 @code{ly:music-property} es la función ustilizada para acceder a las
1657 propiedades musicales (las @code{'articulations}, @code{'duration},
1658 @code{'pitch}, etc, que vemos arriba en la salida de
1659 @code{\displayMusic}). El nuevo valor es la antigua propiedad
1660 @code{'articulations}, con un elemento adicional: la expresión
1661 @code{ArticulationEvent}, que copiamos a partir de la salida de
1662 @code{\displayMusic},
1665 (cons (make-music 'ArticulationEvent
1666 'articulation-type "accent")
1667 (ly:music-property result-event-chord 'articulations))
1670 Se usa @code{cons} para añadir un elemento a la parte delantera de
1671 una lista sin modificar la lista original. Esto es lo que
1672 queremos: la misma lista de antes, más la nueva expresión
1673 @code{ArticulationEvent}. El orden dentro de la propiedad
1674 @code{'articulations} no tiene importancia aquí.
1676 Finalmente, una vez hemos añadido la articulación de acento a su
1677 propiedad @code{articulations}, podemos devolver
1678 @code{note-event}, de aquí la última línea de la función.
1680 Ahora transformamos la función @code{add-accent} en una función
1681 musical (es cuestión de un poco de aderezo sintáctico y una
1682 declaración del tipo de su argumento).
1685 addAccent = #(define-music-function (note-event)
1687 "Add an accent ArticulationEvent to the articulations of `note-event',
1688 which is supposed to be a NoteEvent expression."
1689 (set! (ly:music-property note-event 'articulations)
1690 (cons (make-music 'ArticulationEvent
1691 'articulation-type "accent")
1692 (ly:music-property note-event 'articulations)))
1696 A continuación verificamos que esta función musical funciona
1700 \displayMusic \addAccent c4
1706 * Trucos con Scheme::
1709 @c @nod e Trucos con Scheme
1710 @c @sectio n Trucos con Scheme
1711 @c @transl ationof Tweaking with Scheme
1713 Hemos visto cómo la salida de LilyPond se puede modificar
1714 profundamente usando instrucciones como
1715 @code{\override TextScript.extra-offset = ( 1 . -1)}.
1716 Pero tenemos incluso mucho más poder si
1717 utilizamos Scheme. Para ver una explicación completa de esto,
1718 consulte el @ref{Tutorial de Scheme}, y @ruser{Interfaces para programadores}.
1720 Podemos usar Scheme simplemente para sobreescribir instrucciones con
1723 TODO Find a simple example
1724 @c This isn't a valid example with skylining
1725 @c It works fine without padText -td
1729 @lilypond[quote,verbatim,ragged-right]
1730 padText = #(define-music-function (padding) (number?)
1732 \once \override TextScript.padding = #padding
1736 c'''4^"piu mosso" b a b
1738 c4^"piu mosso" d e f
1740 c4^"piu mosso" fis a g
1746 Lo podemos usar para crear instrucciones nuevas:
1748 @c Check this is a valid example with skylining
1749 @c It is - 'padding still works
1752 @lilypond[quote,verbatim,ragged-right]
1753 tempoPadded = #(define-music-function (padding tempotext)
1756 \once \override Score.MetronomeMark.padding = #padding
1757 \tempo \markup { \bold #tempotext }
1761 \tempo \markup { "Low tempo" }
1763 \tempoPadded #4.0 "High tempo"
1769 Incluso se le pueden pasar expresiones musicales:
1771 @lilypond[quote,verbatim,ragged-right]
1772 pattern = #(define-music-function (x y) (ly:music? ly:music?)
1779 \pattern {d16 dis} { ais16-> b\p }
projects / lilypond.git / blob