Allgemein > Allgemeine Diskussion

scheme - very basic

(1/1)

harm6:
Hallo,

dieser Beitrag bezieht sich auf diesen thread.
Hier wird versucht zunächst ein paar fundamentale Sachen zu behandeln.

Zuvor:
Die LilyPond-extension-Sprache ist guile!
Man könnte sagen guile ist ein Dialekt von scheme, scheme ist ein Dialekt von lisp.

Um eigene Experimente durchzuführen kann man einen guile-interpreter benutzen.
Auf Linux-systemen einfach ein Terminal öffnen und

--- Code: ---guile
--- Ende Code ---
eingeben, return. (Wie es bei anderen OS funktioniert weiß ich nicht.)
Oder man gibt

--- Code: ---lilypond scheme-sandbox
--- Ende Code ---
ein, return, und landet in LilyPonds eigenem Sandkasten. ;)

Anmerkung:
Es gibt aber einen Unterschied zwischen beiden Möglichkeiten: In der sandbox sind einige häufig benutzte module schon aktiviert, zusätzliche module bieten meistens weitere Befehlsmöglichkeiten. Wenn man direkt in den guile-interpreter geht muß man diese zusätzlichen module selbst aktivieren.

Falls man solche Experimente in einem lilypond-file durchführen möchte, muß man alle Definitionen mit einem #-Zeichen anfangen lassen.

Listen
Fast alles in LilyPond ist in Listen organisiert.
(lisp, von dem guile letztlich abstammt, ist die Abkürzung von list-processing)

Ein Beispiel für eine Liste ist '(1 2 3)
Die Schreibweise (list 1 2 3) bedeutet in diesem Fall dasselbe.


--- Code: ---(define ls '(1 2 3))
--- Ende Code ---
definiert diese Liste als 'ls' mit der sie auch aufgerufen werden kann.

--- Code: ---guile> (define ls '(1 2 3))
guile> ls
(1 2 3)
--- Ende Code ---

Wie kommt man nun an die einzelnen Elemente dieser Liste?
Dazu gibt es fundamentale procedures: car und cdr
car kann das erste Element einer Liste ausgeben. cdr den Rest als neue Liste.

--- Code: ---guile> (car ls)
1
--- Ende Code ---


--- Code: ---guile> (cdr ls)
(2 3)
--- Ende Code ---


Es gibt noch zahreiche Kombinationen von car und cdr, die aber letztlich alle auf diese beiden zurückgehen.
Um beispielsweise das zweite Element einer Liste zu erhalten kann man folgendes benutzen:

--- Code: ---guile> (car (cdr ls))
2
--- Ende Code ---

Dafür gibt es praktischerweise aber eine zusammengefasste, kurze Form: cadr

--- Code: ---guile> (cadr ls)
2
--- Ende Code ---

Wenn man jetzt aber eine sehr lange Liste hat, z.B.

--- Code: ---(define lange-liste '(1 2 3 4 5 6 7 8 9))
--- Ende Code ---
und will jetzt das letzte Element der Liste haben so müßte man

--- Code: ---(car (cdr (cdr (cdr (cdr (cdr (cdr (cdr (cdr lange-liste)))))))))
--- Ende Code ---
eingeben um es zu erhalten.
Ist natürlich nicht sehr praktikabel.

Man kann aber glücklicherweise diese Häufung von cdr auf verschiedene Arten vermeiden.
a) Es gibt die reverse-procedure die eine Liste "umdreht":

--- Code: ---guile> (reverse lange-liste)
(9 8 7 6 5 4 3 2 1)

--- Ende Code ---
Nun kann man wieder das fundamentale car benutzen.

--- Code: ---guile> (car (reverse lange-liste))
9

--- Ende Code ---
b) Es gibt die last-pair-procedure, die das letzte Element einer Liste als neue Liste ausgibt:

--- Code: ---guile> (last-pair lange-liste)
(9)

--- Ende Code ---
Jetzt kann man wieder car brauchen:

--- Code: ---guile> (car (last-pair lange-liste))
9

--- Ende Code ---
c) Falls man

--- Code: ---(use-modules (srfi srfi-1))
--- Ende Code ---
benutzt, so gibt es auch die last-procedure, die das letzte Element direkt ausgibt. (Dann kann man auch first, second, third, ... benutzen.)
srfi-1 ist in LilyPond, sowie in der sandbox standard. Ich benutze last, etc aber nicht so gerne, da es gelegentlich Probleme gibt, falls man die Musik in Variablen gepackt hat und sie first = { ... }, etc genannt hat.
Falls man direkt den guile-interpreter benutzt, muß man das module selbst integrieren.


--- Code: ---guile> (last lange-liste)
9
--- Ende Code ---
bzw

--- Code: ---guile> (use-modules (srfi srfi-1))
guile> (last lange-liste)
9
--- Ende Code ---


Soviel für diesen Beitrag, Fortsetzung folgt. :)

Gruß,
  Harm

Manuela:
Jetzt möchte ich diesen Thread wieder ausgraben  ;)

Das ist ein sehr nützlicher Beitrag, leider ist die versprochene Fortsetzung ausgeblieben. Vll. kann man auch einen neuen Thread starten.

Was ich mir wünschen würde: kurze, leicht verständliche Beispiele für Scheme + Lilypond, die man dann selbst zusammenbauen / ändern kann

z.B. wie eruiere ich die Anzahl der Einträge einer Liste (das habe ich schon herausgefunden  :D )

oder wie eruiere ich die Anzahl der Noten in einem Lilypond-Musik-Ausdruck, Schritt für Schritt beschrieben

Navigation

[0] Themen-Index