\subsection{Haskore in Action} \seclabel{examples} \begin{haskelllisting}

    > module Haskore.Example.Miscellaneous where
    >
    > import           Haskore.Composition.Trill as Trill
    > import           Haskore.Composition.Drum  as Drum
    >
    > import qualified Haskore.Music           as Music
    > import           Haskore.Music (rest, delay, (/=:))
    > import           Haskore.Music.GeneralMIDI as MidiMusic
    > import qualified Haskore.Music.Rhythmic  as RhyMusic
    > import qualified Haskore.Melody          as Melody
    > import           Haskore.Melody.Standard as StdMelody
    > import qualified Haskore.Performance.Context as Context

    > import qualified Haskore.Interface.MIDI.InstrumentMap as InstrMap
    > import qualified Haskore.Interface.MIDI.Write        as WriteMidi
    > import qualified Haskore.Interface.MIDI.Read         as ReadMidi
    > import qualified Haskore.Interface.MIDI.Render       as Render

    > import qualified Sound.MIDI.File.Save    as SaveMidi
    > import qualified Sound.MIDI.File.Load    as LoadMidi
    > import qualified Sound.MIDI.File         as MidiFile
    > import qualified Sound.MIDI.General      as GeneralMidi

    > import qualified Haskore.Example.SelfSim        as SelfSim
    > import qualified Haskore.Example.ChildSong6     as ChildSong6
    > import qualified Haskore.Example.Ssf            as Ssf

    > import           Haskore.Basic.Duration ((%+))
    > import qualified Numeric.NonNegative.Wrapper as NonNeg

    > import Data.Tuple.HT (fst3, snd3, thd3, )

    > t0, t1, t2, t3, t4, t5,
    >  t10s, t12, t12a, t13, t13a, t13b, t13c, t13d, t13e,
    >  t14, t14b, t14c, t14d, cs6, ssf0 :: MidiFile.T

    > piano, vibes, flute :: GeneralMidi.Instrument
    > piano = GeneralMidi.AcousticGrandPiano
    > vibes = GeneralMidi.Vibraphone
    > flute = GeneralMidi.Flute

\end{haskelllisting} Simple examples of Haskore in action. Note that this module also imports modules ChildSong6, SelfSim, and Ssf. \vspace{2ex} \hrule{\hfill} From the tutorial, try things such as pr12, cMajArp, cMajChd, etc. and try applying inversions, retrogrades, etc. on the same examples. Also try \code{ChildSong.song}. For example: \begin{haskelllisting}

    > t0 = Render.generalMidiDeflt ChildSong6.song

\end{haskelllisting} \hrule{\hfill} C Major scale for use in examples below: \begin{haskelllisting}

    > cms', cms :: Melody.T ()
    > cms' = line (map (\n -> n en ())
    >           [c 0, d 0, e 0, f 0, g 0, a 0, b 0, c 1])
    > cms = changeTempo 2 cms'

    > drumScale :: MidiMusic.T
    > drumScale =
    >    line (map (\n -> Drum.toMusicDefaultAttr (toEnum (n+13)) sn)
    >              [0,2,4,5,7,9,11,12])

\end{haskelllisting} Test of various articulations and dynamics: \begin{haskelllisting}

    > t1 = Render.generalMidi
    >        (staccato (sn/10) drumScale +:+
    >                          drumScale +:+
    >         legato   (sn/10) drumScale    )
    >
    > temp, mu2 :: MidiMusic.T
    > temp = MidiMusic.fromMelodyNullAttr piano (crescendo 4.0 (c 0 en ()))
    >
    > mu2 = MidiMusic.fromMelodyNullAttr vibes
    >        (diminuendo 0.75 cms +:+
    >         crescendo 0.75 (loudness1 0.25 cms))
    > t2 = Render.generalMidiDeflt mu2
    >
    > t3 = Render.generalMidiDeflt (MidiMusic.fromMelodyNullAttr flute
    >        (accelerando 0.3 cms +:+
    >         ritardando  0.6 cms    ))

