Manual de aprendizaje de GNU LilyPond: B. Scheme tutorial

# B. Scheme tutorial

LilyPond utiliza el lenguaje de programación Scheme, tanto como parte de la sintaxis del código de entrada, como para servir de mecanismo interno que une los módulos del programa entre sí. Esta sección es una panorámica muy breve sobre cómo introducir datos en Scheme. Si quiere saber más sobre Scheme, consulte http://www.schemers.org.

Lo más básico de un lenguaje son los datos: números, cadenas de caracteres, listas, etc. He aquí una lista de los tipos de datos que son de relevancia respecto de la entrada de LilyPond.

Booleanos

  Los valores Booleanos son Verdadero y Falso. Verdadero en Scheme es `#t` y Falso es `#f`.

Números

  Los números se escriben de la forma normal, `1` es el número (entero) uno, mientras que `-1.5` es un número en coma flotante (un número no entero).

Cadenas

  Las cadenas se encierran entre comillas:

  >     "esto es una cadena"

  Las cadenas pueden abarcar varias líneas:

  >     "esto
  >     es
  >     una cadena"

  También se pueden añadir comillas y saltos de línea con las llamadas secuencias de escape. La cadena `a dijo "b"` se escribe como

  >     "a dijo \"b\""

  Los saltos de línea t las barras invertidas se escapan mediante `\n` y `\\` respectivamente.

En un archivo de música, los fragmentos de código de Scheme se escriben con el signo de almohadilla `#`. Así, los ejemplos anteriores traducidos a LilyPond son:

>     ##t ##f
>     #1 #-1.5
>     #"esto es una cadena"
>     #"esto
>     es
>     una cadena"

Durante el resto de esta sección, supondremos que los datos se introducen en un archivo de música, por lo que añadiremos almohadillas `#` en todas partes.

Scheme se puede usar para hacer cálculos. Utiliza sintaxis prefija. Sumar 1 y 2 se escribe como `(+ 1 2)` y no como el tradicional 1+2.

    #(+ 1 2)
      ⇒ #3

La flecha ⇒ muestra que el resultado de evaluar `(+ 1 2)` es `3`. Los cálculos se pueden anidar; el resultado de una función se puede usar para otro cálculo.

    #(+ 1 (* 3 4))
      ⇒ #(+ 1 12)
      ⇒ #13

Estos cálculos son ejemplos de evaluaciones; una expresión como `(* 3 4)` se sustituye por su valor `12`. Algo similar ocurre con las variables. Después de haber definido una variable

>     doce = #12

las variables se pueden usar también dentro de las expresiones, aquí

>     veintiCuatro = #(* 2 doce)

el número 24 se almacena dentro de la variable `veintiCuatro`. La misma asignación se puede hacer también completamente en Scheme,

>     #(define veintiCuatro (* 2 doce))

El nombre de una variable también es una expresión, similar a un número o una cadena. Se introduce como

>     #'veintiCuatro

El apóstrofo `'` evita que el intérprete de Scheme sustituya `veintiCuatro` por `24`. En vez de esto, obtenemos el nombre `veintiCuatro`.

Esta sintaxis se usará con mucha frecuencia, pues muchos de los trucos de presentación consisten en asignar valores (de Scheme) a variables internas, por ejemplo

>     \override Stem #'thickness = #2.6

Esta instrucción ajusta el aspecto de las plicas. El valor `2.6` se pone dentro de la variable `thickness` de un objeto `Stem`. `thickness` se mide a partir del grosor de las líneas del pentagrama, y así estas plicas serán `2.6` veces el grosor de las líneas del pentagrama. Esto hace que las plicas sean casi el doble de gruesas de lo normal. Para distinguir entre las variables que se definen en los archivos de entrada (como `veintiCuatro` en el ejemplo anterior) y las variables de los objetos internos, llamaremos a las últimas ‘propiedades’ y a las primeras ‘variables.’ Así, el objeto plica tiene una propiedad `thickness` (grosor), mientras que `veintiCuatro` es una variable.

Los desplazamientos bidimensionales (coordenadas X e Y) así como los tamaños de los objetos (intervalos con un punto izquierdo y otro derecho) se introducen como `parejas`. Una pareja1 se introduce como `(primero . segundo)` y, como los símbolos, se deben preceder de un apóstrofo:

>     \override TextScript #'extra-offset = #'(1 . 2)

Esto asigna la pareja (1, 2) a la propiedad `extra-offset` del objeto TextScript. Estos números se miden en espacios de pentagrama, y así esta instrucción mueve el objeto un espacio de pentagrama a la derecha, y dos espacios hacia arriba.

Los dos elementos de una pareja pueden ser valores arbitrarios, por ejemplo

>     #'(1 . 2)
>     #'(#t . #f)
>     #'("bla-bla" . 3.14159265)

Una lista se escribe encerrando sus elementos entre paréntesis, y añadiendo un apóstrofo. Por ejemplo,

>     #'(1 2 3)
>     #'(1 2 "cadena" #f)

Todo el tiempo hemos estado usando listas. Un cálculo, como `(+ 1 2)` también es una lista (que contiene el símbolo `+` y los números 1 y 2). Normalmente, las listas se interpretan como cálculos, y el intérprete de Scheme sustituye el resultado del cálculo. Para escribir una lista, detenemos la evaluación. Esto se hace precediendo la lista por un apóstrofo `'`. Así, para los cálculos no usamos ningún apóstrofo.

Dentro de una lista o pareja precedida de apóstrofo, no hay necesidad de escribir ningún apóstrofo más. Lo siguiente es una pareja de símbolos, una lista de símbolos y una lista de listas respectivamente:

>     #'(stem . head)
>     #'(staff clef key-signature)
>     #'((1) (2))

### Notas el pie

[1] En la terminología de Scheme, la pareja se llama `cons`, y sus dos elementos se llaman `car` y `cdr` respectivamente.

Other languages: English, deutsch.

#### Manual de aprendizaje