[Haskell-cafe] dynamic code compilation and loading

Tue Jan 17 07:16:21 UTC 2017

I'm not clear on everything you've saying.

My program, at present, opens some MIDI ports and leaves them open while it
is running. It presents me with a command line prompt from which I can
configure the program and initiate MIDI playback. I can also halt playback
in progress. Every time I change the score (in the Sibelius typesetter
program), I initiate a new playback action.

What you are saying sounds like running the program once for each playback.
I guess the program wouldn't leave the MIDI ports open, as it has to close
them before it exits. But that should work fine. I would also need a
different way of configuring the program -- the current settings would have
to be stored in a file so they won't be lost when the program exits.

I wonder about two things. First, I would like the majority of the program
to be compiled. It needs speed. Is there a way to compile everything but
the module that "varies" a Score?

Second, the Vary.hs module would need to be located on the disk in the same
directory as the music score, to keep things organized. But on my disk
(MacBook Pro with SS drive) there is one tree for Haskell source,
/Users/Dennis/haskell. I use the option "-i/Users/Dennis/haskell" which
compiling or running ghci. The musical scores are all stored in a different
tree, "/Users/Dennis/Dropbox/music/comp".

So I don't know how to "import" a file that is not in my Haskell source
tree, and more important, is not determined until run time.

Oh yeah, I don't specify the specific score when I run my program, but
rather let it search the /Users/Dennis/Dropbox/music/comp tree for the most
recently modified score. This is convenient, because over the course of an
hour or two that I compose, I would switch several times between scores,
and as soon as I modify and save a particular score, that one becomes the
source for playback.

So the program would locate a recently modified Sibelius score, say
$MUSIC/piano/tocatta1.sib. (Where $MUSIC is
/Users/Dennis/Dropbox/music/comp). Then the program would assume there is
some Haskell source in the same directory, called "toccata1.hs". This
source would contain functions that vary the expression in ways I like for
that particular composition.

Does this sound doable with ghci? Or the GHC API?

About what I've learned about expression score realization, I could perhaps
share some things at some point. Unfortunately I have bad work habits... I
often don't take care to finish projects in a way that is presentable, so I
have many years of half-finished compositions that can't even be played
back with the current version of my program. I'm 48 years old and finally
realizing just how important it is to organize and finish things. And to
collaborate. I found another musician to collaborate with -- I will make
computer "interpretations" of his compositions.

So my top priority over the next several months is to look over back
projects and finish things enough to get some sound, then archive the
*sound files* -- so they don't become obsolete. (Assuming wav or mp3 is
trustworthy for a while.)

D

On Mon, Jan 16, 2017 at 6:38 PM, Evan Laforge <qdunkan at gmail.com> wrote:

> I used to use hint for a somewhat similar situation (I wanted to give
> a REPL to my program, which incidentally is also concerned with
> interpreting music).  I found that hint didn't give enough control (it
> wanted to reload everything on every expression, instead of only
> reloading when I told it to) and it was too hard to dig through it's
> ghc compatibility layers, so I directly used the GHC API and it was a
> lot easier than expected.
>
> However, that's for inserting code into a running program.  If you
> want to just run a function to transform a Score, couldn't you just
> load the support modules in ghci, and run the main function from
> there?  Change the source, type :r, and type 'main' again.  You could
> hook up your editor to that automatically on every save.
>
> By the way, I'm also interested in expressive score realization, since
> I'm doing something similar, though in my case I'm using a custom
> score format rather than staff notation.  If you have anything to show
> off I'd be interested to see.
>
> On Sun, Jan 15, 2017 at 12:37 PM, Dennis Raddle <dennis.raddle at gmail.com>
> wrote:
> > Hello,
> > I wrote a Haskell program which reads a MusicXML score and plays it
> through
> > real-time MIDI messages (using the portmidi module) via some algorithms
> that
> > are customized depending on the MIDI synthesizer that is receiving the
> > messages. The program also plays back the music with musically expressive
> > nuances.
> >
> > In the next version of this program, I am going to add more complicated
> > algorithms for the expressive nuances, and it would be helpful to
> configure
> > them and express them in actual Haskell code. My workflow will look like
> > this:
> >
> > A. write a score using the music typesetting program Sibelius
> >
> > B. write some Haskell code to provide expressive nuances
> >
> > C. play the music through a MIDI synthesizer and listen.
> >
> > D. based on what I hear and where I want to take the music, modify the
> score
> > and the Haskell code
> >
> > E. loop back to C
> >
> > Therefore, if I don't want to recompile the program each time I do step
> D, I
> > need to compile and load code dynamically.
> >
> > Let's say that a data structure which contains a MusicXML score and a
> > nominal rendition into MIDI messages together with time tags is of type
> > Score. Then I want to write, and dynamically compile/load, a function
> >
> > vary :: Score -> Score
> >
> > which varies the MIDI messages and time tags to add expressive nuances.
> >
> > Let's say 'vary' is contained in Vary.hs.
> >
> > I want to write 'vary' in terms of already-compiled functions that
> provide
> > the basic music-processing operations. Let's say that these functions
> are in
> > the module MusicBase. Then Vary.hs will look like
> >
> > import MusicBase
> >
> > vary = ... operations in MusicBase ...
> >
> > Can I get some basic idea of how to do this?
> >
> > D
> >
> >
> > _______________________________________________
> > Haskell-Cafe mailing list
> > To (un)subscribe, modify options or view archives go to:
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> > Only members subscribed via the mailman list are allowed to post.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/haskell-cafe/attachments/20170117/d01079ad/attachment.html>