1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
|
<title>Haskore Tutorial: Interpretation and Performance</title>
<body bgcolor="#ffffff"><i>The Haskore Tutorial</i><br><a href="index.html">top</a> <a href="Basics.html">back</a> <a href="HaskToMidi.html">next</a><hr>
<a name="performance"></a><a name="sect4"></a>
<h2>4<tt> </tt>Interpretation and Performance</h2>
<p>
<tt> <br>
<br>
> module Performance (module Performance, module Basics) -- module Players<br>
> where<br>
><br>
> import Basics<br>
> -- import Players<br>
<br>
</tt> <p>
Now that we have defined the structure of musical objects, let us turn
to the issue of <I>performance</I>, which we define as a temporally
ordered sequence of musical <I>events</I>:
<tt> <br>
<br>
> type Performance = [Event]<br>
><br>
> data Event = Event Time IName AbsPitch DurT Volume<br>
> deriving (Eq,Ord,Show)<br>
><br>
> type Time = Float<br>
> type DurT = Float<br>
> type Volume = Float<br>
<br>
</tt>
An event is the lowest of our music representations not yet committed
to Midi, csound, or the MusicKit. An event <tt>Event s i p d v
</tt>captures the fact that at start time <tt>s</tt>, instrument <tt>i</tt> sounds
pitch <tt>p</tt> with volume <tt>v</tt> for a duration <tt>d</tt> (where now
duration is measured in seconds, rather than beats).<p>
To generate a complete performance of, i.e. give an interpretation
to, a musical object, we must know the time to begin the performance,
and the proper volume, key and tempo. We must also know what
<I>players</I> to use; that is, we need a mapping from the <tt>PName</tt>s in
an abstract musical object to the actual players to be used. (We
don't yet need a mapping from abstract <tt>INames</tt> to instruments,
since this is handled in the translation from a performance into, say,
Midi, such as defined in Section <a href="hasktomidi.html#midi">6</a>.)<p>
We can thus model a performer as a function <tt>perform</tt> which maps
all of this information and a musical object into a performance:
<tt> <br>
<br>
> perform :: PMap -> Context -> Music -> Performance<br>
><br>
> type PMap = PName -> Player<br>
> type Context = (Time,Player,IName,DurT,Key,Volume)<br>
> type Key = AbsPitch<br>
<br>
perform pmap c@(t,pl,i,dt,k,v) m =<br>
case m of<br>
Note p d nas -> playNote pl c p d nas<br>
Rest d -> []<br>
m1 :+: m2 -> perform pmap c m1 ++ <br>
perform pmap (setTime c (t+(dur m1)*dt)) m2<br>
m1 :=: m2 -> merge (perform pmap c m1) (perform pmap c m2)<br>
Tempo a b m -> perform pmap (setTempo c (dt * float b / float a)) m<br>
Trans p m -> perform pmap (setTrans c (k+p)) m<br>
Instr nm m -> perform pmap (setInstr c nm ) m<br>
Player nm m -> perform pmap (setPlayer c (pmap nm)) m<br>
Phrase pas m -> interpPhrase pl pmap c pas m<br>
<br>
</tt> <p>
<table border=2 cellpadding=3>
<tr><td><tt> <br>
setTime, setInstr, setTempo, setTrans, and setVolume<br>
have type: Context -> X -> Context, where X is obvious.<br>
<br>
> setTime (t,pl,i,dt,k,v) t' = (t',pl,i,dt,k,v) <br>
> setPlayer (t,pl,i,dt,k,v) pl' = (t,pl',i,dt,k,v)<br>
> setInstr (t,pl,i,dt,k,v) i' = (t,pl,i',dt,k,v)<br>
> setTempo (t,pl,i,dt,k,v) dt' = (t,pl,i,dt',k,v)<br>
> setTrans (t,pl,i,dt,k,v) k' = (t,pl,i,dt,k',v)<br>
> setVolume (t,pl,i,dt,k,v) v' = (t,pl,i,dt,k,v')<br>
<br>
getEventTime, getEventInst, getEventPitch, getEventDur, and getEventVol<br>
have type: Event -> X, where X is obvious <br>
<br>
> getEventTime (Event t _ _ _ _) = t<br>
> getEventInst (Event _ i _ _ _) = i<br>
> getEventPitch (Event _ _ p _ _) = p<br>
> getEventDur (Event _ _ _ d _) = d<br>
> getEventVol (Event _ _ _ _ v) = v<br>
<br>
setEventTime, setEventInst, setEventPitch, setEventDur, and setEventVol<br>
have type: Event -> X -> Event, where X is obvious.<br>
<br>
> setEventTime (Event t i p d v) t' = Event t' i p d v<br>
> setEventInst (Event t i p d v) i' = Event t i' p d v<br>
> setEventPitch (Event t i p d v) p' = Event t i p' d v<br>
> setEventDur (Event t i p d v) d' = Event t i p d' v<br>
> setEventVol (Event t i p d v) v' = Event t i p d v'<br>
<br>
</tt>
<div align=center><B>Figure 5: Selectors and mutators for contexts and events.</B></div>
</td></tr></table>
<p>
<table border=2 cellpadding=3>
<tr><td><tt> <br>
<br>
> perform pmap c m = fst (perf pmap c m)<br>
><br>
> perf :: PMap -> Context -> Music -> (Performance, DurT)<br>
> perf pmap c@(t,pl,i,dt,k,v) m =<br>
> case m of<br>
> Note p d nas -> (playNote pl c p d nas, d*dt)<br>
> Rest d -> ([], d*dt)<br>
> m1 :+: m2 -> let (pf1,d1) = perf pmap c m1<br>
> (pf2,d2) = perf pmap (setTime c (t+d1)) m2<br>
> in (pf1++pf2, d1+d2)<br>
> m1 :=: m2 -> let (pf1,d1) = perf pmap c m1<br>
> (pf2,d2) = perf pmap c m2<br>
> in (merge pf1 pf2, max d1 d2)<br>
> Tempo a b m -> perf pmap (setTempo c (dt * float b / float a)) m<br>
> Trans p m -> perf pmap (setTrans c (k+p)) m<br>
> Instr nm m -> perf pmap (setInstr c nm ) m<br>
> Player nm m -> perf pmap (setPlayer c (pmap nm)) m<br>
> Phrase pas m -> interpPhrase pl pmap c pas m<br>
<br>
</tt>
<div align=center><B>Figure 6: The "real" </B><tt>perform</tt><B> function.</B></div>
</td></tr></table>
<p>
Some things to note:
<OL><LI>
The <tt>Context</tt> is the running "state" of the performance, and
gets updated in several different ways. For example, the
interpretation of the <tt>Tempo</tt> constructor involves scaling
<tt>dt</tt> appropriately and updating the <tt>DurT</tt> field of the context.
Figure <a href="performance.html#context-event-functions">5</a> defines a convenient group of
selectors and mutators for contexts and events.<p>
<LI>
Interpretation of notes and phrases is player dependent. Ultimately a
single note is played by the <tt>playNote</tt> function, which takes the
player as an argument. Similarly, phrase interpretation is also
player dependent, reflected in the use of <tt>interpPhrase</tt>.
Precisely how these two functions work is described in Section
<a href="performance.html#players">5</a>.<p>
<LI>
The <tt>DurT</tt> component of the context is the duration, in seconds,
of one whole note. To make it easier to compute, we can define a
"metronome" function that, given a standard metronome marking (in
beats per minute) and the note type associated with one beat (quarter
note, eighth note, etc.) generates the duration of one whole note:
<tt> <br>
<br>
> metro :: Float -> Dur -> DurT<br>
> metro setting dur = 60 / (setting*dur)<br>
<br>
</tt>
Thus, for example, <tt>metro 96 qn</tt> creates a tempo of 96 quarter
notes per minute.<p>
<LI>
In the treatment of <tt>(:+:)</tt>, note that the sub-sequences are
appended together, with the start time of the second argument delayed
by the duration of the first. The function <tt>dur</tt> (defined in
Section <a href="basics.html#basic-examples">3.2</a>) is used to compute this duration. Note
that this results in a quadratic time complexity for <tt>perform</tt>. A
more efficient solution is to have <tt>perform</tt> compute the duration
directly, returning it as part of its result. This version of
<tt>perform</tt> is shown in Figure <a href="performance.html#real-perform">6</a>.<p>
<LI>
In contrast, the sub-sequences derived from the arguments to
<tt>(:=:)</tt> are merged into a time-ordered stream. The definition of
<tt>merge</tt> is given below.
</OL>
<tt> <br>
<br>
> merge :: Performance -> Performance -> Performance<br>
<br>
merge a@(e1:es1) b@(e2:es2) = <br>
if e1 < e2 then e1 : merge es1 b<br>
else e2 : merge a es2<br>
merge [] es2 = es2<br>
merge es1 [] = es1<br>
<br>
</tt>
Note that <tt>merge</tt> compares entire events rather than just start
times. This is to ensure that it is commutative, a desirable
condition for some of the proofs used in Section <a href="equiv.html#equivalence">8</a>.
Here is a more efficient version that will work just as well in
practice:
<tt> <br>
<br>
> merge a@(e1@(Event t1 _ _ _ _) : es1) b@(e2@(Event t2 _ _ _ _) : es2) = <br>
> if t1 < t2 then e1 : merge es1 b<br>
> else e2 : merge a es2<br>
> merge [] es2 = es2<br>
> merge es1 [] = es1<br>
<br>
</tt> <a name="players"></a>
<a name="sect5"></a>
<h2>5<tt> </tt>Players</h2>
<p>
<tt> <br>
<br>
module Players (module Players, module Music, module Performance)<br>
where<br>
<br>
import Music<br>
import Performance<br>
<br>
</tt> <p>
In the last section we saw how a performance involved the notion of a
<I>player</I>. The reason for this is the same as for real players and
their instruments: many of the note and phrase attributes (see Section
<a href="basics.html#phrasing">3.3</a>) are player and instrument dependent. For example, how
should "legato" be interpreted in a performance? Or "diminuendo?"
Different players interpret things in different ways, of course, but
even more fundamental is the fact that a pianist, for example,
realizes legato in a way fundamentally different from the way a
violinist does, because of differences in their instruments.
Similarly, diminuendo on a piano and a harpsichord are different
concepts. <p>
With a slight stretch of the imagination, we can even consider a
"notator" of a score as a kind of player: exactly how the music is
rendered on the written page may be a personal, stylized process. For
example, how many, and which staves should be used to notate a
particular instrument?<p>
In any case, to handle these issues, Haskore has a notion of a
<I>player</I> which "knows" about differences with respect to performance
and notation. A Haskore player is a 4-tuple consisting of a name and
3 functions: one for interpreting notes, one for phrases, and one for
producing a properly notated score.
<tt> <br>
<br>
> data Player = MkPlayer PName NoteFun PhraseFun NotateFun<br>
><br>
> type NoteFun = Context -> Pitch -> Dur -> [NoteAttribute] -> Performance<br>
> type PhraseFun = PMap -> Context -> [PhraseAttribute] -> Music -> (Performance,Dur)<br>
> type NotateFun = ()<br>
<br>
</tt>
The last line above is temporary for this executable version of
Haskore, since notation only works on systems supporting CMN. The
real definition should read:
<tt> <br>
type NotateFun = [Glyph] -> Staff<br>
</tt> <p>
Note that both <tt>NoteFun</tt> and <tt>PhraseFun</tt> return a
<tt>Performance</tt> (imported from module <tt>Perform</tt>), whereas
<tt>NotateFun</tt> returns a <tt>Staff</tt> (imported from module
<tt>Notation</tt>).<p>
For convenience we define:
<tt> <br>
<br>
> pName :: Player -> PName<br>
> pName (MkPlayer nm _ _ _) = nm<br>
><br>
> playNote :: Player -> NoteFun<br>
> playNote (MkPlayer _ nf _ _) = nf<br>
><br>
> interpPhrase :: Player -> PhraseFun<br>
> interpPhrase (MkPlayer _ _ pf _) = pf<br>
><br>
> notatePlayer :: Player -> NotateFun<br>
> notatePlayer (MkPlayer _ _ _ nf) = nf<br>
<br>
</tt> <p>
<table border=2 cellpadding=3>
<tr><td><tt> <br>
<br>
> defPlayer :: Player<br>
> defPlayer = MkPlayer "Default" (defPlayNote defNasHandler)<br>
> (defInterpPhrase defPasHandler)<br>
> (defNotatePlayer () )<br>
><br>
> defPlayNote :: (Context->NoteAttribute->Event->Event) -> NoteFun<br>
> defPlayNote nasHandler c@(t,pl,i,dt,k,v) p d nas =<br>
> [ foldr (nasHandler c)<br>
> (Event t i (absPitch p + k) (d*dt) v)<br>
> nas ]<br>
><br>
> defNasHandler :: Context-> NoteAttribute -> Event -> Event<br>
> defNasHandler (_,_,_,_,_,v) (Volume v') ev = setEventVol ev (v*v'/100.0)<br>
> defNasHandler _ _ ev = ev<br>
><br>
> defInterpPhrase :: (PhraseAttribute->Performance->Performance) -> PhraseFun<br>
> defInterpPhrase pasHandler pmap c@(t,pl,i,dt,k,v) pas m =<br>
> let (pf,dur) = perf pmap c m<br>
> in (foldr pasHandler pf pas, dur)<br>
> <br>
> defPasHandler :: PhraseAttribute -> Performance -> Performance<br>
> defPasHandler (Dyn (Accent x)) pf = <br>
> map (\e -> setEventVol e (x * getEventVol e)) pf<br>
> defPasHandler (Art (Staccato x)) pf = <br>
> map (\e -> setEventDur e (x * getEventDur e)) pf<br>
> defPasHandler (Art (Legato x)) pf =<br>
> map (\e -> setEventDur e (x * getEventDur e)) pf<br>
> defPasHandler _ pf = pf<br>
><br>
> defNotatePlayer :: () -> NotateFun<br>
> defNotatePlayer _ = ()<br>
<br>
</tt>
<div align=center><B>Figure 7: Definition of default Player </B><tt>defPlayer</tt><B>.</B></div>
</td></tr></table>
<p>
<a name="sect5.1"></a>
<h3>5.1<tt> </tt>Examples of Player Construction</h3><p>
A "default player" called <tt>defPlayer</tt> (not to be confused with
"deaf player"!) is defined for use when none other is specified in
the score; it also functions as a base from which other players can be
derived. <tt>defPlayer</tt> responds only to the <tt>Volume</tt> note
attribute and to the <tt>Accent</tt>, <tt>Staccato</tt>, and <tt>Legato
</tt>phrase attributes. It is defined in Figure <a href="performance.html#default-Player">7</a>.
Before reading this code, recall how players are invoked by the
<tt>perform</tt> function defined in the last section; in particular, note the
calls to <tt>playNote</tt> and <tt>interpPhase</tt> defined above. Then
note:
<OL><LI><tt>defPlayNote</tt> is the only function (even in the definition
of <tt>perform</tt>) that actually generates an event. It also modifies
that event based on an interpretation of each note attribute by the
function <tt>defHasHandler</tt>.<p>
<LI><tt>defNasHandler</tt> only recognizes the <tt>Volume</tt> attribute,
which it uses to set the event volume accordingly.<p>
<LI><tt>defInterpPhrase</tt> calls (mutually recursively)
<tt>perform</tt> to interpret a phrase, and then modifies the result based on
an interpretation of each phrase attribute by the function
<tt>defPasHandler</tt>.<p>
<LI><tt>defPasHandler</tt> only recognizes the <tt>Accent</tt>,
<tt>Staccato</tt>, and <tt>Legato</tt> phrase attributes. For each of these it
uses the numeric argument as a "scaling" factor of the volume (for
<tt>Accent</tt>) and duration (for <tt>Staccato</tt> and <tt>Lagato</tt>).
Thus <tt>(Phrase [Legato 1.1] m)</tt> effectively increases the duration
of each note in <tt>m</tt> by 10%(without changing the tempo).
</OL> <p>
It should be clear that much of the code in Figure
<a href="performance.html#default-Player">7</a> can be re-used in defining a new player.
For example, to define a player <tt>weird</tt> that interprets note
attributes just like <tt>defPlayer</tt> but behaves differently with
respect to phrase attributes, we could write:
<tt> <br>
weird :: Player<br>
weird = MkPlayer "Weirdo" (defPlayNote defNasHandler)<br>
(defInterpPhrase myPasHandler )<br>
(defNotatePlayer () )<br>
</tt>
and then supply a suitable definition of <tt>myPasHandler</tt>. That
definition could also re-use code, in the following sense: suppose we
wish to add an interpretation for <tt>Crescendo</tt>, but otherwise
have <tt>myPasHandler</tt> behave just like <tt>defPasHandler</tt>.
<tt> <br>
myPasHandler :: PhraseAttribute -> Performance -> Performance<br>
myPasHandler (Dyn (Crescendo x)) pf = ...<br>
myPasHandler pa pf = defPasHandler pa pf<br>
</tt> <p>
<p>
<B>Exercise<br>
</B>Fill in the <tt>...</tt> in the definition of <tt>myPasHandler</tt> according
to the following strategy: Assume 0<<tt>x</tt><1. Gradually scale
the volume of each event by a factor of 1.0 through 1.0+<tt>x</tt>,
using linear interpolation.
<p>
<p>
<p>
<B>Exercise<br>
</B>Choose some of the other phrase attributes and provide interpretations
of them, such as <tt>Diminuendo</tt>, <tt>Slurred</tt>, <tt>Trill</tt>, etc.
<p>
<p>
In a system that supports it, the default notation handler sets up a
staff with a treble clef for the player and appends any glyphs to
the end of the staff:
<tt> <br>
defNotatePlayer gs = Staff "Default" 1.0 5 (Clef Treble : gs)<br>
</tt> <p>
Figure <a href="performance.html#fancy-Player">8</a> defines a relatively sophisticated player
called <tt>fancyPlayer</tt> that knows all that <tt>defPlayer</tt> knows, and
much more. Note that <tt>Slurred</tt> is different from <tt>Legato</tt> in
that it doesn't extend the duration of the <I>last</I> note(s). The
behavior of <tt>(Ritardando </tt> x<tt>)</tt> can be explained as
follows. We'd like to "stretch" the time of each event by a factor
from 0 to x, linearly interpolated based on how far along the
musical phrase the event occurs. I.e., given a start time t<sub>0</sub> for
the first event in the phrase, total phrase duration D, and event
time t, the new event time t' is given by:
<p>
t' = (1 + D/(t-t<sub>0</sub>) x)(t-t<sub>0</sub>) + t<sub>0</sub> <p>
Further, if d is the duration of the event, then the end of
the event t+d gets stretched to a new time t<sub>d</sub>' given by:
<p>
t<sub>d</sub>' = (1 + D/(t+d-t<sub>0</sub>) x)(t+d-t<sub>0</sub>) + t<sub>0</sub> <p>
The difference t<sub>d</sub>' - t' gives us the new, stretched duration d',
which after simplification is:
<p>
d' = (1 + D/(2(t-t<sub>0</sub>)+d) x)d <p>
<tt>Accelerando</tt> behaves in exactly the same way, except that it
shortens event times rather than lengthening them. And, a similar but
simpler strategy explains the behaviors of <tt>Crescendo</tt> and
<tt>Diminuendo</tt>.<p>
<table border=2 cellpadding=3>
<tr><td>
<tt> <br>
<br>
> fancyPlayer :: Player<br>
> fancyPlayer = MkPlayer "Fancy" (defPlayNote defNasHandler )<br>
> fancyInterpPhrase<br>
> (defNotatePlayer () )<br>
><br>
> fancyInterpPhrase :: PhraseFun<br>
> fancyInterpPhrase pmap c [] m = perf pmap c m<br>
> fancyInterpPhrase pmap c@(t,pl,i,dt,k,v) (pa:pas) m =<br>
> let pfd@(pf,dur) = fancyInterpPhrase pmap c pas m<br>
> loud x = fancyInterpPhrase pmap c (Dyn (Loudness x) : pas) m<br>
> stretch x = let t0 = getEventTime (head pf)<br>
> r = x/dur<br>
> upd (Event t i p d v) = let dt = t-t0<br>
> t' = (1+dt*r)*dt + t0<br>
> d' = (1+(2*dt+d)*r)*d<br>
> in Event t' i p d' v<br>
> in (map upd pf, (1+x)*dur)<br>
> inflate x = let t0 = getEventTime (head pf)<br>
> r = x/dur<br>
> upd (Event t i p d v) = let dt = t-t0<br>
> in Event t i p d ((1+dt*r)*v)<br>
> in (map upd pf, dur)<br>
> in case pa of<br>
> Dyn (Accent x) -> (map (\e-> setEventVol e (x * getEventVol e)) pf, dur)<br>
> Dyn PPP -> loud 40 ; Dyn PP -> loud 50 ; Dyn P -> loud 60<br>
> Dyn MP -> loud 70 ; Dyn SF -> loud 80 ; Dyn MF -> loud 90<br>
> Dyn NF -> loud 100 ; Dyn FF -> loud 110 ; Dyn FFF -> loud 120<br>
> Dyn (Loudness x) -> fancyInterpPhrase pmap (t,pl,i,dt,k,v*x/100) pas m<br>
> Dyn (Crescendo x) -> inflate x<br>
> Dyn (Diminuendo x) -> inflate (-x)<br>
> Dyn (Ritardando x) -> stretch x<br>
> Dyn (Accelerando x) -> stretch (-x)<br>
> Art (Staccato x) -> (map (\e-> setEventDur e (x * getEventDur e)) pf, dur)<br>
> Art (Legato x) -> (map (\e-> setEventDur e (x * getEventDur e)) pf, dur)<br>
> Art (Slurred x) -> <br>
> let lastStartTime = foldr (\e t -> max (getEventTime e) t) 0 pf<br>
> setDur e = if getEventTime e < lastStartTime<br>
> then setEventDur e (x * getEventDur e)<br>
> else e<br>
> in (map setDur pf, dur)<br>
> Art _ -> pfd -- Remaining articulations:<br>
> -- Tenuto | Marcato | Pedal | Fermata | FermataDown<br>
> -- | Breath | DownBow | UpBow | Harmonic | Pizzicato<br>
> -- | LeftPizz | BartokPizz | Swell | Wedge | Thumb | Stopped<br>
> Orn _ -> pfd -- Remaining ornamenations:<br>
> -- Trill | Mordent | InvMordent | DoubleMordent | Turn<br>
> -- | TrilledTurn | ShortTrill | Arpeggio | ArpeggioUp <br>
> -- | ArpeggioDown | Instruction String | Head NoteHead<br>
> -- Design Bug: To do these right we need to keep the KEY SIGNATURE<br>
> -- around so that we can determine, for example, what the trill note is.<br>
> -- Alternatively, provide an argument to Trill to carry this info.<br>
<br>
</tt>
<div align=center><B>Figure 8: Definition of Player </B><tt>fancyPlayer</tt><B>.</B></div>
</td></tr></table>
<hr><body bgcolor="#ffffff"><i>The Haskore Tutorial</i><br><a href="index.html">top</a> <a href="Basics.html">back</a> <a href="HaskToMidi.html">next</a>
|
