1 @c -*- coding: utf-8; mode: texinfo; documentlanguage: de -*-
4 Translation of GIT committish: 233fb6a8b3b6e31de1841641dbbd4c4f43423151
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..
15 @translationof Scheme tutorial
20 @cindex Scheme, in einer LilyPond-Datei
22 @cindex Auswertung von Scheme-Code
24 LilyPond verwendet die Scheme-Programmiersprache sowohl als Teil
25 der Eingabesyntax als auch als internen Mechanismus, um Programmmodule
26 zusammenzufügen. Dieser Abschnitt ist ein sehr kurzer Überblick über
27 die Dateneingabe mit Scheme. Wenn Sie mehr über Scheme wissen wollen,
28 gehen Sie zu @uref{http://@/www@/.schemers@/.org}.
30 LilyPond benutzt die GNU Guile-Implementation von Scheme, die auf dem
31 @qq{R5RS}-Standard von Scheme basiert. Wenn Sie Scheme lernen wollen,
32 um es innerhalb von LilyPond zu benutzen, wird es nicht empfohlen,
33 mit einer anderen Implementation (die sich auf einen anderen
34 Standard bezieht) zu arbeiten. Information zu Guile findet sich
35 unter @uref{http://www.gnu.org/software/guile/}. Der
36 @qq{R5RS}-Standard von Scheme befindet sich unter der Adresse
37 @uref{http://www.schemers.org/Documents/Standards/R5RS/}.
41 * Einleitung in Scheme::
42 * Scheme in LilyPond::
43 * Komplizierte Funktionen erstellen::
46 @node Einleitung in Scheme
47 @section Einleitung in Scheme
48 @translationof Introduction to Scheme
50 Wir wollen mit einer Einführung in Scheme beginnen. Für diese kurze Einfürung
51 soll der GUILE-Interpreter genommen werden, um zu erforschen, wie die Sprache
52 funktioniert. Nach besserer Bekanntschaft mit Scheme soll gezeigt werden, wie
53 die Sprache in LilyPond-Dateien eingefügt werden kann.
58 * Einfache Scheme-Datentypen::
59 * Zusammengesetzte Scheme-Datentypen::
60 * Berechnungen in Scheme::
62 * Scheme-Konditionale::
65 @node Scheme-Sandkasten
66 @subsection Scheme-Sandkasten
67 @translationof Scheme sandbox
69 Die LilyPond-Installation enthält gleichzeitig auch die
70 Guile-Implementation von Scheme. Auf den meisten Systemen kann
71 man in einer Scheme-sandbox experimentieren, indem man ein
72 Kommandozeilen-Fenster öffnet und @code{guile} aufruft. Unter
73 einigen Systemen, insbesondere unter Windows, muss man evtl.
74 die Umgebungsvariable @code{GUILE_LOAD_PATH} auf das Verzeichnis
75 @code{../usr/share/guile/1.8} innerhalb des LilyPond-Installationsverzeichnisses
76 setzen (der vollständige Pfad ist erklärt in @rlearning{Mehr Information}).
77 Alternativ können Windows-Benutzer auch einfach @qq{Ausführen} im
78 Startmenü wählen und @code{guile} schreiben.
80 Es gibt auch eine direkte Scheme-Umgebung mit allen LilyPond-Voreinstellungen,
81 die man auf der Kommandozeile mit folgendem Befehl aufrufen kann:
84 lilypond scheme-sandbox
88 Wenn guile einmal läuft, erhält man die Eingabeaufforderung von guile:
94 Man kann Scheme-Ausdrucke hier eingeben und mit Scheme experimentieren.
95 Siehe die Datei @file{ly/scheme-sandbox.ly} zu Information, wie man
96 die GNU readline-Bibliothek benutzen kann, um bessere Scheme-Formatierung
97 der Kommandozeile zu erhalten. Wenn die readline-Bibliothek für interaktive
98 Guile-Sitzungen außerhalb von LilyPond schon aktiviert ist, sollte es auch
99 in der Sandbox funktionieren.
102 @node Scheme-Variablen
103 @subsection Scheme-Variablen
104 @translationof Scheme variables
106 Scheme-Variablen können jedlichen gültigen Scheme-Wert erhalten, auch
109 Scheme-Variablen werden mit @code{define} definiert:
116 Scheme-Variablen können an der Guile-Eingabeaufforderung ausgewertet werden,
117 indem man einfach die Variable eintippt.
125 Scheme-Variablen können auf dem Bildschirm ausgegeben werden, indem man
126 @code{display} zum Anzeigen benutzt:
133 Sowohl der Wert @code{2} als auch die Eingabeaufforderung @code{guile}
134 werden auf der gleichen Zeile ausgegeben. Das kann man vermeiden, indem
135 man eine @code{newline}-Prozedur für eine Leerzeile aufruft oder das
136 Zeichen für eine neue Zeile anzeigen lässt:
139 guile> (display a)(newline)
141 guile> (display a)(display "\n")
146 Wenn eine Variable einmal erstellt wurde, kann ihr Wert durch @code{set!}
150 guile> (set! a 12345)
156 @node Einfache Scheme-Datentypen
157 @subsection Einfache Scheme-Datentypen
158 @translationof Scheme simple data types
160 Das Grundlegendste an einer Sprache sind Daten: Zahlen, Zeichen,
161 Zeichenketten, Listen usw. Hier ist eine Liste der Datentypen, die für
162 LilyPond-Eingabedateien relevant sind.
165 @item Boolesche Variablen
166 Werte einer Booleschen Variable sind Wahr oder Falsch. Die Scheme-Entsprechung
167 für Wahr ist @code{#t} und für Falsch @code{#f}.
172 Zahlen werden wie üblich eingegeben, @code{1} ist die (ganze)
173 Zahl Eins, während @w{@code{-1.5}} eine Gleitkommazahl (also
174 eine nicht-ganze) ist.
177 Zeichenketten werden in doppelte Anführungszeichen gesetzt:
180 "Das ist eine Zeichenkette"
183 Zeichenketten können über mehrere Zeilen reichen:
192 und die Zeichen für eine neue Zeile am Ende jeder Zeile werden auch
193 in die Zeichenkette aufgenommen.
195 Zeichen für eine neue Zeile können auch hinzugefügt werden, indem man
196 @code{\n} in die Zeichenkette aufnimmt.
199 "das\nist eine\nmehrzeilige Zeichenkette"
202 Anführungszeichen und neue Zeilen können auch mit sogenannten
203 Fluchtsequenzen eingefügt werden. Die Zeichenkette
204 @code{a sagt "b"} wird wie folgt eingegeben:
212 Weitere zusätzliche Scheme-Datentypen, die hier nicht besprochen wurden,
213 finden sich in einer vollständigen Liste der Scheme-Datentypen in der
214 Guile-Referenzanleitung:
215 @uref{http://www.gnu.org/software/guile/manual/html_node/Simple-Data-Types.html}.
218 @node Zusammengesetzte Scheme-Datentypen
219 @subsection Zusammengesetzte Scheme-Datentypen
220 @translationof Scheme compound data types
222 Es gibt auch zusammengesetzte Datentypen in Scheme. Die Datentypen, die in
223 LilyPond häufig benutzt werden, beinhalten Paare, Listen, assoziative Listen
226 @subheading Paare (pair)
228 Der wichtigeste zusammengesetzte Datentyp in Scheme ist ein Paar (@code{pair}).
229 Wie aus dem Namen schon hervorgeht, besteht ein Paar aus zwei zusammengeschweißten
230 Werten. Die Prozedur um ein Paar zu erstellen ist @code{cons}.
238 Das Paar wird dargestellt als zwei Elemente, von Klammern umgeben
239 und durch Leerzeichen und einen Punkt (@code{.}) getrennt. Der Punkt ist
240 @emph{kein} Dezimalpunkt, sondern markiert die Gruppe als Paar.
242 Paare können auch wörtlich eingegeben werden, indem man ihnen voraus ein
243 einfaches Anführungszeichen (@code{'} setzt.
251 Beide Elemente eines Paares können beliebige gültige Scheme-Werte sein:
256 guile> '("blah-blah" . 3.1415926535)
257 ("blah-blah" . 3.1415926535)
261 Das erste Element eines Paares kann mit der Prozedur @code{car},
262 das zweite mit der Prozedur @code{cdr} angesprochen werden.
265 guile> (define mypair (cons 123 "hello there")
276 Achtung: @code{cdr} wird ausgeprochen wie "kudd-err", nach Sussman und
278 @uref{http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-14.html#footnote_Temp_133}
280 @subheading Listen (list)
282 Ein sehr häufiger Datentyp in Scheme ist die Liste (@emph{list}). Formal
283 gesehen wird eine Liste entweder als leere Liste definiert
284 (repräsentiert als @code{'()}), oder als ein Paar, dessen @code{cdr}
287 Es gibt viele Arten, Listen zu erstellen. Die vielleicht häufigste Methode
288 ist die @code{list}-Prozedur:
291 guile> (list 1 2 3 "abc" 17.5)
295 Wie man sehen kann, wird eine Liste dargestellt in Form der einzelnen
296 Elemente, getrennt durch ein Leerzeichen und als Gruppe in Klammern eingeschlossen.
297 Anders als bei einem Paar, befindet sich kein Punkt zwischen den Elementen.
299 Eine Liste kann auch als wörtliche Liste notiert werden, indem man die
300 enthaltenen Elemente in Klammern einschließt und ein einfaches Anführungszeichen
304 guile> '(17 23 "foo" "bar" "bazzle")
305 (17 23 "foo" "bar" "bazzle")
308 Listen haben eine zentrale Stellung in Scheme. Scheme wird als Dialekt
309 von Lisp angesehen, und das Wort @qq{lisp} steht für @qq{List Processing}.
310 Scheme-Ausdrücke sind immer Listen.
312 @subheading Assoziative Listen (alist)
314 Eine besonderer Listentyp ist die @emph{assoziative Liste} oder @emph{alist}.
315 Eine Alist wird benutzt, um Daten zum einfachen Abrufen zu speichern.
317 Alisten sind Listen, deren Elemente als Paare kommen. Der @code{car}-Teil
318 jedes Elements wird als @emph{Schlüssel} (key) bezeichnet, der
319 @code{cdr}-Teil jedes Elements wird @emph{Wert} (value) genannt.
320 Die Scheme-Prozedur @code{assoc} wird benutzt, um einen Eintrag aus einer
321 Aliste aufzurufen, und mit @code{cdr} wird sein Wert abgefragt:
324 guile> (define my-alist '((1 . "A") (2 . "B") (3 . "C")))
326 ((1 . "A") (2 . "B") (3 . "C"))
327 guile> (assoc 2 my-alist)
329 guile> (cdr (assoc 2 my-alist))
334 Alisten werden sehr viel in LilyPond genutzt, um Eigenschaften und
335 andere Daten zu speichern.
337 @subheading Hash-Tabellen (hash table)
339 Eine Datenstruktur, die ab und zu in LilyPond eingesetzt wird.
340 Eine Hash-Tabelle ähnelt einem Array, aber die Indexe des Arrays
341 können beliebige Scheme-Werte sein, nicht nur Integre.
343 Hash-Tabellen sind effizienter als Alisten, wenn man viele Daten
344 speichern will und die Daten sich oft ändern.
346 Die Syntax, mit der Hash-Tabellen erstellt werden, ist etwas komplex,
347 aber man kann Beispiele hierzu im LilyPond-Quellcode finden.
350 guile> (define h (make-hash-table 10))
353 guile> (hashq-set! h 'key1 "val1")
355 guile> (hashq-set! h 'key2 "val2")
357 guile> (hashq-set! h 3 "val3")
361 Werte werden aus den Hash-Tabellen mit @code{hashq-ref} ausgelesen.
364 guile> (hashq-ref h 3)
366 guile> (hashq-ref h 'key2)
371 Schlüssel und Werte werden als Paar mit @code{hashq-get-handle} ausgelesen.
372 Das ist die beste Art, weil hier @code{#f} ausgegeben wird, wenn ein
373 Schlüssel nicht gefunden werden kann.
376 guile> (hashq-get-handle h 'key1)
378 guile> (hashq-get-handle h 'frob)
384 @node Berechnungen in Scheme
385 @subsection Berechnungen in Scheme
386 @translationof Calculations in Scheme
389 We have been using lists all along. A calculation, like @code{(+ 1 2)}
390 is also a list (containing the symbol @code{+} and the numbers 1
391 and@tie{}2). Normally lists are interpreted as calculations, and the
392 Scheme interpreter substitutes the outcome of the calculation. To enter a
393 list, we stop the evaluation. This is done by quoting the list with a
394 quote @code{'} symbol. So, for calculations do not use a quote.
396 Inside a quoted list or pair, there is no need to quote anymore. The
397 following is a pair of symbols, a list of symbols and a list of lists
402 #'(staff clef key-signature)
407 Scheme kann verwendet werden, um Berechnungen durchzuführen. Es
408 verwendet eine @emph{Präfix}-Syntax. Um 1 und@tie{}2 zu addieren, muss
409 man @code{(+ 1 2)} schreiben, und nicht @math{1+2}, wie in traditioneller
417 Berechnungen können geschachtelt werden und das Ergebnis einer Berechnung
418 kann für eine neue Berechnung eingesetzt werden.
425 Diese Berechnungen sind Beispiele von Auswertungen. Ein Ausdruck
426 wie @code{(* 3 4)} wird durch seinen Wert @code{12} ersetzt.
428 Scheme-Berechnungen können zwischen Integren und Nich-Integren
429 unterscheiden. Integre Berechnungen sind exakt, während Nicht-Integre
430 nach den passenden Genauigkeitseinschränkungen berechnet werden:
439 Wenn der Scheme-Berechner einen Ausdruck antrifft, der eine Liste darstellt,
440 wird das erste Element der Liste als Prozedur behandelt, die mit
441 Argumenten des Restes der Liste ausgewertet werden. Darum sind alle
442 Operatoren in Scheme vorangestellt.
444 Wenn das erste Element eines Scheme-Ausdrucks, der eine Liste darstellt,
445 @emph{kein} Operator oder keine Prozedur ist, gibt es einen Fehler:
454 <unnamed port>:52:1: In expression (1 2 3):
455 <unnamed port>:52:1: Wrong type to apply: 1
460 Hier kann man sehen, dass Scheme versucht hat, 1 als einen Operator oder
461 eine Prozedur zu behandeln, was aber nicht möglich war. Darum der Fehler
462 "Wrong type to apply: 1".
464 Wenn man also eine Liste erstellen will, braucht man also einen Listen-Operator
465 oder man muss die Liste als wörtliches Zitat schreiben, sodass Scheme sie
466 nicht auszuwerten versucht.
476 Dieser Fehler kann durchaus vorkommen, wenn man Scheme unter LilyPond
480 The same assignment can be done in completely in Scheme as well,
483 #(define twentyFour (* 2 twelve))
486 @c this next section is confusing -- need to rewrite
488 The @emph{name} of a variable is also an expression, similar to a
489 number or a string. It is entered as
496 @cindex quoting in Scheme
498 The quote mark @code{'} prevents the Scheme interpreter from substituting
499 @code{24} for the @code{twentyFour}. Instead, we get the name
504 @node Scheme-Prozeduren
505 @subsection Scheme-Prozeduren
506 @translationof Scheme procedures
508 Scheme-Prozeduren sind ausführbare Scheme-Ausdrücke, die einen
509 Wert ausgeben, der das Resultat ihrer Ausführung darstellt. Sie können
510 auch Variablen verändern, die außerhalb dieser Prozedur definiert wurden.
512 @subheading Prozeduren definieren
514 Prozeduren werden in Scheme mit @code{define} definiert:
517 (define (function-name arg1 arg2 ... argn)
518 scheme-expression-that-gives-a-return-value)
521 Beispielsweise könnte man eine Prozedur definieren, die den Durchschnitt
525 guile> (define (average x y) (/ (+ x y) 2))
527 #<procedure average (x y)>
530 Wenn die Prozedur einmal definiert ist, wird sie aufgerufen indem man
531 die Prozedur und die Argumente in eine Liste schreibt. Man könnte also den
532 Durchschnitt von 3 und 12 berechnen:
535 guile> (average 3 12)
539 @subheading Prädikate
541 Scheme-Prozeduren, die Boolsche Werte ausgeben, werden oft als Prädikate
542 (predicate) bezeichnet. Es herrscht die Übereinkunft, Prädikat-Bezeichnungen
543 mit einem Fragezeichen abzuschließen:
546 guile> (define (less-than-ten? x) (< x 10))
547 guile> (less-than-ten? 9)
549 guile> (less-than-ten? 15)
553 @subheading Wiedergabe-Werte
555 Scheme-Prozeduren geben immer einen Wiedergabe-Wert (return value) aus, welcher
556 der Wert des letzten Ausdrucks ist, der in der Prozedur ausgeführt wurde. Der
557 Wiedergabewert kann ein beliebiger gültiger Scheme-Wert sein, auch eine
558 komplexe Datenstruktur oder eine Prozedur.
560 Manchmal würden Benutzer gerne mehrere Scheme-Ausdrucke in einer Prozedur haben.
561 Es gibt zwei Arten, wie merhere Ausdrücke kombiniert werden können. Die erste
562 Art ist die @code{begin}-Prozedur, der es ermöglicht, dass mehrere Ausdrücke
563 ausgewertet werden und den Wert des letzten Ausdrucks wiedergibt.
566 guile> (begin (+ 1 2) (- 5 8) (* 2 2))
570 Die andere Art, mehrere Ausdrücke zu kombinieren, ist eine @code{let}-Umgebung.
571 In dieser Umgebung wird eine Serie von Verbindungen erstellt, und dann wird eine
572 Sequenz von Ausdrücken ausgewertet, die diese Bindungen einschließen können.
573 Der Wiedergabewert der let-Umgebung ist der Wiedergabewert der letzten Aussage
577 guile> (let ((x 2) (y 3) (z 4)) (display (+ x y)) (display (- z 4))
578 ... (+ (* x y) (/ z x)))
583 @node Scheme-Konditionale
584 @subsection Scheme-Konditionale
585 @translationof Scheme conditionals
589 Scheme hat eine @code{if}-Prozedur:
592 (if test-expression true-expression false-expression)
595 @var{test-expression} ist ein Ausdruck, der einen Booleschen
596 Wert zurück gibt. Wenn @var{test-expression} den Wert @code{#t}
597 ausgibt, gibt die if-Prozedur den Wert von @var{true-expression} aus,
598 in allen anderen Fällen den Wert von @var{false-expression}.
603 guile> (if (> a b) "a is greater than b" "a is not greater than b")
604 "a is not greater than b"
609 Eine andere konditionale Prozedur in Scheme ist
613 (cond (test-expression-1 result-expression-sequence-1)
614 (test-expression-2 result-expression-sequence-2)
616 (test-expression-n result-expression-sequence-n))
624 guile> (cond ((< a b) "a is less than b")
625 ... ((= a b) "a equals b")
626 ... ((> a b) "a is greater than b"))
632 @node Scheme in LilyPond
633 @section Scheme in LilyPond
634 @translationof Scheme in LilyPond
637 * LilyPond Scheme-Syntax::
638 * LilyPond-Variablen::
639 * Eingabe-Variablen und Scheme::
640 * Objekteigenschaften::
641 * Zusammengesetzte LilyPond-Variablen::
642 * Interne musikalische Repräsentation::
645 @node LilyPond Scheme-Syntax
646 @subsection LilyPond Scheme-Syntax
647 @translationof LilyPond Scheme syntax
652 Der Guile-Auswerter ist ein Teil von LilyPond, sodass Scheme also auch in
653 normale LilyPond-Eingabedateien eingefügt werden kann. Es gibt mehrere
654 Methoden, um Scheme in LilyPond zu integrieren.
656 Die einfachste Weise ist es, ein Rautenzeichen@tie{}@code{#} vor einem
657 Scheme-Ausdruck zu benutzen.
659 Die Eingabe von LilyPond ist in Zeichen und Ausdrücke gegliedert, so etwa
660 wie die menschliche Sprache sich in Wörter und Sätze gliedert. LilyPond
661 hat einen Lexer, der Zeichen erkennt (Zahlen, Zeichenketten, Scheme-Elemente,
662 Tonhöhen usw.) und einen Parser, der die Syntax versteht, @ruser{LilyPond grammar}.
663 Wenn dann eine bestimmte Syntaxregel als zuständig erkannt wurde, werden die
664 damit verknüpften Aktionen ausgeführt.
666 Die Rautenzeichenmethode (@code{#}), mit der Scheme eingebettet werden kann,
667 passt sehr gut in dieses System. Wenn der Lexer ein Rautenzeichen sieht, ruft
668 er den Scheme-reader auf, um den ganzen Scheme-Ausdruck zu lesen (das kann eine
669 Variable, ein Ausdruck in Klammern oder verschiedene andere Sachen sein). Nachdem
670 der Scheme-Ausdruck gelesen wurde, wird er als Wert eines @code{SCM_TOKEN} in der
671 Grammatik gespeichert. Wenn der Parser weiß, wie er diesen Wert benutzen kann,
672 ruft er Guile auf, um den Scheme-Ausdruck auszuwerten. Weil der Parser normalerweise
673 dem Lexer etwas voraus sein muss, ist die Trennung von Lesen und Auswerten zwischen
674 Lexer und Parser genau das richtige, um die Auswertung von LilyPond- und
675 Scheme-Ausdrücken synchron zu halten. Aus diesem Grund sollte das Rautenzeichen
676 zum Einbinden von Scheme immer benutzt werden, wenn es möglich ist.
678 Eine andere Möglichkeit, Scheme aufzurufen, ist die Benutzung des Dollarzeichens
679 (@code{$}) anstelle der Raute. In diesem Fall wertet LilyPond den Code sofort
680 aus, nachdem der Lexer ihn gelesen hat. Dabei wird der resultierende
681 Scheme-Ausdruckstyp geprüft und eine Tokentyp dafür ausgesucht (einer von mehreren
682 @code{xxx_IDENTIFIER} in der Syntax). Wenn der Wert des Ausdrucks gültig ist
683 (der Guilde-Wert für @code{*unspecified*}), dann wird nichts an den Parser
686 Das ist auch der gleiche Mechanismus, nach dem LilyPond funktioniert, wenn man eine Variable oder musikalische Funktion mit ihrer Bezeichnung ausruft, wie
687 in @code{\Bezeichnung}, mit dem einzigen Unterschied, dass ihr Ende durch den
688 LilyPond-Lexer bestimmt wird, ohne den Scheme-reader einzubeziehen, und also
689 nur Variablen akzeptiert werden, die im aktuellen LilyPond-Modus gültig sind.
691 Die direkte Auswirkung von @code{$} kann zu Überraschungen führen, siehe auch
692 @ref{Eingabe-Variablen und Scheme}. Es bietet sich daher an, @code{#} immer
693 zu benützen, wenn der Parser es unterstützt.
695 Jetzt wollen wir uns tatsächlichen Scheme-Code anschauen. Scheme-Prozeduren
696 können in LilyPond-Eingabedateien definiert werden:
699 #(define (average a b c) (/ (+ a b c) 3))
702 LilyPond-Kommentare (@code{%} oder @code{%@{ %@}}) können innerhalb
703 von Scheme-Code nicht benutzt werden, nicht einmal in einer LilyPond-Eingabedatei,
704 weil der Guile-Interpreter und nicht der LilyPond-Parser den Scheme-Ausdruck
705 liest. Kommentare in Guile Scheme werden wie folgt notiert:
708 ; Einzeiliges Kommentar
711 Guile-Stil Blockkommentar (nicht schachtelbar)
712 Diese Kommentare werden von Scheme-Programmierern
713 selten benutzt und nie im Quellcode
718 Für den Rest dieses Abschnitts soll angenommen werden, dass die Daten in
719 einer LilyPond-Eingabedatei notiert werden sollen, sodass immer@tie{}@code{#}
720 vor die Scheme-Ausdrücke gestellt wird.
722 Alle Scheme-Ausdrücke auf oberster Ebene in einer LilyPond-Eingabedatei
723 können in einen einzigen Scheme-Ausdruck zusammengefasst werden mit
733 @node LilyPond-Variablen
734 @subsection LilyPond-Variablen
735 @translationof LilyPond variables
737 LilyPond-Variablen werden intern als Scheme-Variablen gespeichert. Darum
751 Das bedeutet, dass Scheme-Ausdrücke auf LilyPond-Variablen zugreifen können.
752 Man könnte also schreiben:
755 Vierundzwanzig = #(* 2 Zwoelf)
759 was zur Folge hätte, dass die Zahl 24 in der LilyPond (und Scheme-)Variablen
760 @code{Vierundzwanzig} gespeichert wird.
762 Üblicherweise greift man auf LilyPond-Variablen zu, indem man ihnen einen
763 Backslash voranstellt. Siehe auch @ref{LilyPond Scheme-Syntax}, also etwa
764 @code{\Vierundzwanzig}. Weil dadurch eine Kopie des Wertes für die meisten
765 von LilyPonds internen Typen erstellt wird (insbesondere musikalische Funktionen),
766 erstellen musikalische Funktionen normalerweise Kopien von Material, das sie
767 verändern. Aus diesem Grund sollten musikalische Funktionen, die mit @code{#}
768 aufgerufen werden, kein Material enthalten, dass entweder von Grund auf neu
769 erstellt wird oder explizit kopiert wird, sondern besser direkt auf das relevante
773 @node Eingabe-Variablen und Scheme
774 @subsection Eingabe-Variablen und Scheme
775 @translationof Input variables and Scheme
777 Das Eingabeformat unterstützt die Notation von Variablen: Im folgenden
778 Beispiel wird ein musikalischer Ausdruck einer Variablen mit der
779 Bezeichnung @code{traLaLa} zugewiesen:
782 traLaLa = @{ c'4 d'4 @}
785 Variablen haben beschränkte Geltungsbereiche: im unten stehenden Beispiel
786 enthält auch die @code{\layout}-Umgebung eine @code{traLaLa}-Variable,
787 die sich aber von der @code{traLaLa}-Variable auf oberster Ebene unterscheidet:
790 traLaLa = @{ c'4 d'4 @}
791 \layout @{ traLaLa = 1.0 @}
794 Jede Eingabedatei ist solch ein Gültigkeitsbereich, und alle
795 @code{\header}-, @code{\midi}- und @code{\layout}-Umgebungen
796 sind Gültigkeitsbereiche, die in diesen obersten Gültigkeitsbereich
799 Sowohl Variablen als auch Gültigkeitsbereiche sind im Guile Modulsystem
800 eingebaut. Ein anonymes Scheme-Modul wird jedem Gültigkeitsbereich
801 angehängt. Eine Zuweisen in der Form von
804 traLaLa = @{ c'4 d'4 @}
808 wird intern in die Scheme-Definition
811 (define traLaLa @var{Scheme-Wert von `@code{... }'})
817 Das bedeutet, dass LilyPond-Variablen und Scheme-Variablen frei gemischt
818 werden können. Im folgenden Beispiel wird ein Notenfragment in der
819 Variable @code{traLaLa} gespeichert und mit Scheme dupliziert. Das
820 Resultat wird in eine @code{\score}-Umgebung mit einer weiteren
821 Variable @code{twice} importiert:
824 traLaLa = { c'4 d'4 }
826 #(define newLa (map ly:music-deep-copy
827 (list traLaLa traLaLa)))
829 (make-sequential-music newLa))
834 Das ist ein interessantes Beispiel. Die Zuweisung findet erst statt,
835 nachdem der Parser sichergestellt hat, dass nichts folgt, das Ähnlichkeit
836 mit @code{\addlyrics} hat, sodass er prüfen muss, was als nächstes kommt.
837 Er liest @code{#} und den darauf folgenden Scheme-Ausdruck, @emph{ohne} ihn
838 auszuwerten, so dass er weiterlesen und erst @emph{danach}
839 wird der Scheme-Code ohne Probleme ausführen kann.
841 Das Beispiel zeigt, wie man musikalische Ausdrücke aus der Eingabe in den
842 Scheme-Auswerter @qq{exportieren} kann. Es geht auch andersherum. Indem
843 man Scheme-Werte nach @code{$} schreibt, wird ein
844 Scheme-Wert interpretiert, als ob er in LilyPond-Syntax eingeben wäre.
845 Anstatt @code{\twice} zu definieren, könne man also auch schreiben:
849 @{ $(make-sequential-music (list newLa)) @}
852 Mann kann @code{$} zusammen mit einem Scheme-Ausdruck überall benutzen,
853 wo auch @code{\@var{Bezeichnung}} gültig wäre, nachdem der Scheme-Ausdruck
854 einmal einer Variable @var{Bezeichnung} zugewiesen worden ist. Der Austausch
855 geschieht im Lexer, sodass LilyPond den Unterschied gar nicht merkt.
857 Ein negativer Effekt ist aber das Timing. Wenn man @code{$} anstelle von
858 @code{#} für die Definition von @code{newLa} im obigen Beispiel eingesetzt
859 hätte, würde der folgende Scheme-Ausdruck fehlschlagen, weil @code{traLaLa}
860 noch nicht definiert worden wäre. Zu einer Erklärung dieses Timingproblems
861 siehe @ref{LilyPond Scheme-Syntax}.
863 Auf jeden Fall findet die Auswertung des Scheme-Codes spätestens im Parser
864 statt. Wenn man es noch später ausgeführt haben möchte, muss man
865 @ref{Leere Scheme-Funktionen} benutzen oder es in einem Makro speichern:
869 (ly:set-option 'point-and-click #f))
878 Scheme- und LilyPond-Variablen können nicht gemischt werden, wenn man die
879 @option{--safe}-Option benutzt.
882 @node Objekteigenschaften
883 @subsection Objekteigenschaften
884 @translationof Object properties
886 Objekteigenschaften werden in LilyPond in Form von Alisten-Ketten
887 gespeichert, also als Listen von Alisten. Eigenschaften werden
888 geändert, indem man Werte an den Anfang der Eigenschaftsliste
889 hinzufügt. Eigenschaften werden gelesen, indem Werte aus der
890 Aliste gelesen werden.
892 Ein neuer Wert für eine Eigenschaft kann gesetzt werden, indem man
893 der Alist einen Wert mit Schlüssel und dem Wert zuweist. Die
894 LilyPond-Syntax hierfür ist:
897 \override Stem #'thickness = #2.6
900 Diese Anweisung verändert die Erscheinung der Notenhälse. Der Alist-Eintrag
901 @code{'(thickness . 2.6)} wird zu der Eigenschaftsliste eines
902 @code{Stem}-(Hals-)Objektes hinzugefügt.
903 @code{thickness} wird relativ zu den Notenlinien errechnet, in diesem
904 Fall sind die Hälse also 2,6 mal so dick wie die Notenlinien. Dadurch
905 werden Hälse fast zweimal so dick dargestellt, wie sie normalerweise sind.
906 Um zwischen Variablen zu unterscheiden, die in den Quelldateien direkt
907 definiert werden (wie @code{Vierundzwanzig} weiter oben), und zwischen denen,
908 die für interne Objekte zuständig sind, werden hier die ersteren
909 @qq{Variablen} genannt, die letzteren dagegen @qq{Eigenschaften}.
910 Das Hals-Objekt hat also eine @code{thickness}-Eigenschaft, während
911 @code{Vierundzwanzig} eine Variable ist.
913 @cindex Eigenschaften versus Bezeichner
914 @cindex Bezeichner versus Eigenschaften
917 @node Zusammengesetzte LilyPond-Variablen
918 @subsection Zusammengesetzte LilyPond-Variablen
919 @translationof LilyPond compound variables
921 @subheading Abstände (offset)
923 Zweidimensionale Abstände (X- und Y-Koordinaten) werden
924 als @emph{pairs} (Paare) gespeichert. Der @code{car}-Wert des
925 Abstands ist die X-Koordinate und der @code{cdr}-Wert die
929 \override TextScript #'extra-offset = #'(1 . 2)
932 Hierdurch wird das Paar @code{(1 . 2)} mit der Eigenschaft @code{extra-offset}
933 des TextScript-Objektes verknüpft. Diese Zahlen werden in
934 Systembreiten gemessen, so dass der Befehl das Objekt eine Systembreite
935 nach rechts verschiebt und zwei Breiten nach oben.
937 Prozeduren, um mit Abständen zu arbeiten, finden sich in @file{scm/lily-library.scm}.
939 @subheading Brüche (fractions)
941 Brüche, wie sie LilyPond benutzt, werden wiederum als Paare gespeichert,
942 dieses Mal als unbezeichnete ganze Zahlen. Während Scheme rationale Zahlen
943 als einen negativen Typ darstellen kann, sind musikalische gesehen
944 @samp{2/4} und @samp{1/2} nicht das selbe, sodass man zwischen beiden unterscheiden
945 können muss. Ähnlich gibt es auch keine negativen Brüche in LilyPonds Sinn.
946 Somit bedeutet @code{2/4} in LilyPond @code{(2 . 4)} in Scheme, und @code{#2/4} in
947 LilyPond bedeutet @code{1/2} in Scheme.
949 @subheading Bereiche (extend)
951 Paare werden auch benutzt, um Intervalle zu speichern, die einen Zahlenbereich
952 vom Minimum (dem @code{car}) bis zum Maximum (dem @code{cdr}) darstellen.
953 Intervalle werden benutzt, um die X- und Y-Ausdehnung von druckbaren
954 Objekten zu speichern. Bei X-Ausdehnungen ist @code{car} die linke
955 X-Koordinate und @code{cdr} die rechte X-Koordinate. Für Y-Ausdehnungen
956 ist @code{car} die untere Koordinate und @code{cdr} die obere Koordinate.
958 Prozeduren, um mit Intervallen zu arbeiten, finden sich in
959 @file{scm/lily-library.scm}. Diese Prozeduren sollten benutzt, wenn es möglich
960 ist, um den Code konsistent zu halten.
962 @subheading Eigenschafts-Alisten (property alist)
964 Eine Eigenschafts-Aliste ist eine LilyPond-Datenstruktur, die eine Aliste
965 darstellt, deren Schlüssel Eigenschaften sind und deren Werte
966 Scheme-Ausdrücke sind, die den erwünschen Wert der Eigenschaft ausgeben.
968 LilyPond-Eigenschaften sind Scheme-Symbole, wie etwa @code{'thickness}
971 @subheading Alisten-Ketten (alist chains)
973 Eine Alisten-Kette ist eine Liste, die Eigenschafts-Alisten enthält.
975 Die Menge aller Eigenschaften, die sich auf einen Grob auswirken, wird
976 typischerweise in einer Alisten-Kette gespeichert. Um den Wert einer
977 bestimmten Eigenschaft zu finden, die ein Grob haben soll, wird jede
978 Liste in der Kette nach einander durchsucht, wobei nach einem Eintrag
979 geschaut wird, der den Eigenschaftsschlüssel enthält. Der erste
980 gefundene Alisten-Eintrag wird benutzt und dessen Wert ist der
981 Wert der Eigenschaft.
983 Die Scheme-Prozedur @code{chain-assoc-get} wird normalerweise benutzt,
984 um Grob-Eigenschaftenwerte zu erhalten.
987 @node Interne musikalische Repräsentation
988 @subsection Interne musikalische Repräsentation
989 @translationof Internal music representation
991 Intern werden Noten als Scheme-Liste dargestellt. Die Liste enthält
992 verschiedene Elemente, die die Druckausgabe beeinflussen. Parsen
993 nennt man den Prozess, der die Noten aus der LilyPond-Repräsentation
994 in die interne Scheme-Repräsentation überführt.
996 Wenn ein musikalischer Ausdruck geparst wird, wird er in eine Gruppe
997 von Scheme-Musikobjekten konvertiert. Die definierende Eigenschaft
998 eines Musikobjektes ist, dass es Zeit einnimmt. Die Zeit, die
999 ein Objekt braucht, wird Dauer (engl. @emph{duration}) genannt.
1000 Dauern werden in rationalen Zahlen ausgedrückt, die die Länge des
1001 Musikobjekts in Ganzen Noten angeben.
1003 Ein Musikobjekt hat drei Typen:
1007 Musikbezeichnung (music name): Jeder Musikausdruck hat eine Bezeichnung. Eine
1008 Note beispielsweise erzeugt ein @rinternals{NoteEvent} und @code{\simultaneous}
1009 produziert @rinternals{SimultaneousMusic}. Eine Liste aller möglichen
1010 Ausdrücke findet sich in der Referenz der Interna, unter
1011 @rinternals{Music expressions}.
1014 Typ (type) oder Schnittstelle (interface): Jede Musikbezeichnung hat mehrere
1015 Typen oder Schnittstellen, beispielsweise eine Note ist ein Ereignis (@code{event}),
1016 aber auch ein Notenereignis (@code{note-event}), ein rhythmisches Ereignis
1017 (@code{rhythmic-event}) und ein Melodieereignis (@code{melodic-event}).
1018 Alle Musikklassen sind in der Referenz der Interna aufgelistet, unter
1019 @rinternals{Music classes}.
1022 C++-Objekt: Jedes Musikobjekt ist durch ein Objekt der C++-Klasse @code{Music}
1026 Die eigentliche Information eines musikalischen Ausdrucks wird in Eigenschaften
1027 gespeichert. Ein @rinternals{NoteEvent} beispielsweise hat die Eigenschaften
1028 Tonhöhe (@code{pitch}) und Dauer (@code{duration}), die die Dauer und die
1029 Tonhöhe der Note speichern. Eine Liste aller möglichen Eigenschaften findet
1030 sich in der Referenz der Interna, unter
1031 @rinternals{Music properties}.
1033 Ein zusammengesetzter musikalischer Ausdruck ist ein Musikobjekt, das andere
1034 Musikobjekte als Eigenschaften enthält. Eine Liste an Objekten kann in der
1035 @code{elements}-Eigenschaft eines Musikobjekts bzw. ein einziges
1036 Ableger-Musikelement in der @code{element}-Eigenschaft gespeichert werden.
1037 @rinternals{SequentialMusic} beispielsweise hat sein einziges Argument in
1038 @code{element}. Der Körper einer Wiederholung wird in der @code{element}-Eigenschaft
1039 von @rinternals{RepeatedMusic} gespeichert, und die alternativen Endungen
1043 @node Komplizierte Funktionen erstellen
1044 @section Komplizierte Funktionen erstellen
1045 @translationof Building complicated functions
1047 Dieser Abschnitt zeigt, wie man Information zusammensucht,
1048 um komplizierte musikalische Funktionen zu erstellen.
1051 * Musikalische Funktionen darstellen::
1052 * Eigenschaften von Musikobjekten::
1053 * Verdoppelung einer Note mit Bindebögen (Beispiel)::
1054 * Artikulationszeichen zu Noten hinzufügen (Beispiel)::
1058 @node Musikalische Funktionen darstellen
1059 @subsection Musikalische Funktionen darstellen
1060 @translationof Displaying music expressions
1062 @cindex interne Speicherung
1063 @cindex Musikausdrücke anzeigen
1064 @cindex Anzeigen von Musikausdrücken
1066 @funindex displayMusic
1067 @funindex \displayMusic
1069 Wenn man eine musikalische Funktion erstellt, ist es oft
1070 hilfreich sich anzuschauen, wie musikalische Funktionen
1071 intern gespeichert werden. Das kann mit der Funktion
1072 @code{\displayMusic} erreicht werden:
1076 \displayMusic @{ c'4\f @}
1091 'AbsoluteDynamicEvent
1095 (ly:make-duration 2 0 1 1)
1097 (ly:make-pitch 0 0 0))))
1100 Normalerweise gibt LilyPond diese Ausgabe auf der Konsole mit
1101 allen anderen Nachrichten aus. Um die wichtigen Nachrichten
1102 in einer Datei zu speichern, kann die Ausgabe in eine Datei
1106 lilypond file.ly >display.txt
1109 Mit LilyPond- und Scheme-Magie kann man LilyPond anweisen, genau
1110 diese Ausgabe an eine eigene Datei zu senden:
1114 $(with-output-to-file "display.txt"
1115 (lambda () #@{ \displayMusic @{ c'4\f @} #@}))
1119 Mit etwas Umformatierung ist die gleiche Information sehr viel
1123 (make-music 'SequentialMusic
1125 (make-music 'NoteEvent
1126 'articulations (list
1127 (make-music 'AbsoluteDynamicEvent
1130 'duration (ly:make-duration 2 0 1 1)
1131 'pitch (ly:make-pitch 0 0 0))))
1134 Eine musikalische @code{@{ ... @}}-Sequenz hat die Bezeichnung
1135 @code{SequentialMusic} und ihre inneren Ausdrücke werden als
1136 Liste in seiner @code{'elements}-Eigenschaft gespeichert. Eine
1137 Note ist als als ein @code{EventChord}-Objekt dargestellt (welches Dauer und
1138 Tonhöhe speichert) und zusätzliche Information enthält (in
1139 diesem Fall ein @code{AbsoluteDynamicEvent} mit einer
1140 @code{"f"}-Text-Eigenschaft).
1144 @code{\displayMusic} gibt die Noten aus, die dargestellt werden, sodass
1145 sie sowohl angezeigt als auch ausgewertet werden. Um die Auswertung zu
1146 vermeiden, kann @code{\void} vor @code{\displayMusic} geschrieben werden.
1149 @node Eigenschaften von Musikobjekten
1150 @subsection Eigenschaften von Musikobjekten
1151 @translationof Music properties
1153 TODO -- make sure we delineate between @emph{music} properties,
1154 @emph{context} properties, and @emph{layout} properties. These
1155 are potentially confusing.
1157 Schauen wir uns ein Beispiel an:
1161 \displayMusic \someNote
1166 (ly:make-duration 2 0 1 1)
1168 (ly:make-pitch 0 0 0))
1171 Das @code{NoteEvent}-Objekt ist die Repräsentation von @code{someNote}.
1172 Einfach. Wie fügt man denn ein c' in einen Akkorde ein?
1176 \displayMusic \someNote
1184 (ly:make-duration 2 0 1 1)
1186 (ly:make-pitch 0 0 0))))
1189 Jetzt ist das @code{NoteEvent}-Objekt das erste Objekt der
1190 @code{'elements}-Eigenschaft von @code{someNote}.
1192 Die @code{display-scheme-music}-Funktion ist die Funktion, die von
1193 @code{\displayMusic} eingesetzt wird, um die Scheme-Repräsentation
1194 eines musikalischen Ausdrucks anzuzeigen.
1197 #(display-scheme-music (first (ly:music-property someNote 'elements)))
1202 (ly:make-duration 2 0 1 1)
1204 (ly:make-pitch 0 0 0))
1207 Danach wird die Tonhöhe der Note von der @code{'pitch}-Eigenschaft
1208 des @code{NoteEvent}-Objektes gelesen:
1211 #(display-scheme-music
1212 (ly:music-property (first (ly:music-property someNote 'elements))
1215 (ly:make-pitch 0 0 0)
1218 Die Tonhöhe einer Note kann geändert werden, indem man diese
1219 @code{'pitch}-Eigenschaft umdefiniert:
1221 @funindex \displayLilyMusic
1222 @funindex displayLilyMusic
1225 #(set! (ly:music-property (first (ly:music-property someNote 'elements))
1227 (ly:make-pitch 0 1 0)) ;; Die Tonhöhen auf d' verändern.
1228 \displayLilyMusic \someNote
1234 @node Verdoppelung einer Note mit Bindebögen (Beispiel)
1235 @subsection Verdoppelung einer Note mit Bindebögen (Beispiel)
1236 @translationof Doubling a note with slurs (example)
1238 In diesem Abschnitt soll gezeigt, werden, wie man eine
1239 Funktion erstellt, die eine Eingabe wie @code{a}
1240 nach @code{@{ a( a) @}} umdefiniert. Dazu wird zuerst die
1241 interne Repräsentation der Musik betrachtet, die
1242 das Endergebnis darstellt:
1245 \displayMusic@{ a'( a') @}
1258 (ly:make-duration 2 0 1 1)
1260 (ly:make-pitch 0 5 0))
1269 (ly:make-duration 2 0 1 1)
1271 (ly:make-pitch 0 5 0))))
1274 Eine schlechte Nachricht ist, dass die
1275 @code{SlurEvent}-Ausdrücke @qq{innerhalb}
1276 der Noten (in ihrer @code{articulations}-Eigenschaft) hinzugefügt werden müssen.
1278 Jetzt folgt eine Betrachtung der Eingabe:
1286 (ly:make-duration 2 0 1 1)
1288 (ly:make-pitch 0 5 0))))
1291 In der gewünschten Funktion muss also dieser Ausdruck
1292 kopiert werden (sodass zwei Noten vorhanden sind, die
1293 eine Sequenz bilden), dann müssen @code{SlurEvent}
1294 zu der @code{'articulations}-Eigenschaft jeder Noten hinzugefügt
1295 werden, und schließlich muss eine @code{SequentialMusic}
1296 mit den beiden @code{EventChords} erstellt werden. Um zu
1297 einer Eigenschaft etwas hinzuzufügen, ist es nützlich zu wissen, dass
1298 eine nicht gesetzte Eigenschaft als @code{'()} gelesen wird, sodass
1299 keine speziellen Überprüfungen nötig sind, bevor ein anderes
1300 Element vor die @code{articulations}-Eigenschaft gesetzt wird.
1303 doubleSlur = #(define-music-function (parser location note) (ly:music?)
1304 "Return: @{ note ( note ) @}.
1305 `note' is supposed to be a single note."
1306 (let ((note2 (ly:music-deep-copy note)))
1307 (set! (ly:music-property note 'articulations)
1308 (cons (make-music 'SlurEvent 'span-direction -1)
1309 (ly:music-property note 'articulations)))
1310 (set! (ly:music-property note2 'articulations)
1311 (cons (make-music 'SlurEvent 'span-direction 1)
1312 (ly:music-property note2 'articulations)))
1313 (make-music 'SequentialMusic 'elements (list note note2))))
1317 @node Artikulationszeichen zu Noten hinzufügen (Beispiel)
1318 @subsection Artikulationszeichen zu Noten hinzufügen (Beispiel)
1319 @translationof Adding articulation to notes (example)
1321 Am einfachsten können Artikulationszeichen zu Noten
1322 hinzugefügt werden, indem man zwei musikalische Funktionen
1323 in einen Kontext einfügt, wie erklärt in
1324 @ruser{Kontexte erstellen}. Hier soll jetzt eine musikalische
1325 Funktion entwickelt werden, die das vornimmt. Daraus ergibt sich
1326 der zusätzliche Vorteil, dass diese musikalische Funktion eingesetzt
1327 werden kann, um eine Artikulation (wie etwa eine Fingersatzanweisung)
1328 einer einzigen Note innerhalb eines Akkordes hinzugefügt werden
1329 kann, was nicht möglich ist, wenn einfach unabhängige Noten ein einem
1330 Kontext miteinander verschmolzen werden.
1332 Eine @code{$variable} innerhalb von @code{#@{...#@}} ist das
1333 gleiche wie die normale Befehlsform @code{\variable} in
1334 üblicher LilyPond-Notation. Es ist bekannt dass
1341 in LilyPond nicht funktioniert. Das Problem könnte vermieden
1342 werden, indem das Artikulationszeichen an eine Pseudonote
1346 @{ << \music s1*0-.-> @}
1350 aber in diesem Beispiel soll gezeigt werden, wie man das in
1351 Scheme vornimmt. Zunächst wird die Eingabe und die gewünschte
1361 (ly:make-duration 2 0 1 1)
1363 (ly:make-pitch -1 0 0))))
1365 % gewünschte Ausgabe
1376 (ly:make-duration 2 0 1 1)
1378 (ly:make-pitch -1 0 0))
1387 (ly:make-duration 2 0 1 1)
1389 (ly:make-pitch -1 0 0))))
1392 Dabei ist zu sehen, dass eine Note (@code{c4}) als @code{NoteEvent}-Ausdruck
1393 repräsentiert ist. Um eine Akzent-Artikulation hinzuzufügen, muss
1394 ein @code{ArticulationEvent}-Ausdruck zu der Elementeigenschaft @code{articulations}
1395 des @code{NoteEvent}-Ausdrucks hinzugefügt werden.
1397 Um diese Funktion zu bauen, wird folgendermaßen begonnen:
1400 (define (add-accent note-event)
1401 "Add an accent ArticulationEvent to the articulations of `note-event',
1402 which is supposed to be a NoteEvent expression."
1403 (set! (ly:music-property note-event 'articulations)
1404 (cons (make-music 'ArticulationEvent
1405 'articulation-type "accent")
1406 (ly:music-property note-event 'articulations)))
1410 Die erste Zeile definiert eine Funktion in Scheme: Die Bezeichnung
1411 der Funktion ist @code{add-accent} und sie hat eine Variable
1412 mit der Bezeichnung @code{note-event}. In Scheme geht der Typ
1413 einer Variable oft direkt aus der Bezeichnung hervor (das ist auch
1414 eine gute Methode für andere Programmiersprachen).
1421 ist eine (englische) Beschreibung, was diese Funktion tut. Sie ist
1422 nicht unbedingt notwendig, aber genauso wie klare Variablen-Bezeichnungen
1423 ist auch das eine gute Methode.
1425 Es kann seltsam scheinen, warum das Notenereignis direkt verändert wird,
1426 anstatt mit einer Kopie zu arbeiten (@code{ly:music-deep-copy} kann dafür
1427 benützt werden). Der Grund ist eine stille Übereinkunft: musikalische
1428 Funktionen dürfen ihre Argumente verändern: sie werden entweder von
1429 Grund auf erstellt (wie Eingabe des Benutzers) oder sind schon kopiert
1430 (etwa Verweis auf eine Variable mit @samp{\Bezeichnung} oder Noten aus
1431 einem Scheme-Ausdruck @samp{$(@dots{})} sind Kopien). Weil es uneffizient
1432 wäre, unnötige Kopien zu erstellen, wird der Wiedergabewert einer musikalischen
1433 Funktion @emph{nicht} kopiert. Um sich also an die Übereinkunft zu halten,
1434 dürfen Argumente nicht mehr als einmal benützt werden, und sie wiederzugeben
1435 zählt als eine Benutzung.
1437 In einem früheren Beispiel wurden Noten konstruiert, indem ein musikalisches
1438 Argument wiederholt wurde. In diesem Fall muss wenigstens eine Wiederholung
1439 eine Kopie ihres Arguments sein. Wenn es keine Kopie ist, können seltsame
1440 Dinge passieren. Wenn man beispielsweise @code{\relative} oder @code{\transpose}
1441 auf die resultierenden Noten anwendet, die die gleichen Elemente mehrmals
1442 enthalten, werden die Elemente mehrmals der @code{\relative}-Veränderung
1443 oder Transposition unterworfen. Wenn man sie einer musikalischen Variable
1444 zuweist, wird dieser Fluch aufgehoben, denn der Verweis auf @samp{\Bezeichnung}
1445 erstellt wiederum eine Kopie, die nicht die Identität der wiederholten
1448 Während die Funktion oben keine musikalische Funktion ist, wird sie
1449 normalerweise inmitten musikalischer Funktionen eingesetzt. Darum
1450 ist es sinnvoll, der gleichen Übereinkunft zu folgen, die für musikalische
1451 Funktionen gelten: Die Eingabe kann verändert worden sein, um die
1452 Ausgabe zu produzieren, und der den Aufruf erstellt, ist verantwortlich
1453 für die Erstellung von Kopien, wenn er immernoch die unveränderten
1454 Argumente benötigt. Wenn man sich LilyPonds eigene Funktionen wie etwa
1455 @code{music-map} anschaut, sieht man, dass sie denselben Prinzipien folgen.
1457 Aber wo waren wir? Jetzt gibt es ein @code{note-event}, das verändert
1458 werden kann, nicht unter Einsatz von @code{ly:music-deep-copy} sondern
1459 aufgrund einer langen Erklärung. Der Akzent wird zu seiner
1460 @code{'articulations}-Liste hinzugefügt:
1463 (set! place neuer-Wert)
1466 Was in diesem Fall @qq{gesetzt} werden soll (@qq{place}) ist die
1467 @q{'articulations}-Eigenschaft des @code{note-event}-Ausdrucks.
1470 (ly:music-property note-event 'articulations)
1473 @code{ly:music-property} ist die Funktion, mit der musikalische
1474 Eigenschaften erreicht werden können (die @code{'articulations},
1475 @code{'duration}, @code{'pitch} usw., die in der Ausgabe von
1476 @code{\displayMusic} weiter oben angezeigt werden). Der neue
1477 Wert ist, was ehemals die @code{'articulations}-Eigenschaft war, mit einem
1478 zusätzlichen Element: dem @code{ArticulationEvent}-Ausdruck,
1479 der aus der Ausgabe von @code{\displayMusic} kopiert werden kann:
1482 (cons (make-music 'ArticulationEvent
1483 'articulation-type "accent")
1484 (ly:music-property result-event-chord 'articulations))
1487 @code{cons} wird benutzt, um ein Element vorne an eine Liste hinzuzufügen,
1488 ohne dass die originale Liste verändert wird. Das ist es, was die
1489 Funktion tun soll: die gleiche Liste wie vorher, aber mit dem neuen
1490 @code{ArticulationEvent}-Ausdruck. Die Reihenfolge innerhalb
1491 der Elementeeigenschaft ist hier nicht relevant.
1493 Wenn schließlich die Akzent-Artikulation zu der entsprechenden
1494 @code{elements}-Eigenschaft hinzugefügt ist, kann
1495 @code{note-event} ausgegeben werden, darum die letzte Zeile
1498 Jetzt wird die @code{add-accent}-Funktion in eine musikalische
1499 Funktion umgewandelt (hierzu gehört etwas syntaktischer Zuckerguß und
1500 eine Deklaration des Typs ihres einzigen @qq{wirklichen} Arguments:
1503 addAccent = #(define-music-function (parser location note-event)
1505 "Add an accent ArticulationEvent to the articulations of `note-event',
1506 which is supposed to be a NoteEvent expression."
1507 (set! (ly:music-property note-event 'articulations)
1508 (cons (make-music 'ArticulationEvent
1509 'articulation-type "accent")
1510 (ly:music-property note-event 'articulations)))
1514 Eine Überprüfung, dass die Funktion richtig arbeitet, geschieht
1518 \displayMusic \addAccent c4
1525 * Optimierungen mit Scheme::
1528 @c node Optimierungen mit Scheme
1529 @c appendixsec Optimierungen mit Scheme
1530 @c translationof Tweaking with Scheme
1532 Wir haben gesehen wie LilyPond-Eingabe massiv beeinflusst
1533 werden kann, indem Befehle wie etwa
1534 @code{\override TextScript #'extra-offset = ( 1 . -1)}
1535 benutzt werden. Aber es wurde gezeigt, dass Scheme noch
1536 mächtiger ist. Eine bessere Erklärung findet sich in der@ref{Scheme-Übung} und in
1537 @ruser{Schnittstellen für Programmierer}.
1539 Scheme kann auch in einfachen @code{\override}-Befehlen
1542 TODO Find a simple example
1543 @c This isn't a valid example with skylining
1544 @c It works fine without padText -td
1547 @lilypond[quote,verbatim,ragged-right]
1548 padText = #(define-music-function (parser location padding) (number?)
1550 \once \override TextScript #'padding = #padding
1554 c4^"piu mosso" b a b
1556 c4^"piu mosso" d e f
1558 c4^"piu mosso" fis a g
1563 Es kann auch benutzt werden, um Befehle zu erstellen:
1565 @c Check this is a valid example with skylining
1566 @c It is - 'padding still works
1568 @lilypond[quote,verbatim,ragged-right]
1569 tempoPadded = #(define-music-function (parser location padding tempotext)
1572 \once \override Score.MetronomeMark #'padding = $padding
1573 \tempo \markup { \bold #tempotext }
1577 \tempo \markup { "Low tempo" }
1579 \tempoPadded #4.0 #"High tempo"
1584 Sogar ganze Musikausdrücke können eingefügt werden:
1586 @lilypond[quote,verbatim,ragged-right]
1587 pattern = #(define-music-function (parser location x y) (ly:music? ly:music?)
1594 \pattern {d16 dis} { ais16-> b\p }