\end{haskelllisting} \hrule{\hfill} A function to recursively apply transformations \code{f'} (to elements in a sequence) and \code{g'} (to accumulated phrases): \begin{haskelllisting}

    > rep :: (Music.T note -> Music.T note)
    >     -> (Music.T note -> Music.T note)
    >     -> Int -> Music.T note -> Music.T note
    > rep _  _  0 _ = rest 0
    > rep f' g' n m = m =:= g' (rep f' g' (n-1) (f' m))

\end{haskelllisting} An example using "rep" three times, recursively, to create a "cascade" of sounds. \begin{haskelllisting}

    > run, cascade, cascades :: Melody.T ()
    > run       = rep (transpose 5) (delay tn) 8 (c 0 tn ())
    > cascade   = rep (transpose 4) (delay en) 8 run
    > cascades  = rep  id           (delay sn) 2 cascade
    >
    > t4' :: Melody.T () -> MidiFile.T
    > t4' x     = Render.generalMidiDeflt (MidiMusic.fromMelodyNullAttr piano x)
    > t4        = Render.generalMidiDeflt (MidiMusic.fromMelodyNullAttr piano
    >               (cascades +:+ Music.reverse cascades))

\end{haskelllisting} What happens if we simply reverse the \code{f} and \code{g} arguments? \begin{haskelllisting}

    > run', cascade', cascades' :: Melody.T ()
    > run'      = rep (delay tn) (transpose 5) 4 (c 0 tn ())
    > cascade'  = rep (delay en) (transpose 4) 6 run'
    > cascades' = rep (delay sn)  id           2 cascade'
    > t5        = Render.generalMidiDeflt (MidiMusic.fromMelodyNullAttr piano cascades')

\end{haskelllisting} \hrule{\hfill} Example from the SelfSim module. \begin{haskelllisting}

    > t10s   = Render.generalMidiDeflt (rep (delay SelfSim.durss) (transpose 4) 2 SelfSim.ss)

\end{haskelllisting} \hrule{\hfill} Example from the ChildSong6 module. \begin{haskelllisting}

    > cs6 = Render.generalMidiDeflt ChildSong6.song

\end{haskelllisting} \hrule{\hfill} Example from the Ssf (Stars and Stripes Forever) module. \begin{haskelllisting}

    > ssf0 = Render.generalMidiDeflt Ssf.song

\end{haskelllisting} \hrule{\hfill} Midi percussion test. Plays all "notes" in a range. (Requires adding an instrument for percussion to the \code{InstrMap}.) \begin{haskelllisting}

    > drums :: GeneralMidi.Drum -> GeneralMidi.Drum -> MidiMusic.T
    > drums dr0 dr1 =
    >    line (map (\drm -> Drum.toMusicDefaultAttr drm sn) [dr0..dr1])
    >
    > t11 :: GeneralMidi.Drum -> GeneralMidi.Drum -> MidiFile.T
    > t11 dr0 dr1 = Render.generalMidiDeflt (drums dr0 dr1)

\end{haskelllisting} \hrule{\hfill} Test of \function{Music.take} and shorten. \begin{haskelllisting}

    > t12 = Render.generalMidiDeflt (Music.take 4 ChildSong6.song)
    > t12a =
    >    Render.generalMidiDeflt
    >       (MidiMusic.fromMelodyNullAttr piano cms /=: ChildSong6.song)

\end{haskelllisting} \hrule{\hfill} Tests of the trill functions. \begin{haskelllisting}

    > t13note :: MidiMusic.T
    > t13note = MidiMusic.fromMelodyNullAttr piano (c 1 qn ())
    > t13 =  Render.generalMidiDeflt (trill   1 sn t13note)
    > t13a = Render.generalMidiDeflt (trill'  2 dqn t13note)
    > t13b = Render.generalMidiDeflt (trillN  1 5 t13note)
    > t13c = Render.generalMidiDeflt (trillN' 3 7 t13note)
    > t13d = Render.generalMidiDeflt (roll tn t13note)
    > t13e = Render.generalMidiDeflt (changeTempo (2/3) (transpose 2 (trillN' 2 7 t13note)))

\end{haskelllisting} \hrule{\hfill} Tests of drum. \begin{haskelllisting}

    > t14 = Render.generalMidiDeflt (Drum.toMusicDefaultAttr AcousticSnare qn)

\end{haskelllisting} A "funk groove" \begin{haskelllisting}

    > t14b = let p1 = Drum.toMusicDefaultAttr LowTom        qn
    >            p2 = Drum.toMusicDefaultAttr AcousticSnare en
    >        in Render.generalMidiDeflt (changeTempo 3 (Music.replicate 4
    >                  (line [p1, qnr, p2,  qnr, p2,
    >                         p1, p1,  qnr, p2,  enr]
    >                   =:= roll en (Drum.toMusicDefaultAttr ClosedHiHat 2))))

\end{haskelllisting} A "jazz groove" \begin{haskelllisting}

    > t14c = let p1 = Drum.toMusicDefaultAttr CrashCymbal2  qn
    >            p2 = Drum.toMusicDefaultAttr AcousticSnare en
    >            p3 = Drum.toMusicDefaultAttr LowTom        qn
    >        in Render.generalMidiDeflt (changeTempo 3 (Music.replicate 8
    >                  ((p1 +:+ changeTempo (3%+2) (p2 +:+ enr +:+ p2))
    >                   =:= (p3 +:+ qnr)) ))

    > t14d = let p1 = Drum.toMusicDefaultAttr LowTom        en
    >            p2 = Drum.toMusicDefaultAttr AcousticSnare hn
    >        in Render.generalMidiDeflt(line [roll tn p1,
    >                          p1,
    >                          p1,
    >                          rest en,
    >                          roll tn p1,
    >                          p1,
    >                          p1,
    >                          rest qn,
    >                          roll tn p2,
    >                          p1,
    >                          p1]  )

\end{haskelllisting} \hrule{\hfill} \paragraph{Tests of the MIDI interface.} \code{MidiMusic.T} into a MIDI file. \begin{haskelllisting}

    > tab :: MidiMusic.T -> IO ()
    > tab m = SaveMidi.toFile "test.mid" (Render.generalMidiDeflt m)

\end{haskelllisting} \code{MidiMusic.T} to a MidiFile datatype and back to Music. \begin{haskelllisting}

    > type StdContext =
    >    Context.T NonNeg.Float Float (RhyMusic.Note MidiMusic.Drum MidiMusic.Instr)
    > -- type StdContext = Pf.Context NonNeg.Float Float MidiMusic.Note -- rejected by Hugs

    > type MidiArrange =
    >    (InstrMap.ChannelTable MidiMusic.Instr, StdContext, MidiMusic.T)

    > tad :: MidiMusic.T -> MidiArrange
    > tad = ReadMidi.toGMMusic . Render.generalMidiDeflt

\end{haskelllisting} A MIDI file to a MidiFile datatype and back to a MIDI file. \begin{haskelllisting}

    > tcb, tc, tcd, tcdab :: FilePath -> IO ()
    > tcb file = LoadMidi.fromFile file >>= SaveMidi.toFile "test.mid"

\end{haskelllisting} MIDI file to MidiFile datatype. \begin{haskelllisting}

    > tc file = LoadMidi.fromFile file >>= print

\end{haskelllisting} MIDI file to \code{MidiMusic.T}, a \code{InstrMap}, and a \code{Context}. \begin{haskelllisting}

    > tcd file = do
    >              x <- fmap ReadMidi.toGMMusic
    >                        (LoadMidi.fromFile file)
    >              print $ fst3 (x::MidiArrange)
    >              print $ snd3 x
    >              print $ thd3 x

\end{haskelllisting} A MIDI file to \code{MidiMusic.T} and back to a MIDI file. \begin{haskelllisting}

    > tcdab file =
    >    LoadMidi.fromFile file >>=
    >       (SaveMidi.toFile "test.mid" . WriteMidi.fromGMMusic .
    >          (id::MidiArrange -> MidiArrange) . ReadMidi.toGMMusic)

\end{haskelllisting}