Eine Live-Coding-Musik-App bauen · Teil 5 von 18 der Serie
Teil 5: Eine kleine Sprache für Rhythmus
Schreib Rhythmen als Text: bd [~ bd] sd ~ statt verschachtelter Funktionsaufrufe. Ein Tokenizer, ein Parser und ein Compiler machen aus dem Text die Patterns aus Teil 4, ein Fehler wird an seiner Stelle unter dem Eingabefeld markiert, und bei einem kaputten Pattern spielt das letzte gute weiter.
Eine Live-Coding-Musik-App bauenTeil 5 von 18
Auf dieser Seite
Quest-Ziele
- Die Mini-Notation lesen und schreiben: Schritte, Gruppen, Pausen, Wechsel und Ebenen
- Einen Text in Tokens schneiden, die ihre Stelle darin kennen
- Die Tokens zu einem Baum parsen, mit einer Methode pro Regel der Grammatik
- Den Baum mit den Funktionen aus Teil 4 zu einem Pattern kompilieren
- Einen Fehler unter der Stelle anzeigen, an der er gefunden wurde
Die Rhythmen aus Teil 4 lassen sich gut spielen und schlecht lesen. Eine Bassdrum mit einem zusätzlichen Anschlag war sequence([pure('bd'), rest, sequence([rest, pure('bd')]), rest]). Niemand tippt das, während die Musik läuft. Dieselbe Bassdrum lässt sich als bd ~ [~ bd] ~ schreiben.
Diese Kurzform heißt Mini-Notation. Sie stammt aus Tidal und Strudel, wie die Haps aus Teil 4. Dieser Teil baut etwas, das sie liest: eine Funktion mini(), die einen solchen Text nimmt und ein Pattern zurückgibt.
Die Notation
Ein Wort ist der Name eines Sounds. Vorerst sind das die Sounds des Drumcomputers aus Teil 3: bd ist die Bassdrum, die tiefe Trommel, sd die Snare, eine Trommel mit einem Stoß Rauschen darin, hh die geschlossene Hi-Hat, ein kurzes metallisches Ticken, oh die offene Hi-Hat, die nachklingt, und cp der Clap, ein Händeklatschen. Fünf Regeln setzen Wörter zusammen:
bd sd: Schritte, durch Leerzeichen getrennt, teilen sich den Zyklus gleichmäßig. Ein Zyklus ist ein Takt mit vier Schlägen. Bei zwei Schritten hat die Bassdrum die erste Hälfte und die Snare die zweite. Inbd sd hhhat jeder ein Drittel.[bd bd] sd: Eckige Klammern bilden eine Gruppe. Sie steht dort, wo ein Schritt steht, und teilt die Zeit dieses Schritts unter ihren eigenen Schritten auf. Hier teilen sich zwei Bassdrums die erste Hälfte.bd ~ sd ~: Eine Tilde ist eine Pause, ein Schritt, in dem nichts spielt.bd <sd cp>: Spitze Klammern wechseln ab. Sie stehen dort, wo ein Schritt steht, und spielen pro Zyklus einen ihrer Schritte: im ersten Zyklus die Snare, im zweiten den Clap, im dritten wieder die Snare.bd sd, hh hh hh: Ein Komma trennt Ebenen, die gleichzeitig spielen. Jede Ebene teilt den Zyklus für sich: hier zwei Schritte, dort drei.
Die Regeln lassen sich verschachteln. Eine Gruppe darf Ebenen enthalten, wie in [bd, hh hh] sd, und spitze Klammern dürfen Gruppen enthalten.
Drei Stufen
Eine Sprache wird üblicherweise in drei Stufen gelesen, und so ist es auch hier. Der Tokenizer schneidet den Text in Tokens: Wörter und Symbole. Der Parser findet die Struktur in den Tokens und baut einen Baum. Der Compiler geht den Baum ab und macht ein Pattern daraus. Jede Stufe erledigt eine kleine Aufgabe und gibt eine einfachere Form an die nächste weiter.
Alle drei stehen in einer neuen Datei. Lege src/mini.ts an, die so beginnt:
import { pure, sequence, silence, slow, stack, type Pattern } from './pattern.ts';
/** What a step of a pattern holds: the name of a sound or a note, or a number. */
export type Atom = string | number;
/** A mistake in a pattern, with the place in the text where it was found. */
export class MiniError extends Error {
readonly position: number;
constructor(message: string, position: number) {
super(message);
this.position = position;
}
}Ein Atom ist das, was ein einzelner Schritt enthält. Die Drums brauchen nur Namen. Zahlen werden von Anfang an als Zahlen gelesen, weil spätere Teile sie nutzen.
MiniError ist ein Fehler, der weiß, wo er passiert ist: position ist der Index des Zeichens im Text, an dem der Fehler gefunden wurde. Eine Meldung wie Missing "]" hilft in einem langen Pattern wenig. Mit einer Position kann die Seite auf die Stelle zeigen.
Der Tokenizer
Die folgenden Blöcke kommen in dieselbe Datei, einer unter den anderen. Zuerst der Tokenizer:
// ---------------------------------------------------------------------------
// 1. The tokenizer: from characters to tokens
interface Token {
type: 'word' | 'symbol' | 'end';
text: string;
start: number;
end: number;
}
const SYMBOLS = '[]<>,~';
const WORD = /[A-Za-z0-9#.:]/;
function tokenize(source: string): Token[] {
const tokens: Token[] = [];
let at = 0;
while (at < source.length) {
const char = source[at];
if (/\s/.test(char)) {
at += 1;
} else if (SYMBOLS.includes(char)) {
tokens.push({ type: 'symbol', text: char, start: at, end: at + 1 });
at += 1;
} else if (WORD.test(char)) {
const start = at;
while (at < source.length && WORD.test(source[at])) at += 1;
tokens.push({ type: 'word', text: source.slice(start, at), start, end: at });
} else {
throw new MiniError(`Unexpected character "${char}"`, at);
}
}
tokens.push({ type: 'end', text: '', start: source.length, end: source.length });
return tokens;
}Der Tokenizer geht den Text Zeichen für Zeichen durch und kennt drei Fälle. Leerraum wird übersprungen: Er hat seine Arbeit getan, indem er ein Wort beendet hat. Jedes der sechs Symbole ist ein eigenes Token. Eine Folge von Wortzeichen ist ein Wort. Jedes andere Zeichen ist ein Fehler, der mit seinem Index gemeldet wird.
Wortzeichen sind Buchstaben, Ziffern und drei weitere: der Punkt, für Zahlen wie 0.5, sowie # und :, die die Noten aus Teil 8 brauchen.
Jedes Token hält fest, wo es im Text beginnt und endet. Aus dem Pattern bd [~ bd] werden sechs Tokens:
das Wort
bd, von 0 bis 2das Symbol
[, von 3 bis 4das Symbol
~, von 4 bis 5das Wort
bd, von 6 bis 8das Symbol
], von 8 bis 9das Ende, bei 9
Das letzte Token markiert das Ende des Texts. Damit muss der Parser nie fragen, ob noch Tokens übrig sind, und ein Pattern, das zu früh aufhört, hat eine Position, auf die sich zeigen lässt.
Die Grammatik
Eine Grammatik sagt, welche Reihenfolgen von Tokens ein Pattern sind. Diese hat drei Regeln. Sie stehen als Kommentare über den Methoden des Parsers, in einer Kurzform, in der | „oder“ bedeutet, * „beliebig oft“, runde Klammern zusammenhalten, was der Stern wiederholt, und Symbole in Anführungszeichen für sich selbst stehen:
layers = sequence ("," sequence)*: Ebenen sind eine Abfolge oder mehrere Abfolgen mit Kommas dazwischen.sequence = step*: Eine Abfolge besteht aus beliebig vielen Schritten, bis zu dem, was sie schließt: ein], ein>, ein Komma oder das Ende des Texts.step = word | "~" | "[" layers "]" | "<" layers ">": Ein Schritt ist ein Wort oder eine Pause oder Ebenen in eckigen Klammern oder Ebenen in spitzen Klammern.
Die Regeln führen im Kreis: Ebenen bestehen aus Abfolgen, Abfolgen aus Schritten, und ein Schritt kann wieder Ebenen enthalten. Durch diesen Kreis lassen sich Klammern beliebig tief verschachteln.
Der Parser
Das Ergebnis des Parsers ist ein Baum aus Knoten. Es gibt fünf Arten:
// ---------------------------------------------------------------------------
// 2. The parser: from tokens to a tree
export type Node =
| { type: 'atom'; value: Atom }
| { type: 'rest' }
| { type: 'sequence'; steps: Node[] }
| { type: 'stack'; layers: Node[] }
| { type: 'alternate'; steps: Node[] };Der Parser selbst hat eine Methode pro Regel der Grammatik, und die Methoden rufen einander so auf, wie die Regeln aufeinander verweisen. Diese Art, einen Parser zu schreiben, heißt rekursiver Abstieg.
class Parser {
private readonly tokens: Token[];
private at = 0;
constructor(tokens: Token[]) {
this.tokens = tokens;
}
private peek(): Token {
return this.tokens[this.at];
}
private next(): Token {
const token = this.peek();
if (token.type !== 'end') this.at += 1;
return token;
}
private isSymbol(text: string): boolean {
const token = this.peek();
return token.type === 'symbol' && token.text === text;
}
private expect(text: string) {
const token = this.next();
if (token.type === 'symbol' && token.text === text) return;
throw new MiniError(
token.type === 'end' ? `Missing "${text}"` : `Expected "${text}" but found "${token.text}"`,
token.start,
);
}
/** The whole pattern: layers up to the end of the text. */
parse(): Node {
const node = this.parseLayers();
const token = this.peek();
if (token.type !== 'end') throw new MiniError(`Unexpected "${token.text}"`, token.start);
return node;
}
/** layers = sequence ("," sequence)* */
private parseLayers(): Node {
const layers = [this.parseSequence()];
while (this.isSymbol(',')) {
this.next();
layers.push(this.parseSequence());
}
return layers.length === 1 ? layers[0] : { type: 'stack', layers };
}
/** sequence = step*, up to whatever closes it */
private parseSequence(): Node {
const steps: Node[] = [];
while (!this.atSequenceEnd()) steps.push(this.parseStep());
return { type: 'sequence', steps };
}
private atSequenceEnd(): boolean {
const token = this.peek();
return token.type === 'end' || (token.type === 'symbol' && ']>,'.includes(token.text));
}
/** step = word | "~" | "[" layers "]" | "<" layers ">" */
private parseStep(): Node {
const token = this.next();
if (token.type === 'word') {
const number = Number(token.text);
return { type: 'atom', value: Number.isFinite(number) ? number : token.text };
}
if (token.text === '~') return { type: 'rest' };
if (token.text === '[') {
const inner = this.parseLayers();
this.expect(']');
return inner;
}
if (token.text === '<') {
const inner = this.parseLayers();
this.expect('>');
return alternate(inner);
}
throw new MiniError(
token.type === 'end' ? 'The pattern ends too early' : `Unexpected "${token.text}"`,
token.start,
);
}
}Die ersten vier Methoden sind das Werkzeug des Parsers. peek() sieht sich das nächste Token an, next() nimmt es und geht weiter, aber nie über das End-Token hinaus. isSymbol() fragt, ob als Nächstes ein bestimmtes Symbol kommt, und expect() verlangt eines und wirft einen MiniError, wenn dort etwas anderes steht.
parseLayers() liest eine Abfolge und nach jedem Komma eine weitere. Eine einzelne Ebene wird so zurückgegeben, wie sie ist. Nur mehrere Ebenen bekommen einen stack-Knoten um sich herum.
parseSequence() sammelt Schritte, bis ein Token kommt, das die Abfolge schließt. Dieses Token lässt sie stehen: Wer die Klammer geöffnet hat, will sie geschlossen sehen.
parseStep() entscheidet nach dem nächsten Token. Ein Wort wird ein Atom, und zwar eine Zahl, wenn es sich als Zahl lesen lässt. Eine Tilde wird eine Pause. Nach einem [ liest die Methode Ebenen, verlangt das ] und gibt zurück, was darin stand. Eine Gruppe braucht keinen eigenen Knoten, denn eine Abfolge in einer Abfolge ist schon eine. Nach einem < tut sie dasselbe und übergibt das Ergebnis an alternate(), das unter der Klasse folgt:
/** `<a b, c d>` alternates in each of its layers. */
function alternate(node: Node): Node {
if (node.type === 'stack') return { type: 'stack', layers: node.layers.map(alternate) };
return { type: 'alternate', steps: node.type === 'sequence' ? node.steps : [node] };
}Die Schritte der Abfolge in den spitzen Klammern werden die Schritte eines alternate-Knotens. Standen Ebenen darin, wie in <bd sd, hh oh cp>, wechselt jede Ebene für sich ab: Die erste ist nach zwei Zyklen wieder vorn, die zweite nach drei.
Für bd [~ bd] sd ~ gibt der Parser einen Baum zurück, dessen Wurzel eine Abfolge aus vier Schritten ist:
das Atom
bdeine Abfolge aus zwei Schritten, eine Pause und das Atom
bddas Atom
sdeine Pause
Die Fehler ergeben sich aus denselben Methoden. In bd [sd endet die Abfolge in der Klammer am Ende des Texts, expect(']') findet das End-Token, und der Fehler ist Missing "]" an Position 6. In bd sd] hält die äußere Abfolge an der Klammer an, die niemand geöffnet hat, und parse() meldet Unexpected "]" an Position 5.
Der Compiler
Der Baum sagt, was der Text bedeutet, und die Funktionen aus Teil 4 können es spielen. Der Compiler bringt beides zusammen:
// ---------------------------------------------------------------------------
// 3. The compiler: from the tree to a pattern
function compile(node: Node): Pattern<Atom> {
switch (node.type) {
case 'atom':
return pure(node.value);
case 'rest':
return silence();
case 'sequence':
return compileSteps(node.steps);
case 'stack':
return stack(node.layers.map(compile));
case 'alternate':
// All steps in a row, slowed down so that each one fills a cycle.
return slow(node.steps.length, compileSteps(node.steps));
}
}
function compileSteps(steps: Node[]): Pattern<Atom> {
if (steps.length === 0) return silence();
if (steps.length === 1) return compile(steps[0]);
return sequence(steps.map(compile));
}
/** Reads a pattern in mini-notation. Throws a MiniError if the text is not one. */
export function mini(source: string): Pattern<Atom> {
return compile(new Parser(tokenize(source)).parse());
}compile() hat einen Fall pro Art von Knoten, und jeder Fall ist ein Aufruf. Ein Atom wird pure, eine Pause silence, Ebenen ein stack, Schritte eine sequence. Aus dem Baum oben wird sequence([pure('bd'), sequence([silence(), pure('bd')]), pure('sd'), silence()]), ein Ausdruck von der Art, die Teil 4 von Hand geschrieben hat.
Das Abwechseln braucht keine eigene Funktion. <sd cp> ist die Abfolge seiner zwei Schritte, um deren Anzahl verlangsamt, sodass jeder Schritt einen ganzen Zyklus füllt: die Snare Zyklus 0, der Clap Zyklus 1, die Snare Zyklus 2. In bd <sd cp> wird dieses Pattern in die zweite Hälfte des Zyklus gepresst, und compress behält die Nummer des Zyklus, wie Teil 4 angemerkt hat. Also spielt die zweite Hälfte von Zyklus 0 die Snare und die zweite Hälfte von Zyklus 1 den Clap.
compileSteps() spart in zwei Fällen Arbeit: Ohne Schritte ist das Ergebnis Stille, und ein einzelner Schritt braucht keine Abfolge um sich herum. Ein leerer Text ist deshalb kein Fehler. Er ist ein stilles Pattern.
mini() am Ende sind die drei Stufen in einer Zeile und die einzige Funktion der Datei, die die Seite braucht.
Ein Eingabefeld auf der Seite
Die Buttons aus Teil 4 machen Platz für ein Eingabefeld und darunter eine Zeile für den Fehler. Ersetze in index.html das Element main. Die spitzen Klammern des Patterns werden im HTML als < und > geschrieben:
<main class="stage">
<div class="line">
<input id="pattern" value="bd [~ bd] sd ~, hh hh hh <hh oh>" spellcheck="false" autocomplete="off" />
<p id="message" class="message"></p>
</div>
<p class="hint">Press Play, then change the pattern. Sounds: bd sd hh oh cp rim lt mt ht cb cy</p>
</main>Ersetze am Ende von src/style.css die Regel .beats durch:
.line {
width: min(640px, 90vw);
}
.line input {
width: 100%;
padding: 8px 10px;
border: 2px solid var(--edge);
border-radius: 4px;
background: var(--night);
color: var(--text);
font: inherit;
}
.line input:focus {
outline: none;
border-color: var(--lilac);
}
.message {
min-height: 1.4em;
margin: 4px 0 0;
padding: 0 12px;
color: var(--orange);
white-space: pre;
}Zwei Einzelheiten der letzten Regel gehören zur Fehlerzeile. white-space: pre erhält die Leerzeichen, die die Markierung an ihre Stelle schieben werden. Und die 12 Pixel Innenabstand sind der Rahmen des Eingabefelds plus sein Innenabstand, das erste Zeichen der Meldung sitzt also genau unter dem ersten Zeichen im Eingabefeld. Die Schrift der Seite gibt jedem Zeichen dieselbe Breite, und damit ist der Rest eine Sache des Zählens.
Ersetze in src/main.ts alles von den Importen bis einschließlich der Uhr. Die Funktionen aus ./pattern.ts werden hier nicht mehr gebraucht, nur der Typ Pattern, und mini, MiniError und Atom kommen aus ./mini.ts:
import { audio } from './audio.ts';
import { Clock } from './clock.ts';
import { Drums } from './drums.ts';
import { mini, MiniError, type Atom } from './mini.ts';
import type { Pattern } from './pattern.ts';
import './style.css';
const drums = new Drums(audio().destination);
const input = document.querySelector<HTMLInputElement>('#pattern')!;
const message = document.querySelector<HTMLParagraphElement>('#message')!;
let pattern: Pattern<Atom> = mini(input.value);
const clock = new Clock((from, to) => {
for (const hap of pattern(from, to)) drums.play(String(hap.value), clock.timeAt(hap.begin));
});Das Pattern wird beim Start einmal aus dem Text des Eingabefelds gelesen. Der Callback der Uhr hat eine Änderung: Ein Atom kann jetzt eine Zahl sein, und die Drums wollen einen Namen, also steht String() um den Wert.
Ergänze unter der Uhr den Listener, der das Eingabefeld liest. Entferne dann weiter unten die Schleife, die die Buttons für die Rhythmen erzeugt hat, samt ihrem Kommentar und der Zeile, die #beats gesucht hat:
// Every key stroke is read. A pattern that can't be read leaves the last good one playing.
input.addEventListener('input', () => {
try {
pattern = mini(input.value);
message.textContent = '';
} catch (error) {
if (!(error instanceof MiniError)) throw error;
// Point at the place of the mistake, under the input's text.
message.textContent = `${' '.repeat(error.position)}^ ${error.message}`;
}
});Der Text wird bei jedem Tastendruck neu gelesen. Ist er ein Pattern, ersetzt es das Pattern, das gerade spielt, und wie in Teil 4 bleibt die Musik im Takt. Ist er keines, wirft mini() einen Fehler, bevor pattern zugewiesen wird. Das letzte gute Pattern spielt weiter, und die Zeile unter dem Eingabefeld zeigt ein ^ unter der Stelle des Fehlers, gefolgt von der Meldung.
Das ist wichtiger, als es aussieht. Fast jedes Pattern ist beim Tippen einen Moment lang kaputt: nach dem [ und vor dem ]. Dafür darf die Musik nicht anhalten. Ein Fehler, der kein MiniError ist, wird weitergeworfen, denn er wäre ein Fehler in src/mini.ts und kein Tippfehler.
Probier es aus
Drück auf Play. Das Pattern im Eingabefeld hat zwei Ebenen. Die erste ist die Bassdrum auf Schlag 1, eine zweite Bassdrum kurz vor der Snare und die Snare auf Schlag 3. Die zweite ist eine Hi-Hat auf jedem Schlag, und in jedem zweiten Takt ist die vierte eine offene Hi-Hat.
Tipp jetzt, während es spielt:
Lösch das
]. Unter dem Ende des Texts erscheintMissing "]", und der Rhythmus läuft unverändert weiter. Setz die Klammer wieder ein.Ersetze alles durch
bd sd, hh hh hh: zwei Schritte gegen drei im selben Takt.Probier
<bd sd cp>: ein Sound pro Takt, alle drei Takte wieder dasselbe.Setz Gruppen in Gruppen:
bd [sd [hh hh]]. Jede Verschachtelung halbiert die Zeit.Tipp
bd*2. Die Markierung steht unter dem Stern:Unexpected character "*". Die Sprache kennt ihn noch nicht. Teil 6 bringt ihn ihr bei.
Kommentare
Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.
Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.