So for those of you that watch the hackage what's-new page, you will
probably be aware of this. For the last few months, there's been
significant work on my implementation of Session Types in Haskell.
The reason for this particular announcement is that it should now be at
a point where functionality is verging on useful. There are a few things
that are still missing which should appear over the next few weeks but
if you're at all interested in message-passing as a tool in the box for
dealing with concurrency, I'd love to know what you think.
To that end, I would *not* encourage you to try to look at the
implementation too closely as you may suddenly discover a powerful urge
to stick knives in your eyes and/or eat your computer. However, the
Tests.hs file should give you a good idea of the kinds of things that
are possible and they do cover all the functionality currently
implemented. Note that ghci may well take about 5 mins to type check
Tests.hs. Or longer if you're still running a BBC B Micro.
I would almost certainly not advise anyone to look at the haddock. I
really can't quite believe how horrible the type sigs end up looking
under haddock. Some of my comments may almost pass the barrier of being
useful. Nicely formatted type sigs exist in the source.
If however, you are as mad as I, and enjoy pushing the GHC type system
to the limit, then you may enjoy looking at the implementation in all
its glory. base10 numbers, lists, associative maps and a whole lot of
other madness works correctly at the type-level in ghc 6.8.2.
Anyway, as the subject says, comments gratefully received.
On Thu, Feb 28, 2008 at 11:23 PM, Matthew Sackman <[hidden email]> wrote:
> If however, you are as mad as I, and enjoy pushing the GHC type system
> to the limit, then you may enjoy looking at the implementation in all
> its glory. base10 numbers, lists, associative maps and a whole lot of
> other madness works correctly at the type-level in ghc 6.8.2.
Only if I had known before before ....
I recently released a library, "type-level" , which implements
type-level base10 numbers and Booleans. I could have reused your
implementation but didn't know about it ...
The plan is to include a common type-level implementation to avoid
reinventing the wheel all the time. I'm still know if people will find
it useful but if they do I could include your implementation of lists
and maps. What do you think?