Reading 27: Little Languages I

music.midi.MidiSequencePlayer uses the Java MIDI APIs to play sequences of notes. It’s quite a bit of code, and you don’t need to understand how it works.

MidiSequencePlayer implements the music.SequencePlayer interface, allowing clients to use it without depending on the particular MIDI implementation. We do need to understand this interface and the types it depends on:

addNote : SequencePlayer × Instrument × Pitch × double × double → void (SequencePlayer.java) is the workhorse of our music player. Calling this method schedules a musical pitch to be played at some time during the piece of music.

play : SequencePlayer → void (SequencePlayer.java) actually plays the music. Until we call this method, we’re just scheduling music that will, eventually, be played.

The addNote operation depends on two more types:

Instrument is an enumeration of all the available MIDI instruments.

Pitch is an abstract data type for musical pitches (think keys on the piano keyboard).

Using the MIDI sequence player and Pitch, we’re ready to write code for our first bit of music!

The Pitch datatype is useful, but if we want to represent a whole piece of music using Pitch objects, we should create an abstract data type to encapsulate that representation.

To start, we’ll define the Music type with a few operations:

notes : String × Instrument → Music (MusicLanguage.java) makes a new Music from a string of simplified abc notation, described below.

duration : Music → double (Music.java) returns the duration, in beats, of the piece of music.

play : Music × SequencePlayer × double → void (Music.java) plays the piece of music using the given sequence player.

We’ll implement duration and play as instance methods of Music, so we declare them in the Music interface.

notes will be a static factory method; rather than put it in Music (which we could do), we’ll put it in a separate class: MusicLanguage will be our place for all the static methods we write to operate on Music.

Now that we’ve chosen some operations in the spec of Music, let’s choose a representation.

• Looking at ScaleSequence, the first concrete variant that might jump out at us is one to capture the information in each call to addNote: a particular pitch on a particular instrument played for some amount of time. We’ll call this a Note.

• The other basic element of music is the silence between notes: Rest.

• Finally, we need a way to glue these basic elements together into larger pieces of music. We’ll choose a tree-like structure: Concat(m1,m2:Music) represents m1 followed by m2, where m1 and m2 are any music.

  This tree structure turns out to be an elegant decision as we further develop our Music type later on. In a real design process, we might have had to iterate on the recursive structure of Music before we found the best implementation.

Here’s the datatype definition:

Music = Note(duration:double, pitch:Pitch, instrument:Instrument)
        + Rest(duration:double)
        + Concat(m1:Music, m2:Music)

Composite

Music is an example of the composite pattern, in which we treat both single objects (primitives, e.g. Note and Rest) and groups of objects (composites, e.g. Concat) the same way.

• Formula is also an example of the composite pattern.

• The graphical user interface (GUI) view tree relies heavily on the composite pattern: there are primitive views like JLabel and JTextField that don’t have children, and composite views like JPanel and JScrollPane that do contain other views as children. Both implement the common JComponent interface.

The composite pattern gives rise to a tree data structure, with primitives at the leaves and composites at the internal nodes.

Emptiness

One last design consideration: how do we represent the empty music? It’s always good to have a representation for nothing, and we’re certainly not going to use null.

We could introduce an Empty variant, but instead we’ll use a Rest of duration 0 to represent emptiness.

First we need to create the Note, Rest, and Concat variants. All three are straightforward to implement, starting with constructors, checkRep, some observers, toString, and the equality methods.

• Since the duration operation is an instance method, each variant implements duration appropriately.

• The play operation is also an instance method; we’ll discuss it below under implementing the player.

We’ll discuss the notes operation, implemented as a static method in class MusicLanguage under implementing the parser.

To avoid representation dependence, let’s add some additional static factory methods for building Music instances:

note : double × Pitch × Instrument → Music (MusicLanguage.java)

rest : double → Music (MusicLanguage.java)

concat : Music × Music → Music (MusicLanguage.java) is our first producer operation.

All three of them are easy to implement by constructing the appropriate variant.

import music.*;
import static music.Instrument.*;
import static music.MusicLanguage.*;

We will write pieces of music using a simplified version of abc notation, a text-based music format.

We’ve already been representing pitches using their familiar letters. Our simplified abc notation represents sequences of notes and rests with syntax for indicating their duration, accidental (sharp or flat), and octave.

For example:

C D E F G A B C' B A G F E D C represents the one-octave ascending and descending C major scale we played in ScaleSequence. C is middle C, and C' is C one octave above middle C. Each note is a quarter note.

C/2 D/2 _E/2 F/2 G/2 _A/2 _B/2 C'/2 is the ascending scale in C minor, played twice as fast. The E, A, and B are flat. Each note is an eighth note.

If you’re not familiar with music theory — why is an octave 8 notes but only 12 semitones? — don’t worry. You might not be able to look at the abc strings and guess what they sound like, but you can understand the point of choosing a convenient textual syntax.

The notes method parses strings of simplified abc notation into Music.

notes : String × Instrument → Music (MusicLanguage.java) splits the input into individual symbols (e.g. A,,/2, .1/2). We start with the empty Music, rest(0), parse symbols individually, and build up the Music using concat.

parseSymbol : String × Instrument → Music (MusicLanguage.java) returns a Rest or a Note for a single abc symbol (symbol in the grammar). It only parses the type (rest or note) and duration; it relies on parsePitch to handle pitch letters, accidentals, and octaves.

parsePitch : String → Pitch (MusicLanguage.java) returns a Pitch by parsing a pitch grammar production. You should be able to understand the recursion — what’s the base case? What are the recursive cases?

Recall our operation for playing music:

play : Music × SequencePlayer × double → void (Music.java) plays the piece of music using the given sequence player after the given number of beats delay.

Why does this operation take atBeat? Why not simply play the music now?

If we define play in that way, we won’t be able to play sequences of notes over time unless we actually pause during the play operation, for example with Thread.sleep. Our sequence player’s addNote operation is already designed to schedule notes in the future — it handles the delay.

With that design decision, it’s straightforward to implement play in every variant of Music.

Just one more piece of utility code before we’re ready to jam: music.midi.MusicPlayer plays a Music using the MidiSequencePlayer. Music doesn’t know about the concrete type of the sequence player, so we need a bit of code to bring them together.

Bringing this all together, let’s use the Music ADT:

import music.*;
import static music.Instrument.*;
import static music.MusicLanguage.*;

Music r = rest(1);
Pitch p = new Pitch('A').transpose(6);
Music n = note(1, p, GLOCKENSPIEL);
List<Music> s = List.of(r, n);