@c -*- coding: utf-8; mode: texinfo; documentlanguage: de -*-
@ignore
- Translation of GIT committish: 233fb6a8b3b6e31de1841641dbbd4c4f43423151
+ Translation of GIT committish: e5a609e373eae846857f9a6d70a402a3d42b7d94
When revising a translation, copy the HEAD committish of the
version that you are working on. For details, see the Contributors'
Guide, node Updating translation committishes..
@end ignore
-@c \version "2.16.0"
+@c \version "2.19.22"
-@node Scheme-Übung
-@chapter Scheme-Übung
+@node Scheme-Tutorium
+@chapter Scheme-Tutorium
@translationof Scheme tutorial
* LilyPond Scheme-Syntax::
* LilyPond-Variablen::
* Eingabe-Variablen und Scheme::
+* Scheme in LilyPond importieren::
* Objekteigenschaften::
* Zusammengesetzte LilyPond-Variablen::
* Interne musikalische Repräsentation::
Die Eingabe von LilyPond ist in Zeichen und Ausdrücke gegliedert, so etwa
wie die menschliche Sprache sich in Wörter und Sätze gliedert. LilyPond
hat einen Lexer, der Zeichen erkennt (Zahlen, Zeichenketten, Scheme-Elemente,
-Tonhöhen usw.) und einen Parser, der die Syntax versteht, @ruser{LilyPond grammar}.
+Tonhöhen usw.) und einen Parser, der die Syntax versteht,
+@rcontribnamed{LilyPond grammar, LilyPond-Grammatik}.
Wenn dann eine bestimmte Syntaxregel als zuständig erkannt wurde, werden die
damit verknüpften Aktionen ausgeführt.
übergeben.
Das ist auch der gleiche Mechanismus, nach dem LilyPond funktioniert, wenn man eine Variable oder musikalische Funktion mit ihrer Bezeichnung ausruft, wie
-in @code{\Bezeichnung}, mit dem einzigen Unterschied, dass ihr Ende durch den
+in @code{\Bezeichnung}, mit dem einzigen Unterschied, dass ihre Bezeichnung durch den
LilyPond-Lexer bestimmt wird, ohne den Scheme-reader einzubeziehen, und also
nur Variablen akzeptiert werden, die im aktuellen LilyPond-Modus gültig sind.
-Die direkte Auswirkung von @code{$} kann zu Überraschungen führen, siehe auch
+Die direkte Auswirkung von @code{$} kann zu Überraschungen führen, siehe
@ref{Eingabe-Variablen und Scheme}. Es bietet sich daher an, @code{#} immer
-zu benützen, wenn der Parser es unterstützt.
+zu benützen, wenn der Parser es unterstützt. Innerhalb von musikalischen
+Ausdrücken werden Ausdrücke, die mit @code{#} erstellt werden, @emph{tatsächlich}
+als Noten interpretiert. Sie werden jedoch @emph{nicht} vor der Benutzung
+kopiert. Wenn Sie Teil einer Struktur sind, die noch einmal benutzt werden
+soll, muss man eventuell @code{ly:music-deep-copy} explizit einsetzen.
+
+@funindex $@@
+@funindex #@@
+
+Es gibt auch die Operatoren @code{$@@} und @code{#@@}, die eine @qq{listentrennende}
+Funktion aufweisen, indem sie alle Elemente einer Liste in den umgebenden
+Kontext einfügen.
Jetzt wollen wir uns tatsächlichen Scheme-Code anschauen. Scheme-Prozeduren
können in LilyPond-Eingabedateien definiert werden:
#(define twice
(make-sequential-music newLa))
-{ \twice }
+\twice
@end lilypond
Das ist ein interessantes Beispiel. Die Zuweisung findet erst statt,
auszuwerten, so dass er weiterlesen und erst @emph{danach}
wird der Scheme-Code ohne Probleme ausführen kann.
+
+@node Scheme in LilyPond importieren
+@subsection Scheme in LilyPond importieren
+@translationof Importing Scheme in LilyPond
+
+@funindex $
+@funindex #
+
Das Beispiel zeigt, wie man musikalische Ausdrücke aus der Eingabe in den
Scheme-Auswerter @qq{exportieren} kann. Es geht auch andersherum. Indem
man Scheme-Werte nach @code{$} schreibt, wird ein
@example
...
-@{ $(make-sequential-music (list newLa)) @}
+$(make-sequential-music newLa)
@end example
Mann kann @code{$} zusammen mit einem Scheme-Ausdruck überall benutzen,
noch nicht definiert worden wäre. Zu einer Erklärung dieses Timingproblems
siehe @ref{LilyPond Scheme-Syntax}.
-Auf jeden Fall findet die Auswertung des Scheme-Codes spätestens im Parser
-statt. Wenn man es noch später ausgeführt haben möchte, muss man
+@funindex $@@
+@funindex #@@
+
+Eine weitere Bequemlichkeit können die @qq{listentrennenden} Operatoren
+@code{$@@} und @code{#@@} bieten, indem sie die Elemente einer Liste
+in den umgebenden Kontext einfügen. Wenn man sie einsetzt, hätte der
+letzte Teil des Beispiels auch so geschrieben werden können:
+
+@example
+...
+@{ #@@newLa @}
+@end example
+
+Hier wird jedes Element der Liste, welche in @code{newLa} gespeichert ist,
+der Reihenfolge nach genommen und in die Liste eingefügt, als ob man
+geschrieben hätte:
+
+@example
+@{ #(first newLa) #(second newLa) @}
+@end example
+
+In allen diesen Formen findet die Auswertung des Scheme-Codes statt,
+während die Eingabe noch gelesen wird, entweder im Lexer oder im Parser.
+Wenn man es später ausgeführt haben möchte, muss man
@ref{Leere Scheme-Funktionen} benutzen oder es in einem Makro speichern:
@example
LilyPond-Syntax hierfür ist:
@example
-\override Stem #'thickness = #2.6
+\override Stem.thickness = #2.6
@end example
Diese Anweisung verändert die Erscheinung der Notenhälse. Der Alist-Eintrag
Y-Koordinate.
@example
-\override TextScript #'extra-offset = #'(1 . 2)
+\override TextScript.extra-offset = #'(1 . 2)
@end example
Hierdurch wird das Paar @code{(1 . 2)} mit der Eigenschaft @code{extra-offset}
@cindex Musikausdrücke anzeigen
@cindex Anzeigen von Musikausdrücken
-@funindex displayMusic
@funindex \displayMusic
Wenn man eine musikalische Funktion erstellt, ist es oft
'text
"f"))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))))
@end example
@example
@{
- $(with-output-to-file "display.txt"
+ #(with-output-to-file "display.txt"
(lambda () #@{ \displayMusic @{ c'4\f @} #@}))
@}
@end example
(make-music 'AbsoluteDynamicEvent
'text
"f"))
- 'duration (ly:make-duration 2 0 1 1)
+ 'duration (ly:make-duration 2 0 1/1)
'pitch (ly:make-pitch 0 0 0))))
@end example
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))
@end example
(list (make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))))
@end example
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))
@end example
@code{'pitch}-Eigenschaft umdefiniert:
@funindex \displayLilyMusic
-@funindex displayLilyMusic
@example
#(set! (ly:music-property (first (ly:music-property someNote 'elements))
'span-direction
-1))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 5 0))
(make-music
'span-direction
1))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 5 0))))
@end example
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 5 0))))
@end example
Element vor die @code{articulations}-Eigenschaft gesetzt wird.
@example
-doubleSlur = #(define-music-function (parser location note) (ly:music?)
+doubleSlur = #(define-music-function (note) (ly:music?)
"Return: @{ note ( note ) @}.
`note' is supposed to be a single note."
(let ((note2 (ly:music-deep-copy note)))
Am einfachsten können Artikulationszeichen zu Noten
hinzugefügt werden, indem man zwei musikalische Funktionen
in einen Kontext einfügt, wie erklärt in
-@ruser{Kontexte erstellen}. Hier soll jetzt eine musikalische
+@ruser{Kontexte erstellen und referenzieren}. Hier soll jetzt eine musikalische
Funktion entwickelt werden, die das vornimmt. Daraus ergibt sich
der zusätzliche Vorteil, dass diese musikalische Funktion eingesetzt
werden kann, um eine Artikulation (wie etwa eine Fingersatzanweisung)
@noindent
in LilyPond nicht funktioniert. Das Problem könnte vermieden
-werden, indem das Artikulationszeichen an eine Pseudonote
+werden, indem das Artikulationszeichen an einen leeren Akkord
gehängt wird:
@example
-@{ << \music s1*0-.-> @}
+@{ << \music <> -. -> >> @}
@end example
@noindent
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch -1 0 0))))
=====
'articulation-type
"accent"))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch -1 0 0))
\displayMusic c4
(list (make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch -1 0 0))))
@end example
eine Deklaration des Typs ihres einzigen @qq{wirklichen} Arguments:
@example
-addAccent = #(define-music-function (parser location note-event)
+addAccent = #(define-music-function (note-event)
(ly:music?)
"Add an accent ArticulationEvent to the articulations of `note-event',
which is supposed to be a NoteEvent expression."
Wir haben gesehen wie LilyPond-Eingabe massiv beeinflusst
werden kann, indem Befehle wie etwa
-@code{\override TextScript #'extra-offset = ( 1 . -1)}
+@code{\override TextScript.extra-offset = ( 1 . -1)}
benutzt werden. Aber es wurde gezeigt, dass Scheme noch
-mächtiger ist. Eine bessere Erklärung findet sich in der@ref{Scheme-Übung} und in
+mächtiger ist. Eine bessere Erklärung findet sich in der@ref{Scheme-Tutorium} und in
@ruser{Schnittstellen für Programmierer}.
Scheme kann auch in einfachen @code{\override}-Befehlen
@lilypond[quote,verbatim,ragged-right]
-padText = #(define-music-function (parser location padding) (number?)
+padText = #(define-music-function (padding) (number?)
#{
- \once \override TextScript #'padding = #padding
+ \once \override TextScript.padding = #padding
#})
-\relative c''' {
- c4^"piu mosso" b a b
+\relative {
+ c'''4^"piu mosso" b a b
\padText #1.8
c4^"piu mosso" d e f
\padText #2.6
@c It is - 'padding still works
@lilypond[quote,verbatim,ragged-right]
-tempoPadded = #(define-music-function (parser location padding tempotext)
- (number? string?)
+tempoPadded = #(define-music-function (padding tempotext)
+ (number? markup?)
#{
- \once \override Score.MetronomeMark #'padding = $padding
+ \once \override Score.MetronomeMark.padding = #padding
\tempo \markup { \bold #tempotext }
#})
-\relative c'' {
+\relative {
\tempo \markup { "Low tempo" }
- c4 d e f g1
- \tempoPadded #4.0 #"High tempo"
+ c''4 d e f g1
+ \tempoPadded #4.0 "High tempo"
g4 f e d c1
}
@end lilypond
Sogar ganze Musikausdrücke können eingefügt werden:
@lilypond[quote,verbatim,ragged-right]
-pattern = #(define-music-function (parser location x y) (ly:music? ly:music?)
+pattern = #(define-music-function (x y) (ly:music? ly:music?)
#{
- $x e8 a b $y b a e
+ #x e8 a b $y b a e
#})
\relative c''{
projects / lilypond.git / blobdiff