1 @c -*- coding: utf-8; mode: texinfo; documentlanguage: de -*-
4 Translation of GIT committish: 32b9cd030a1917570346e9b9ea267fe409156b2f
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/shr/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.
97 @node Scheme-Variablen
98 @subsection Scheme-Variablen
99 @translationof Scheme variables
101 Scheme-Variablen können jedlichen gültigen Scheme-Wert erhalten, auch
104 Scheme-Variablen werden mit @code{define} definiert:
111 Scheme-Variablen können an der Guile-Eingabeaufforderung ausgewertet werden,
112 indem man einfach die Variable eintippt.
120 Scheme-Variablen können auf dem Bildschirm ausgegeben werden, indem man
121 @code{display} zum Anzeigen benutzt:
128 Sowohl der Wert @code{2} als auch die Eingabeaufforderung @code{guile}
129 werden auf der gleichen Zeile ausgegeben. Das kann man vermeiden, indem
130 man eine @code{newline}-Prozedur für eine Leerzeile aufruft oder das
131 Zeichen für eine neue Zeile anzeigen lässt:
134 guile> (display a)(newline)
136 guile> (display a)(display "\n")
141 Wenn eine Variable einmal erstellt wurde, kann ihr Wert durch @code{set!}
145 guile> (set! a 12345)
151 @node Einfache Scheme-Datentypen
152 @subsection Einfache Scheme-Datentypen
153 @translationof Scheme simple data types
155 Das Grundlegendste an einer Sprache sind Daten: Zahlen, Zeichen,
156 Zeichenketten, Listen usw. Hier ist eine Liste der Datentypen, die für
157 LilyPond-Eingabedateien relevant sind.
160 @item Boolesche Variablen
161 Werte einer Booleschen Variable sind Wahr oder Falsch. Die Scheme-Entsprechung
162 für Wahr ist @code{#t} und für Falsch @code{#f}.
167 Zahlen werden wie üblich eingegeben, @code{1} ist die (ganze)
168 Zahl Eins, während @w{@code{-1.5}} eine Gleitkommazahl (also
169 eine nicht-ganze) ist.
172 Zeichenketten werden in doppelte Anführungszeichen gesetzt:
175 "Das ist eine Zeichenkette"
178 Zeichenketten können über mehrere Zeilen reichen:
187 und die Zeichen für eine neue Zeile am Ende jeder Zeile werden auch
188 in die Zeichenkette aufgenommen.
190 Zeichen für eine neue Zeile können auch hinzugefügt werden, indem man
191 @code{\n} in die Zeichenkette aufnimmt.
194 "das\nist eine\nmehrzeilige Zeichenkette"
197 Anführungszeichen und neue Zeilen können auch mit sogenannten
198 Fluchtsequenzen eingefügt werden. Die Zeichenkette
199 @code{a sagt "b"} wird wie folgt eingegeben:
207 Weitere zusätzliche Scheme-Datentypen, die hier nicht besprochen wurden,
208 finden sich in einer vollständigen Liste der Scheme-Datentypen in der
209 Guile-Referenzanleitung:
210 @uref{http://www.gnu.org/software/guile/manual/html_node/Simple-Data-Types.html}.
213 @node Zusammengesetzte Scheme-Datentypen
214 @subsection Zusammengesetzte Scheme-Datentypen
215 @translationof Scheme compound data types
217 Es gibt auch zusammengesetzte Datentypen in Scheme. Die Datentypen, die in
218 LilyPond häufig benutzt werden, beinhalten Paare, Listen, assoziative Listen
221 @subheading Paare (pair)
223 Der wichtigeste zusammengesetzte Datentyp in Scheme ist ein Paar (@code{pair}).
224 Wie aus dem Namen schon hervorgeht, besteht ein Paar aus zwei zusammengeschweißten
225 Werten. Die Prozedur um ein Paar zu erstellen ist @code{cons}.
233 Das Paar wird dargestellt als zwei Elemente, von Klammern umgeben
234 und durch Leerzeichen und einen Punkt (@code{.}) getrennt. Der Punkt ist
235 @emph{kein} Dezimalpunkt, sondern markiert die Gruppe als Paar.
237 Paare können auch wörtlich eingegeben werden, indem man ihnen voraus ein
238 einfaches Anführungszeichen (@code{'} setzt.
246 Beide Elemente eines Paares können beliebige gültige Scheme-Werte sein:
251 guile> '("blah-blah" . 3.1415926535)
252 ("blah-blah" . 3.1415926535)
256 Das erste Element eines Paares kann mit der Prozedur @code{car},
257 das zweite mit der Prozedur @code{cdr} angesprochen werden.
260 guile> (define mypair (cons 123 "hello there")
271 Achtung: @code{cdr} wird ausgeprochen wie "kudd-err", nach Sussman und
273 @uref{http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-14.html#footnote_Temp_133}
275 @subheading Listen (list)
277 Ein sehr häufiger Datentyp in Scheme ist die Liste (@emph{list}). Formal
278 gesehen wird eine Liste entweder als leere Liste definiert
279 (repräsentiert als @code{'()}), oder als ein Paar, dessen @code{cdr}
282 Es gibt viele Arten, Listen zu erstellen. Die vielleicht häufigste Methode
283 ist die @code{list}-Prozedur:
286 guile> (list 1 2 3 "abc" 17.5)
290 Wie man sehen kann, wird eine Liste dargestellt in Form der einzelnen
291 Elemente, getrennt durch ein Leerzeichen und als Gruppe in Klammern eingeschlossen.
292 Anders als bei einem Paar, befindet sich kein Punkt zwischen den Elementen.
294 Eine Liste kann auch als wörtliche Liste notiert werden, indem man die
295 enthaltenen Elemente in Klammern einschließt und ein einfaches Anführungszeichen
299 guile> '(17 23 "foo" "bar" "bazzle")
300 (17 23 "foo" "bar" "bazzle")
303 Listen haben eine zentrale Stellung in Scheme. Scheme wird als Dialekt
304 von Lisp angesehen, und das Wort @qq{lisp} steht für @qq{List Processing}.
305 Scheme-Ausdrücke sind immer Listen.
307 @subheading Assoziative Listen (alist)
309 Eine besonderer Listentyp ist die @emph{assoziative Liste} oder @emph{alist}.
310 Eine Alist wird benutzt, um Daten zum einfachen Abrufen zu speichern.
312 Alisten sind Listen, deren Elemente als Paare kommen. Der @code{car}-Teil
313 jedes Elements wird als @emph{Schlüssel} (key) bezeichnet, der
314 @code{cdr}-Teil jedes Elements wird @emph{Wert} (value) genannt.
315 Die Scheme-Prozedur @code{assoc} wird benutzt, um einen Eintrag aus einer
316 Aliste aufzurufen, und mit @code{cdr} wird sein Wert abgefragt:
319 guile> (define my-alist '((1 . "A") (2 . "B") (3 . "C")))
321 ((1 . "A") (2 . "B") (3 . "C"))
322 guile> (assoc 2 my-alist)
324 guile> (cdr (assoc 2 my-alist))
329 Alisten werden sehr viel in LilyPond genutzt, um Eigenschaften und
330 andere Daten zu speichern.
332 @subheading Hash-Tabellen (hash table)
334 Eine Datenstruktur, die ab und zu in LilyPond eingesetzt wird.
335 Eine Hash-Tabelle ähnelt einem Array, aber die Indexe des Arrays
336 können beliebige Scheme-Werte sein, nicht nur Integre.
338 Hash-Tabellen sind effizienter als Alisten, wenn man viele Daten
339 speichern will und die Daten sich oft ändern.
341 Die Syntax, mit der Hash-Tabellen erstellt werden, ist etwas komplex,
342 aber man kann Beispiele hierzu im LilyPond-Quellcode finden.
345 guile> (define h (make-hash-table 10))
348 guile> (hashq-set! h 'key1 "val1")
350 guile> (hashq-set! h 'key2 "val2")
352 guile> (hashq-set! h 3 "val3")
356 Werte werden aus den Hash-Tabellen mit @code{hashq-ref} ausgelesen.
359 guile> (hashq-ref h 3)
361 guile> (hashq-ref h 'key2)
366 Schlüssel und Werte werden als Paar mit @code{hashq-get-handle} ausgelesen.
367 Das ist die beste Art, weil hier @code{#f} ausgegeben wird, wenn ein
368 Schlüssel nicht gefunden werden kann.
371 guile> (hashq-get-handle h 'key1)
373 guile> (hashq-get-handle h 'frob)
379 @node Berechnungen in Scheme
380 @subsection Berechnungen in Scheme
381 @translationof Calculations in Scheme
384 We have been using lists all along. A calculation, like @code{(+ 1 2)}
385 is also a list (containing the symbol @code{+} and the numbers 1
386 and@tie{}2). Normally lists are interpreted as calculations, and the
387 Scheme interpreter substitutes the outcome of the calculation. To enter a
388 list, we stop the evaluation. This is done by quoting the list with a
389 quote @code{'} symbol. So, for calculations do not use a quote.
391 Inside a quoted list or pair, there is no need to quote anymore. The
392 following is a pair of symbols, a list of symbols and a list of lists
397 #'(staff clef key-signature)
402 Scheme kann verwendet werden, um Berechnungen durchzuführen. Es
403 verwendet eine @emph{Präfix}-Syntax. Um 1 und@tie{}2 zu addieren, muss
404 man @code{(+ 1 2)} schreiben, und nicht @math{1+2}, wie in traditioneller
412 Berechnungen können geschachtelt werden und das Ergebnis einer Berechnung
413 kann für eine neue Berechnung eingesetzt werden.
420 Diese Berechnungen sind Beispiele von Auswertungen. Ein Ausdruck
421 wie @code{(* 3 4)} wird durch seinen Wert @code{12} ersetzt.
423 Scheme-Berechnungen können zwischen Integren und Nich-Integren
424 unterscheiden. Integre Berechnungen sind exakt, während Nicht-Integre
425 nach den passenden Genauigkeitseinschränkungen berechnet werden:
434 Wenn der Scheme-Berechner einen Ausdruck antrifft, der eine Liste darstellt,
435 wird das erste Element der Liste als Prozedur behandelt, die mit
436 Argumenten des Restes der Liste ausgewertet werden. Darum sind alle
437 Operatoren in Scheme vorangestellt.
439 Wenn das erste Element eines Scheme-Ausdrucks, der eine Liste darstellt,
440 @emph{kein} Operator oder keine Prozedur ist, gibt es einen Fehler:
449 <unnamed port>:52:1: In expression (1 2 3):
450 <unnamed port>:52:1: Wrong type to apply: 1
455 Hier kann man sehen, dass Scheme versucht hat, 1 als einen Operator oder
456 eine Prozedur zu behandeln, was aber nicht möglich war. Darum der Fehler
457 "Wrong type to apply: 1".
459 Wenn man also eine Liste erstellen will, braucht man also einen Listen-Operator
460 oder man muss die Liste als wörtliches Zitat schreiben, sodass Scheme sie
461 nicht auszuwerten versucht.
471 Dieser Fehler kann durchaus vorkommen, wenn man Scheme unter LilyPond
475 The same assignment can be done in completely in Scheme as well,
478 #(define twentyFour (* 2 twelve))
481 @c this next section is confusing -- need to rewrite
483 The @emph{name} of a variable is also an expression, similar to a
484 number or a string. It is entered as
491 @cindex quoting in Scheme
493 The quote mark @code{'} prevents the Scheme interpreter from substituting
494 @code{24} for the @code{twentyFour}. Instead, we get the name
499 @node Scheme-Prozeduren
500 @subsection Scheme-Prozeduren
501 @translationof Scheme procedures
503 Scheme-Prozeduren sind ausführbare Scheme-Ausdrücke, die einen
504 Wert ausgeben, der das Resultat ihrer Ausführung darstellt. Sie können
505 auch Variablen verändern, die außerhalb dieser Prozedur definiert wurden.
507 @subheading Prozeduren definieren
509 Prozeduren werden in Scheme mit @code{define} definiert:
512 (define (function-name arg1 arg2 ... argn)
513 scheme-expression-that-gives-a-return-value)
516 Beispielsweise könnte man eine Prozedur definieren, die den Durchschnitt
520 guile> (define (average x y) (/ (+ x y) 2))
522 #<procedure average (x y)>
525 Wenn die Prozedur einmal definiert ist, wird sie aufgerufen indem man
526 die Prozedur und die Argumente in eine Liste schreibt. Man könnte also den
527 Durchschnitt von 3 und 12 berechnen:
530 guile> (average 3 12)
534 @subheading Prädikate
536 Scheme-Prozeduren, die Boolsche Werte ausgeben, werden oft als Prädikate
537 (predicate) bezeichnet. Es herrscht die Übereinkunft, Prädikat-Bezeichnungen
538 mit einem Fragezeichen abzuschließen:
541 guile> (define (less-than-ten? x) (< x 10))
542 guile> (less-than-ten? 9)
544 guile> (less-than-ten? 15)
548 @subheading Wiedergabe-Werte
550 Scheme-Prozeduren geben immer einen Wiedergabe-Wert (return value) aus, welcher
551 der Wert des letzten Ausdrucks ist, der in der Prozedur ausgeführt wurde. Der
552 Wiedergabewert kann ein beliebiger gültiger Scheme-Wert sein, auch eine
553 komplexe Datenstruktur oder eine Prozedur.
555 Manchmal würden Benutzer gerne mehrere Scheme-Ausdrucke in einer Prozedur haben.
556 Es gibt zwei Arten, wie merhere Ausdrücke kombiniert werden können. Die erste
557 Art ist die @code{begin}-Prozedur, der es ermöglicht, dass mehrere Ausdrücke
558 ausgewertet werden und den Wert des letzten Ausdrucks wiedergibt.
561 guile> (begin (+ 1 2) (- 5 8) (* 2 2))
565 Die andere Art, mehrere Ausdrücke zu kombinieren, ist eine @code{let}-Umgebung.
566 In dieser Umgebung wird eine Serie von Verbindungen erstellt, und dann wird eine
567 Sequenz von Ausdrücken ausgewertet, die diese Bindungen einschließen können.
568 Der Wiedergabewert der let-Umgebung ist der Wiedergabewert der letzten Aussage
572 guile> (let ((x 2) (y 3) (z 4)) (display (+ x y)) (display (- z 4))
573 ... (+ (* x y) (/ z x)))
578 @node Scheme-Konditionale
579 @subsection Scheme-Konditionale
580 @translationof Scheme conditionals
584 Scheme hat eine @code{if}-Prozedur:
587 (if test-expression true-expression false-expression)
590 @var{test-expression} ist ein Ausdruck, der einen Booleschen
591 Wert zurück gibt. Wenn @var{test-expression} den Wert @code{#t}
592 ausgibt, gibt die if-Prozedur den Wert von @var{true-expression} aus,
593 in allen anderen Fällen den Wert von @var{false-expression}.
598 guile> (if (> a b) "a is greater than b" "a is not greater than b")
599 "a is not greater than b"
604 Eine andere konditionale Prozedur in Scheme ist
608 (cond (test-expression-1 result-expression-sequence-1)
609 (test-expression-2 result-expression-sequence-2)
611 (test-expression-n result-expression-sequence-n))
619 guile> (cond ((< a b) "a is less than b")
620 ... ((= a b) "a equals b")
621 ... ((> a b) "a is greater than b"))
627 @node Scheme in LilyPond
628 @section Scheme in LilyPond
629 @translationof Scheme in LilyPond
632 * LilyPond Scheme-Syntax::
633 * LilyPond-Variablen::
634 * Eingabe-Variablen und Scheme::
635 * Objekteigenschaften::
636 * Zusammengesetzte LilyPond-Variablen::
637 * Interne musikalische Repräsentation::
640 @node LilyPond Scheme-Syntax
641 @subsection LilyPond Scheme-Syntax
642 @translationof LilyPond Scheme syntax
647 Der Guile-Auswerter ist ein Teil von LilyPond, sodass Scheme also auch in
648 normale LilyPond-Eingabedateien eingefügt werden kann. Es gibt mehrere
649 Methoden, um Scheme in LilyPond zu integrieren.
651 Die einfachste Weise ist es, ein Rautenzeichen@tie{}@code{#} vor einem
652 Scheme-Ausdruck zu benutzen.
654 Die Eingabe von LilyPond ist in Zeichen und Ausdrücke gegliedert, so etwa
655 wie die menschliche Sprache sich in Wörter und Sätze gliedert. LilyPond
656 hat einen Lexer, der Zeichen erkennt (Zahlen, Zeichenketten, Scheme-Elemente,
657 Tonhöhen usw.) und einen Parser, der die Syntax versteht, @ruser{LilyPond grammar}.
658 Wenn dann eine bestimmte Syntaxregel als zuständig erkannt wurde, werden die
659 damit verknüpften Aktionen ausgeführt.
661 Die Rautenzeichenmethode (@code{#}), mit der Scheme eingebettet werden kann,
662 passt sehr gut in dieses System. Wenn der Lexer ein Rautenzeichen sieht, ruft
663 er den Scheme-reader auf, um den ganzen Scheme-Ausdruck zu lesen (das kann eine
664 Variable, ein Ausdruck in Klammern oder verschiedene andere Sachen sein). Nachdem
665 der Scheme-Ausdruck gelesen wurde, wird er als Wert eines @code{SCM_TOKEN} in der
666 Grammatik gespeichert. Wenn der Parser weiß, wie er diesen Wert benutzen kann,
667 ruft er Guile auf, um den Scheme-Ausdruck auszuwerten. Weil der Parser normalerweise
668 dem Lexer etwas voraus sein muss, ist die Trennung von Lesen und Auswerten zwischen
669 Lexer und Parser genau das richtige, um die Auswertung von LilyPond- und
670 Scheme-Ausdrücken synchron zu halten. Aus diesem Grund sollte das Rautenzeichen
671 zum Einbinden von Scheme immer benutzt werden, wenn es möglich ist.
673 Eine andere Möglichkeit, Scheme aufzurufen, ist die Benutzung des Dollarzeichens
674 (@code{$}) anstelle der Raute. In diesem Fall wertet LilyPond den Code sofort
675 aus, nachdem der Lexer ihn gelesen hat. Dabei wird der resultierende
676 Scheme-Ausdruckstyp geprüft und eine Tokentyp dafür ausgesucht (einer von mehreren
677 @code{xxx_IDENTIFIER} in der Syntax). Wenn der Wert des Ausdrucks gültig ist
678 (der Guilde-Wert für @code{*unspecified*}), dann wird nichts an den Parser
681 Das ist auch der gleiche Mechanismus, nach dem LilyPond funktioniert, wenn man eine Variable oder musikalische Funktion mit ihrer Bezeichnung ausruft, wie
682 in @code{\Bezeichnung}, mit dem einzigen Unterschied, dass ihr Ende durch den
683 LilyPond-Lexer bestimmt wird, ohne den Scheme-reader einzubeziehen, und also
684 nur Variablen akzeptiert werden, die im aktuellen LilyPond-Modus gültig sind.
686 Die direkte Auswirkung von @code{$} kann zu Überraschungen führen, siehe auch
687 @ref{Eingabe-Variablen und Scheme}. Es bietet sich daher an, @code{#} immer
688 zu benützen, wenn der Parser es unterstützt.
690 Jetzt wollen wir uns tatsächlichen Scheme-Code anschauen. Scheme-Prozeduren
691 können in LilyPond-Eingabedateien definiert werden:
694 #(define (average a b c) (/ (+ a b c) 3))
697 LilyPond-Kommentare (@code{%} oder @code{%@{ %@}}) können innerhalb
698 von Scheme-Code nicht benutzt werden, nicht einmal in einer LilyPond-Eingabedatei,
699 weil der Guile-Interpreter und nicht der LilyPond-Parser den Scheme-Ausdruck
700 liest. Kommentare in Guile Scheme werden wie folgt notiert:
703 ; Einzeiliges Kommentar
706 Guile-Stil Blockkommentar (nicht schachtelbar)
707 Diese Kommentare werden von Scheme-Programmierern
708 selten benutzt und nie im Quellcode
713 Für den Rest dieses Abschnitts soll angenommen werden, dass die Daten in
714 einer LilyPond-Eingabedatei notiert werden sollen, sodass immer@tie{}@code{#}
715 vor die Scheme-Ausdrücke gestellt wird.
717 Alle Scheme-Ausdrücke auf oberster Ebene in einer LilyPond-Eingabedatei
718 können in einen einzigen Scheme-Ausdruck zusammengefasst werden mit
728 @node LilyPond-Variablen
729 @subsection LilyPond-Variablen
730 @translationof LilyPond variables
732 LilyPond-Variablen werden intern als Scheme-Variablen gespeichert. Darum
746 Das bedeutet, dass Scheme-Ausdrücke auf LilyPond-Variablen zugreifen können.
747 Man könnte also schreiben:
750 Vierundzwanzig = #(* 2 Zwoelf)
754 was zur Folge hätte, dass die Zahl 24 in der LilyPond (und Scheme-)Variablen
755 @code{Vierundzwanzig} gespeichert wird.
757 Üblicherweise greift man auf LilyPond-Variablen zu, indem man ihnen einen
758 Backslash voranstellt. Siehe auch @ref{LilyPond Scheme-Syntax}, also etwa
759 @code{\Vierundzwanzig}. Weil dadurch eine Kopie des Wertes für die meisten
760 von LilyPonds internen Typen erstellt wird (insbesondere musikalische Funktionen),
761 erstellen musikalische Funktionen normalerweise Kopien von Material, das sie
762 verändern. Aus diesem Grund sollten musikalische Funktionen, die mit @code{#}
763 aufgerufen werden, kein Material enthalten, dass entweder von Grund auf neu
764 erstellt wird oder explizit kopiert wird, sondern besser direkt auf das relevante
768 @node Eingabe-Variablen und Scheme
769 @subsection Eingabe-Variablen und Scheme
770 @translationof Input variables and Scheme
772 Das Eingabeformat unterstützt die Notation von Variablen: Im folgenden
773 Beispiel wird ein musikalischer Ausdruck einer Variablen mit der
774 Bezeichnung @code{traLaLa} zugewiesen:
777 traLaLa = @{ c'4 d'4 @}
780 Variablen haben beschränkte Geltungsbereiche: im unten stehenden Beispiel
781 enthält auch die @code{\layout}-Umgebung eine @code{traLaLa}-Variable,
782 die sich aber von der @code{traLaLa}-Variable auf oberster Ebene unterscheidet:
785 traLaLa = @{ c'4 d'4 @}
786 \layout @{ traLaLa = 1.0 @}
789 Jede Eingabedatei ist solch ein Gültigkeitsbereich, und alle
790 @code{\header}-, @code{\midi}- und @code{\layout}-Umgebungen
791 sind Gültigkeitsbereiche, die in diesen obersten Gültigkeitsbereich
794 Sowohl Variablen als auch Gültigkeitsbereiche sind im Guile Modulsystem
795 eingebaut. Ein anonymes Scheme-Modul wird jedem Gültigkeitsbereich
796 angehängt. Eine Zuweisen in der Form von
799 traLaLa = @{ c'4 d'4 @}
803 wird intern in die Scheme-Definition
806 (define traLaLa @var{Scheme-Wert von `@code{... }'})
812 Das bedeutet, dass LilyPond-Variablen und Scheme-Variablen frei gemischt
813 werden können. Im folgenden Beispiel wird ein Notenfragment in der
814 Variable @code{traLaLa} gespeichert und mit Scheme dupliziert. Das
815 Resultat wird in eine @code{\score}-Umgebung mit einer weiteren
816 Variable @code{twice} importiert:
819 traLaLa = { c'4 d'4 }
821 #(define newLa (map ly:music-deep-copy
822 (list traLaLa traLaLa)))
824 (make-sequential-music newLa))
829 Das ist ein interessantes Beispiel. Die Zuweisung findet erst statt,
830 nachdem der Parser sichergestellt hat, dass nichts folgt, das Ähnlichkeit
831 mit @code{\addlyrics} hat, sodass er prüfen muss, was als nächstes kommt.
832 Er liest @code{#} und den darauf folgenden Scheme-Ausdruck, @emph{ohne} ihn
833 auszuwerten, so dass er weiterlesen und erst @emph{danach}
834 wird der Scheme-Code ohne Probleme ausführen kann.
836 Das Beispiel zeigt, wie man musikalische Ausdrücke aus der Eingabe in den
837 Scheme-Auswerter @qq{exportieren} kann. Es geht auch andersherum. Indem
838 man Scheme-Werte nach @code{$} schreibt, wird ein
839 Scheme-Wert interpretiert, als ob er in LilyPond-Syntax eingeben wäre.
840 Anstatt @code{\twice} zu definieren, könne man also auch schreiben:
844 @{ $(make-sequential-music (list newLa)) @}
847 Mann kann @code{$} zusammen mit einem Scheme-Ausdruck überall benutzen,
848 wo auch @code{\@var{Bezeichnung}} gültig wäre, nachdem der Scheme-Ausdruck
849 einmal einer Variable @var{Bezeichnung} zugewiesen worden ist. Der Austausch
850 geschieht im Lexer, sodass LilyPond den Unterschied gar nicht merkt.
852 Ein negativer Effekt ist aber das Timing. Wenn man @code{$} anstelle von
853 @code{#} für die Definition von @code{newLa} im obigen Beispiel eingesetzt
854 hätte, würde der folgende Scheme-Ausdruck fehlschlagen, weil @code{traLaLa}
855 noch nicht definiert worden wäre. Zu einer Erklärung dieses Timingproblems
856 siehe @ref{LilyPond Scheme-Syntax}.
858 Auf jeden Fall findet die Auswertung des Scheme-Codes spätestens im Parser
859 statt. Wenn man es noch später ausgeführt haben möchte, muss man
860 @ref{Leere Scheme-Funktionen} benutzen oder es in einem Makro speichern:
864 (ly:set-option 'point-and-click #f))
873 Scheme- und LilyPond-Variablen können nicht gemischt werden, wenn man die
874 @option{--safe}-Option benutzt.
877 @node Objekteigenschaften
878 @subsection Objekteigenschaften
879 @translationof Object properties
881 Objekteigenschaften werden in LilyPond in Form von Alisten-Ketten
882 gespeichert, also als Listen von Alisten. Eigenschaften werden
883 geändert, indem man Werte an den Anfang der Eigenschaftsliste
884 hinzufügt. Eigenschaften werden gelesen, indem Werte aus der
885 Aliste gelesen werden.
887 Ein neuer Wert für eine Eigenschaft kann gesetzt werden, indem man
888 der Alist einen Wert mit Schlüssel und dem Wert zuweist. Die
889 LilyPond-Syntax hierfür ist:
892 \override Stem #'thickness = #2.6
895 Diese Anweisung verändert die Erscheinung der Notenhälse. Der Alist-Eintrag
896 @code{'(thickness . 2.6)} wird zu der Eigenschaftsliste eines
897 @code{Stem}-(Hals-)Objektes hinzugefügt.
898 @code{thickness} wird relativ zu den Notenlinien errechnet, in diesem
899 Fall sind die Hälse also 2,6 mal so dick wie die Notenlinien. Dadurch
900 werden Hälse fast zweimal so dick dargestellt, wie sie normalerweise sind.
901 Um zwischen Variablen zu unterscheiden, die in den Quelldateien direkt
902 definiert werden (wie @code{Vierundzwanzig} weiter oben), und zwischen denen,
903 die für interne Objekte zuständig sind, werden hier die ersteren
904 @qq{Variablen} genannt, die letzteren dagegen @qq{Eigenschaften}.
905 Das Hals-Objekt hat also eine @code{thickness}-Eigenschaft, während
906 @code{Vierundzwanzig} eine Variable ist.
908 @cindex Eigenschaften versus Bezeichner
909 @cindex Bezeichner versus Eigenschaften
912 @node Zusammengesetzte LilyPond-Variablen
913 @subsection Zusammengesetzte LilyPond-Variablen
914 @translationof LilyPond compound variables
916 @subheading Abstände (offset)
918 Zweidimensionale Abstände (X- und Y-Koordinaten) werden
919 als @emph{pairs} (Paare) gespeichert. Der @code{car}-Wert des
920 Abstands ist die X-Koordinate und der @code{cdr}-Wert die
924 \override TextScript #'extra-offset = #'(1 . 2)
927 Hierdurch wird das Paar @code{(1 . 2)} mit der Eigenschaft @code{extra-offset}
928 des TextScript-Objektes verknüpft. Diese Zahlen werden in
929 Systembreiten gemessen, so dass der Befehl das Objekt eine Systembreite
930 nach rechts verschiebt und zwei Breiten nach oben.
932 Prozeduren, um mit Abständen zu arbeiten, finden sich in @file{scm/lily-library.scm}.
934 @subheading Brüche (fractions)
936 Brüche, wie sie LilyPond benutzt, werden wiederum als Paare gespeichert,
937 dieses Mal als unbezeichnete ganze Zahlen. Während Scheme rationale Zahlen
938 als einen negativen Typ darstellen kann, sind musikalische gesehen
939 @samp{2/4} und @samp{1/2} nicht das selbe, sodass man zwischen beiden unterscheiden
940 können muss. Ähnlich gibt es auch keine negativen Brüche in LilyPonds Sinn.
941 Somit bedeutet @code{2/4} in LilyPond @code{(2 . 4)} in Scheme, und @code{#2/4} in
942 LilyPond bedeutet @code{1/2} in Scheme.
944 @subheading Bereiche (extend)
946 Paare werden auch benutzt, um Intervalle zu speichern, die einen Zahlenbereich
947 vom Minimum (dem @code{car}) bis zum Maximum (dem @code{cdr}) darstellen.
948 Intervalle werden benutzt, um die X- und Y-Ausdehnung von druckbaren
949 Objekten zu speichern. Bei X-Ausdehnungen ist @code{car} die linke
950 X-Koordinate und @code{cdr} die rechte X-Koordinate. Für Y-Ausdehnungen
951 ist @code{car} die untere Koordinate und @code{cdr} die obere Koordinate.
953 Prozeduren, um mit Intervallen zu arbeiten, finden sich in
954 @file{scm/lily-library.scm}. Diese Prozeduren sollten benutzt, wenn es möglich
955 ist, um den Code konsistent zu halten.
957 @subheading Eigenschafts-Alisten (property alist)
959 Eine Eigenschafts-Aliste ist eine LilyPond-Datenstruktur, die eine Aliste
960 darstellt, deren Schlüssel Eigenschaften sind und deren Werte
961 Scheme-Ausdrücke sind, die den erwünschen Wert der Eigenschaft ausgeben.
963 LilyPond-Eigenschaften sind Scheme-Symbole, wie etwa @code{'thickness}
966 @subheading Alisten-Ketten (alist chains)
968 Eine Alisten-Kette ist eine Liste, die Eigenschafts-Alisten enthält.
970 Die Menge aller Eigenschaften, die sich auf einen Grob auswirken, wird
971 typischerweise in einer Alisten-Kette gespeichert. Um den Wert einer
972 bestimmten Eigenschaft zu finden, die ein Grob haben soll, wird jede
973 Liste in der Kette nach einander durchsucht, wobei nach einem Eintrag
974 geschaut wird, der den Eigenschaftsschlüssel enthält. Der erste
975 gefundene Alisten-Eintrag wird benutzt und dessen Wert ist der
976 Wert der Eigenschaft.
978 Die Scheme-Prozedur @code{chain-assoc-get} wird normalerweise benutzt,
979 um Grob-Eigenschaftenwerte zu erhalten.
982 @node Interne musikalische Repräsentation
983 @subsection Interne musikalische Repräsentation
984 @translationof Internal music representation
986 Intern werden Noten als Scheme-Liste dargestellt. Die Liste enthält
987 verschiedene Elemente, die die Druckausgabe beeinflussen. Parsen
988 nennt man den Prozess, der die Noten aus der LilyPond-Repräsentation
989 in die interne Scheme-Repräsentation überführt.
991 Wenn ein musikalischer Ausdruck geparst wird, wird er in eine Gruppe
992 von Scheme-Musikobjekten konvertiert. Die definierende Eigenschaft
993 eines Musikobjektes ist, dass es Zeit einnimmt. Die Zeit, die
994 ein Objekt braucht, wird Dauer (engl. @emph{duration}) genannt.
995 Dauern werden in rationalen Zahlen ausgedrückt, die die Länge des
996 Musikobjekts in Ganzen Noten angeben.
998 Ein Musikobjekt hat drei Typen:
1002 Musikbezeichnung (music name): Jeder Musikausdruck hat eine Bezeichnung. Eine
1003 Note beispielsweise erzeugt ein @rinternals{NoteEvent} und @code{\simultaneous}
1004 produziert @rinternals{SimultaneousMusic}. Eine Liste aller möglichen
1005 Ausdrücke findet sich in der Referenz der Interna, unter
1006 @rinternals{Music expressions}.
1009 Typ (type) oder Schnittstelle (interface): Jede Musikbezeichnung hat mehrere
1010 Typen oder Schnittstellen, beispielsweise eine Note ist ein Ereignis (@code{event}),
1011 aber auch ein Notenereignis (@code{note-event}), ein rhythmisches Ereignis
1012 (@code{rhythmic-event}) und ein Melodieereignis (@code{melodic-event}).
1013 Alle Musikklassen sind in der Referenz der Interna aufgelistet, unter
1014 @rinternals{Music classes}.
1017 C++-Objekt: Jedes Musikobjekt ist durch ein Objekt der C++-Klasse @code{Music}
1021 Die eigentliche Information eines musikalischen Ausdrucks wird in Eigenschaften
1022 gespeichert. Ein @rinternals{NoteEvent} beispielsweise hat die Eigenschaften
1023 Tonhöhe (@code{pitch}) und Dauer (@code{duration}), die die Dauer und die
1024 Tonhöhe der Note speichern. Eine Liste aller möglichen Eigenschaften findet
1025 sich in der Referenz der Interna, unter
1026 @rinternals{Music properties}.
1028 Ein zusammengesetzter musikalischer Ausdruck ist ein Musikobjekt, das andere
1029 Musikobjekte als Eigenschaften enthält. Eine Liste an Objekten kann in der
1030 @code{elements}-Eigenschaft eines Musikobjekts bzw. ein einziges
1031 Ableger-Musikelement in der @code{element}-Eigenschaft gespeichert werden.
1032 @rinternals{SequentialMusic} beispielsweise hat sein einziges Argument in
1033 @code{element}. Der Körper einer Wiederholung wird in der @code{element}-Eigenschaft
1034 von @rinternals{RepeatedMusic} gespeichert, und die alternativen Endungen
1038 @node Komplizierte Funktionen erstellen
1039 @section Komplizierte Funktionen erstellen
1040 @translationof Building complicated functions
1042 Dieser Abschnitt zeigt, wie man Information zusammensucht,
1043 um komplizierte musikalische Funktionen zu erstellen.
1046 * Musikalische Funktionen darstellen::
1047 * Eigenschaften von Musikobjekten::
1048 * Verdoppelung einer Note mit Bindebögen (Beispiel)::
1049 * Artikulationszeichen zu Noten hinzufügen (Beispiel)::
1053 @node Musikalische Funktionen darstellen
1054 @subsection Musikalische Funktionen darstellen
1055 @translationof Displaying music expressions
1057 @cindex interne Speicherung
1058 @cindex Musikausdrücke anzeigen
1059 @cindex Anzeigen von Musikausdrücken
1061 @funindex displayMusic
1062 @funindex \displayMusic
1064 Wenn man eine musikalische Funktion erstellt, ist es oft
1065 hilfreich sich anzuschauen, wie musikalische Funktionen
1066 intern gespeichert werden. Das kann mit der Funktion
1067 @code{\displayMusic} erreicht werden:
1071 \displayMusic @{ c'4\f @}
1086 'AbsoluteDynamicEvent
1090 (ly:make-duration 2 0 1 1)
1092 (ly:make-pitch 0 0 0))))
1095 Normalerweise gibt LilyPond diese Ausgabe auf der Konsole mit
1096 allen anderen Nachrichten aus. Um die wichtigen Nachrichten
1097 in einer Datei zu speichern, kann die Ausgabe in eine Datei
1101 lilypond file.ly >display.txt
1104 Mit LilyPond- und Scheme-Magie kann man LilyPond anweisen, genau
1105 diese Ausgabe an eine eigene Datei zu senden:
1109 $(with-output-to-file "display.txt"
1110 (lambda () #@{ \displayMusic @{ c'4\f @} #@}))
1114 Mit etwas Umformatierung ist die gleiche Information sehr viel
1118 (make-music 'SequentialMusic
1120 (make-music 'NoteEvent
1121 'articulations (list
1122 (make-music 'AbsoluteDynamicEvent
1125 'duration (ly:make-duration 2 0 1 1)
1126 'pitch (ly:make-pitch 0 0 0))))
1129 Eine musikalische @code{@{ ... @}}-Sequenz hat die Bezeichnung
1130 @code{SequentialMusic} und ihre inneren Ausdrücke werden als
1131 Liste in seiner @code{'elements}-Eigenschaft gespeichert. Eine
1132 Note ist als als ein @code{EventChord}-Objekt dargestellt (welches Dauer und
1133 Tonhöhe speichert) und zusätzliche Information enthält (in
1134 diesem Fall ein @code{AbsoluteDynamicEvent} mit einer
1135 @code{"f"}-Text-Eigenschaft).
1139 @code{\displayMusic} gibt die Noten aus, die dargestellt werden, sodass
1140 sie sowohl angezeigt als auch ausgewertet werden. Um die Auswertung zu
1141 vermeiden, kann @code{\void} vor @code{\displayMusic} geschrieben werden.
1144 @node Eigenschaften von Musikobjekten
1145 @subsection Eigenschaften von Musikobjekten
1146 @translationof Music properties
1148 TODO -- make sure we delineate between @emph{music} properties,
1149 @emph{context} properties, and @emph{layout} properties. These
1150 are potentially confusing.
1152 Schauen wir uns ein Beispiel an:
1156 \displayMusic \someNote
1161 (ly:make-duration 2 0 1 1)
1163 (ly:make-pitch 0 0 0))
1166 Das @code{NoteEvent}-Objekt ist die Repräsentation von @code{someNote}.
1167 Einfach. Wie fügt man denn ein c' in einen Akkorde ein?
1171 \displayMusic \someNote
1179 (ly:make-duration 2 0 1 1)
1181 (ly:make-pitch 0 0 0))))
1184 Jetzt ist das @code{NoteEvent}-Objekt das erste Objekt der
1185 @code{'elements}-Eigenschaft von @code{someNote}.
1187 Die @code{display-scheme-music}-Funktion ist die Funktion, die von
1188 @code{\displayMusic} eingesetzt wird, um die Scheme-Repräsentation
1189 eines musikalischen Ausdrucks anzuzeigen.
1192 #(display-scheme-music (first (ly:music-property someNote 'elements)))
1197 (ly:make-duration 2 0 1 1)
1199 (ly:make-pitch 0 0 0))
1202 Danach wird die Tonhöhe der Note von der @code{'pitch}-Eigenschaft
1203 des @code{NoteEvent}-Objektes gelesen:
1206 #(display-scheme-music
1207 (ly:music-property (first (ly:music-property someNote 'elements))
1210 (ly:make-pitch 0 0 0)
1213 Die Tonhöhe einer Note kann geändert werden, indem man diese
1214 @code{'pitch}-Eigenschaft umdefiniert:
1216 @funindex \displayLilyMusic
1217 @funindex displayLilyMusic
1220 #(set! (ly:music-property (first (ly:music-property someNote 'elements))
1222 (ly:make-pitch 0 1 0)) ;; Die Tonhöhen auf d' verändern.
1223 \displayLilyMusic \someNote
1229 @node Verdoppelung einer Note mit Bindebögen (Beispiel)
1230 @subsection Verdoppelung einer Note mit Bindebögen (Beispiel)
1231 @translationof Doubling a note with slurs (example)
1233 In diesem Abschnitt soll gezeigt, werden, wie man eine
1234 Funktion erstellt, die eine Eingabe wie @code{a}
1235 nach @code{@{ a( a) @}} umdefiniert. Dazu wird zuerst die
1236 interne Repräsentation der Musik betrachtet, die
1237 das Endergebnis darstellt:
1240 \displayMusic@{ a'( a') @}
1253 (ly:make-duration 2 0 1 1)
1255 (ly:make-pitch 0 5 0))
1264 (ly:make-duration 2 0 1 1)
1266 (ly:make-pitch 0 5 0))))
1269 Eine schlechte Nachricht ist, dass die
1270 @code{SlurEvent}-Ausdrücke @qq{innerhalb}
1271 der Noten (in ihrer @code{articulations}-Eigenschaft) hinzugefügt werden müssen.
1273 Jetzt folgt eine Betrachtung der Eingabe:
1281 (ly:make-duration 2 0 1 1)
1283 (ly:make-pitch 0 5 0))))
1286 In der gewünschten Funktion muss also dieser Ausdruck
1287 kopiert werden (sodass zwei Noten vorhanden sind, die
1288 eine Sequenz bilden), dann müssen @code{SlurEvent}
1289 zu der @code{'articulations}-Eigenschaft jeder Noten hinzugefügt
1290 werden, und schließlich muss eine @code{SequentialMusic}
1291 mit den beiden @code{EventChords} erstellt werden. Um zu
1292 einer Eigenschaft etwas hinzuzufügen, ist es nützlich zu wissen, dass
1293 eine nicht gesetzte Eigenschaft als @code{'()} gelesen wird, sodass
1294 keine speziellen Überprüfungen nötig sind, bevor ein anderes
1295 Element vor die @code{articulations}-Eigenschaft gesetzt wird.
1298 doubleSlur = #(define-music-function (parser location note) (ly:music?)
1299 "Return: @{ note ( note ) @}.
1300 `note' is supposed to be a single note."
1301 (let ((note2 (ly:music-deep-copy note)))
1302 (set! (ly:music-property note 'articulations)
1303 (cons (make-music 'SlurEvent 'span-direction -1)
1304 (ly:music-property note 'articulations)))
1305 (set! (ly:music-property note2 'articulations)
1306 (cons (make-music 'SlurEvent 'span-direction 1)
1307 (ly:music-property note2 'articulations)))
1308 (make-music 'SequentialMusic 'elements (list note note2))))
1312 @node Artikulationszeichen zu Noten hinzufügen (Beispiel)
1313 @subsection Artikulationszeichen zu Noten hinzufügen (Beispiel)
1314 @translationof Adding articulation to notes (example)
1316 Am einfachsten können Artikulationszeichen zu Noten
1317 hinzugefügt werden, indem man zwei musikalische Funktionen
1318 in einen Kontext einfügt, wie erklärt in
1319 @ruser{Kontexte erstellen}. Hier soll jetzt eine musikalische
1320 Funktion entwickelt werden, die das vornimmt. Daraus ergibt sich
1321 der zusätzliche Vorteil, dass diese musikalische Funktion eingesetzt
1322 werden kann, um eine Artikulation (wie etwa eine Fingersatzanweisung)
1323 einer einzigen Note innerhalb eines Akkordes hinzugefügt werden
1324 kann, was nicht möglich ist, wenn einfach unabhängige Noten ein einem
1325 Kontext miteinander verschmolzen werden.
1327 Eine @code{$variable} innerhalb von @code{#@{...#@}} ist das
1328 gleiche wie die normale Befehlsform @code{\variable} in
1329 üblicher LilyPond-Notation. Es ist bekannt dass
1336 in LilyPond nicht funktioniert. Das Problem könnte vermieden
1337 werden, indem das Artikulationszeichen an eine Pseudonote
1341 @{ << \music s1*0-.-> @}
1345 aber in diesem Beispiel soll gezeigt werden, wie man das in
1346 Scheme vornimmt. Zunächst wird die Eingabe und die gewünschte
1356 (ly:make-duration 2 0 1 1)
1358 (ly:make-pitch -1 0 0))))
1360 % gewünschte Ausgabe
1371 (ly:make-duration 2 0 1 1)
1373 (ly:make-pitch -1 0 0))
1382 (ly:make-duration 2 0 1 1)
1384 (ly:make-pitch -1 0 0))))
1387 Dabei ist zu sehen, dass eine Note (@code{c4}) als @code{NoteEvent}-Ausdruck
1388 repräsentiert ist. Um eine Akzent-Artikulation hinzuzufügen, muss
1389 ein @code{ArticulationEvent}-Ausdruck zu der Elementeigenschaft @code{articulations}
1390 des @code{NoteEvent}-Ausdrucks hinzugefügt werden.
1392 Um diese Funktion zu bauen, wird folgendermaßen begonnen:
1395 (define (add-accent note-event)
1396 "Add an accent ArticulationEvent to the articulations of `note-event',
1397 which is supposed to be a NoteEvent expression."
1398 (set! (ly:music-property note-event 'articulations)
1399 (cons (make-music 'ArticulationEvent
1400 'articulation-type "accent")
1401 (ly:music-property note-event 'articulations)))
1405 Die erste Zeile definiert eine Funktion in Scheme: Die Bezeichnung
1406 der Funktion ist @code{add-accent} und sie hat eine Variable
1407 mit der Bezeichnung @code{note-event}. In Scheme geht der Typ
1408 einer Variable oft direkt aus der Bezeichnung hervor (das ist auch
1409 eine gute Methode für andere Programmiersprachen).
1416 ist eine (englische) Beschreibung, was diese Funktion tut. Sie ist
1417 nicht unbedingt notwendig, aber genauso wie klare Variablen-Bezeichnungen
1418 ist auch das eine gute Methode.
1420 Es kann seltsam scheinen, warum das Notenereignis direkt verändert wird,
1421 anstatt mit einer Kopie zu arbeiten (@code{ly:music-deep-copy} kann dafür
1422 benützt werden). Der Grund ist eine stille Übereinkunft: musikalische
1423 Funktionen dürfen ihre Argumente verändern: sie werden entweder von
1424 Grund auf erstellt (wie Eingabe des Benutzers) oder sind schon kopiert
1425 (etwa Verweis auf eine Variable mit @samp{\Bezeichnung} oder Noten aus
1426 einem Scheme-Ausdruck @samp{$(@dots{})} sind Kopien). Weil es uneffizient
1427 wäre, unnötige Kopien zu erstellen, wird der Wiedergabewert einer musikalischen
1428 Funktion @emph{nicht} kopiert. Um sich also an die Übereinkunft zu halten,
1429 dürfen Argumente nicht mehr als einmal benützt werden, und sie wiederzugeben
1430 zählt als eine Benutzung.
1432 In einem früheren Beispiel wurden Noten konstruiert, indem ein musikalisches
1433 Argument wiederholt wurde. In diesem Fall muss wenigstens eine Wiederholung
1434 eine Kopie ihres Arguments sein. Wenn es keine Kopie ist, können seltsame
1435 Dinge passieren. Wenn man beispielsweise @code{\relative} oder @code{\transpose}
1436 auf die resultierenden Noten anwendet, die die gleichen Elemente mehrmals
1437 enthalten, werden die Elemente mehrmals der @code{\relative}-Veränderung
1438 oder Transposition unterworfen. Wenn man sie einer musikalischen Variable
1439 zuweist, wird dieser Fluch aufgehoben, denn der Verweis auf @samp{\Bezeichnung}
1440 erstellt wiederum eine Kopie, die nicht die Identität der wiederholten
1443 Während die Funktion oben keine musikalische Funktion ist, wird sie
1444 normalerweise inmitten musikalischer Funktionen eingesetzt. Darum
1445 ist es sinnvoll, der gleichen Übereinkunft zu folgen, die für musikalische
1446 Funktionen gelten: Die Eingabe kann verändert worden sein, um die
1447 Ausgabe zu produzieren, und der den Aufruf erstellt, ist verantwortlich
1448 für die Erstellung von Kopien, wenn er immernoch die unveränderten
1449 Argumente benötigt. Wenn man sich LilyPonds eigene Funktionen wie etwa
1450 @code{music-map} anschaut, sieht man, dass sie denselben Prinzipien folgen.
1452 Aber wo waren wir? Jetzt gibt es ein @code{note-event}, das verändert
1453 werden kann, nicht unter Einsatz von @code{ly:music-deep-copy} sondern
1454 aufgrund einer langen Erklärung. Der Akzent wird zu seiner
1455 @code{'articulations}-Liste hinzugefügt:
1458 (set! place neuer-Wert)
1461 Was in diesem Fall @qq{gesetzt} werden soll (@qq{place}) ist die
1462 @q{'articulations}-Eigenschaft des @code{note-event}-Ausdrucks.
1465 (ly:music-property note-event 'articulations)
1468 @code{ly:music-property} ist die Funktion, mit der musikalische
1469 Eigenschaften erreicht werden können (die @code{'articulations},
1470 @code{'duration}, @code{'pitch} usw., die in der Ausgabe von
1471 @code{\displayMusic} weiter oben angezeigt werden). Der neue
1472 Wert ist, was ehemals die @code{'articulations}-Eigenschaft war, mit einem
1473 zusätzlichen Element: dem @code{ArticulationEvent}-Ausdruck,
1474 der aus der Ausgabe von @code{\displayMusic} kopiert werden kann:
1477 (cons (make-music 'ArticulationEvent
1478 'articulation-type "accent")
1479 (ly:music-property result-event-chord 'articulations))
1482 @code{cons} wird benutzt, um ein Element vorne an eine Liste hinzuzufügen,
1483 ohne dass die originale Liste verändert wird. Das ist es, was die
1484 Funktion tun soll: die gleiche Liste wie vorher, aber mit dem neuen
1485 @code{ArticulationEvent}-Ausdruck. Die Reihenfolge innerhalb
1486 der Elementeeigenschaft ist hier nicht relevant.
1488 Wenn schließlich die Akzent-Artikulation zu der entsprechenden
1489 @code{elements}-Eigenschaft hinzugefügt ist, kann
1490 @code{note-event} ausgegeben werden, darum die letzte Zeile
1493 Jetzt wird die @code{add-accent}-Funktion in eine musikalische
1494 Funktion umgewandelt (hierzu gehört etwas syntaktischer Zuckerguß und
1495 eine Deklaration des Typs ihres einzigen @qq{wirklichen} Arguments:
1498 addAccent = #(define-music-function (parser location note-event)
1500 "Add an accent ArticulationEvent to the articulations of `note-event',
1501 which is supposed to be a NoteEvent expression."
1502 (set! (ly:music-property note-event 'articulations)
1503 (cons (make-music 'ArticulationEvent
1504 'articulation-type "accent")
1505 (ly:music-property note-event 'articulations)))
1509 Eine Überprüfung, dass die Funktion richtig arbeitet, geschieht
1513 \displayMusic \addAccent c4
1520 * Optimierungen mit Scheme::
1523 @c node Optimierungen mit Scheme
1524 @c appendixsec Optimierungen mit Scheme
1525 @c translationof Tweaking with Scheme
1527 Wir haben gesehen wie LilyPond-Eingabe massiv beeinflusst
1528 werden kann, indem Befehle wie etwa
1529 @code{\override TextScript #'extra-offset = ( 1 . -1)}
1530 benutzt werden. Aber es wurde gezeigt, dass Scheme noch
1531 mächtiger ist. Eine bessere Erklärung findet sich in der@ref{Scheme-Übung} und in
1532 @ruser{Schnittstellen für Programmierer}.
1534 Scheme kann auch in einfachen @code{\override}-Befehlen
1537 TODO Find a simple example
1538 @c This isn't a valid example with skylining
1539 @c It works fine without padText -td
1542 @lilypond[quote,verbatim,ragged-right]
1543 padText = #(define-music-function (parser location padding) (number?)
1545 \once \override TextScript #'padding = #padding
1549 c4^"piu mosso" b a b
1551 c4^"piu mosso" d e f
1553 c4^"piu mosso" fis a g
1558 Es kann auch benutzt werden, um Befehle zu erstellen:
1560 @c Check this is a valid example with skylining
1561 @c It is - 'padding still works
1563 @lilypond[quote,verbatim,ragged-right]
1564 tempoPadded = #(define-music-function (parser location padding tempotext)
1567 \once \override Score.MetronomeMark #'padding = $padding
1568 \tempo \markup { \bold #tempotext }
1572 \tempo \markup { "Low tempo" }
1574 \tempoPadded #4.0 #"High tempo"
1579 Sogar ganze Musikausdrücke können eingefügt werden:
1581 @lilypond[quote,verbatim,ragged-right]
1582 pattern = #(define-music-function (parser location x y) (ly:music? ly:music?)
1589 \pattern {d16 dis} { ais16-> b\p }