I realize my current implementation of my music application is not pretty
and I want to learn to use Haskell more effectively.
My application reads a musical score exported by the typesetter Sibelius. A
score is a high-level representation of music that includes structures,
like grouping notes for each instrument, and directions that affect how the
musuc will be played, like tempo indications, indications to gradually
speed up, gradually get louder, etc. My program translates it into
low-level time stamped MIDI events, which say things like "turn on this
note", "turn off this note", "change the volume setting on this
instrument," etc.
The outline of my program is this:
1. Read the output of Sibeliusl
2. Construct a Score. A Score has several Parts (individual instruments). A
part consists of a list of time stamped Chords, which represent a list of
Notes that are sounded at the same time (roughly). There are expression
marks in the music that apply to Chords as a whole and some apply only to
Notes. Notes are the most basic sound-generating unit -- they have a pitch,
a duration, some indicators of musical expression like performance
techniques, a time offset (a Note may start slightly ahead or behind the
time stamp on the Chord), and more.
3. Modify the Score to account for forms of musical expression and for a
few strange things in the way Sibelius exports its data. Right now I
process the score through a LOT of passes, maybe two dozen. Also I have
given a ton of extra fields to Notes and Chords that essentially are cache
or memos of the results of processing that looks for patterns. So now
things are quite unwieldy.. I have two dozen extra fields between Chords
and Notes, and I need to make two dozen modification passes on the Score.
It's bug prone and hard to understand because the order of the passes is
important and I could easily put the Score into an invalid state.
So the data looks like this:
The basic time stamp type is Loc, indicating a measure number and a beat
within that measure.
type MeasureNum = Int
type MeasureBeat = Rational
data Loc = Loc MeasureNum MeasureBeat
type PartName = String
data Score = Score ScoreRelatedData (Map PartName Part)
data ScoreRelatedData = -- this is data that applies to the score as a
whole, like a measure-by-measure list of tempos, time signatures, and a
time map that allows the translation of Loc to a number of seconds.
-- The Chords in a Part occur in time at a Loc. There can be more
-- than one Chord at a Loc
data Part = PartRelatedData (Map Loc [Chord])
data PartRelatedData -- data about musical expression that applies to a
Part as a whole
data VoiceNumber Int -- even within a single Part there can be different
"voices" which means independent sequential Chords, independent in the
sense they may have different volume levels, different durations, etc.
data Chord = ChordRelatedData VoiceNumber [Note]
data ChordRelatedData -- this includes data about the Chord as a whole,
such as playback techniqes that applies to the whole Chord. It also
contains a list of Notes.
data Note = Note NoteRelatedData Pitch
data NoteRelatedData -- this includes expression markings that apply to a
Note only
So there are some patterns within the Score that need to be identified
before it can be translated to MIDI events. Here are some examples:
1. Tied notes. Some Notes within a Chord X are tied to a Note in the
following Chord Y. That means they represent a single sound unit that
should be sustained from the beginning of Chord X to the end of Chord Y.
But actually the note in Chord Y can be tied to Chord Z and so on for any
number of sequential Chords. When I want to find the true ending Loc of a
Note I need to follow the tie chain. Some Notes in the same Chord may be
tied, and others may not.
2. Double tremolos. Sometimes two sequential chords are actually supposed
to played together--actually the player will rapidly alternate between the
chords. When I first read the score there will be a marking on the first
chord X of the double tremolo. I have to look for a Chord Y that
immediately follows X, has the same VoiceNumber and the same duration, and
I can infer that's the second chord in the double tremolo. Note that the
timing and notes of a double tremolo, when translated to MIDI, look hardly
anything like the original data -- the original data just has two Chords,
but the playback will contains lots of sequential notes that are drawn from
both chords.
3. Arpeggios. Sometime the notes in a chord are "rolled" -- played with the
lowest note first, followed by a time-staggered playback of the other
notes, going up in pitch. There might be an arpeggio marking that spans
several Parts, meaning I have to look at all the parts to compute the time
offsets for the notes in an arpeggio
4. problems in the data export. Sibelius has some bugs, so I need to find
problems in its output and fix them by removing or altering certain Chords.
And that's just the beginning. There are something like two dozen patterns
that need to be identified.
What I'm doing now is adding all sorts of fields to Parts, Chords, and
Notes to hold memos of the results of this processing. These memo fields
have to be initialized to something, like zero, or an empty Map, or
whatever. Then I set them via the processing passes.
This is bug-prone and unwieldy.
What I am realizing is that I don't necessarily need to store every field.
For isntance, consider tie chains. I don't really need to process them all
ahead of time. I can follow a tie chain only in the places where I need to
know the full duration of a Note. I might end up with some redundant
processing, but the advantage is
(1) I don't need an extra field
(2) I don't have to worry about that extra field becoming invalid or
remaining uninitialized.
But there are some processing data that probably should be done once and
memoized. For instance, I need a Map of the END LOCATION of each Chord to
the Chord itself to look up certain things. That is expensive to construct.
So what data do I pass to my MIDI-conversion algorithm? I could create
something called ContextNote like this
data ContextNote = ContextNote Score Part Chord Note
Then I could write a function that converts a score to a list of context
notes, and pass all of them to the conversion routine.
allContextNotes :: Score -> [ContextNote]
This list would have one entry for every note in the Score.
Also I would probably use named fields. So I would have something like
data Note = Note
{ nPitch :: Int
, nVolume :: Int
, ...
}
When I'm accessing the data on ContextNote, I don't want to have to type
several accessor functions to get down to the Note fields. So I could do
something like
class HasNoteData a where
pitch :: a -> Int
Then
instance HasNoteData ContextNote where
pitch (ContextNote _ _ note) = nPitch note
I could create a bunch of accessor functions like that for every field in
the ContextNote.
For data that should probably be computed once, I could create Memo data.
Maybe I would have
data ContextNote = ContextNote Memo Score Part Chord Note
or something like that.
So if you have read this far, thank you very much. Any suggestions welcome.
D
