Haskell library infrastructure coordinator

[Peter Simons]

I wanted to write up a proposal regarding the organization of a
»central« library infrastructure for weeks ... So I guess now is the
time to do or die.

Shae Matijs Erisson owns the »haskell-libs« project at
sourceforge.net, and we figured this would be a good platform for the
effort. The idea is to set-up a CVS repository, which contains the
following directories:

 - hslibs

   Here do the actual source codes live, using a directory layout
   complying to the hierarchical library structure, for example:

       - Text
       - Data
       - Foobar

   The contents is by-approval-only: Any library accepted into this
   part of the repository has to undergo a review process, in order to
   ensure high quality and somewhat stable interfaces. A set of
   guidelines for this process would have to be created, but we could
   probably adapt the _excellent_ www.boost.org process with little
   effort.

   These libraries serve as a quasi-extension of the libraries shipped
   with ghc/hugs/nhc98. Ideally, everybody would be able to use them
   by just checking out this directory and adding it to the compiler's
   search path.

 - Unstable

   This directory will contain a bunch of per-user-directories, for
   example:

      - SimonsPeter
      - ErissonShaeMatijs
      - AgentSmith

   This directory serves as a private (but unique) namespace for
   _everybody_ to publish work-in-progress, or libraries that are too
   specific to be accepted into the general »hslibs« area. Everybody,
   who checks out »Unstable« and adds it to the compiler's search
   path, can access them like this:

       import Unstable.SimonsPeter.MyPrivateLib
       import Unstable.Whoever.Whatever

   Libraries from »hslibs« must not relay on libraries provided in the
   »Unstable« space, but user-space libraries may relay on »hslibs«.

   It's also a good idea to publish candidate libraries for inclusion
   in the »official« space here. But basically this space can contain
   _anything_ you feel others might be interested in.

 - tools

   This directory will contain several small tools useful for user's
   of the distribution. So far I am working on two things to go here:

      - cvssynch

        This is a small Haskell program to synchronize two CVS
        repositories. The idea is that you maintain your private
        sources in a CVS repository on your private machine. When
        you're ready to release it, all you do is call »cvssynch« and
        it will import the code into the »vendor branch« of the CVS
        repository at sourceforge.net. Unlike »cvs import«, though,
        »cvssynch« will handle added and erased files/directories
        automatically.

        Since the files are imported into the vendor branch, you can
        still make sourceforge.net-specific changes to the files using
        CVS's merging feature. If done right, this allows to maintain
        a private copy of the sources simultaneously to the public
        version with very little overhead. (A make target could take
        care of all this.)

      - hbuild

        hbuild is a monadic combinatory library, which implements a
        »make« utility in Haskell. Unlike normal makes, though, hbuild
        is an ordinary haskell program! You can build your sources by
        executing »runhugs HBuild all« or »runhugs HBuild install«.

        This is still highly experimental, but -- not surprisingly --
        the package blows any make-variant I've seen out of the water
        in terms of flexibility and power. I'm still struggling with
        the design when it comes to building variants (say, you want
        to build a library for GHC and NHC98 simultaneously), but I
        hope to get a beta version ready within a few weeks at most.

What this approach would achieve:

 * Users could access the libraries contained in here with no effort
   at all.

 * Users can chose whether they want only the tested and stable
   libraries, or whether they're up for some experimental stuff.

 * The experimental code is guaranteed to have a unique module name
   thanks to the »Unstable.UserID« path.

 * SourceForge.net provides us with all kinds of nifty features, like
   web space, bug tracking, feature request tracking, etc.

 * The »hslibs« space could evolve into a portable base library for
   Haskell, which can be re-used by _all_ compiler vendors, rather
   than each of them providing their own versions of standard modules.

I would like to help getting this set-up, if there is any interest. In
particular, I could help working on the guidelines, etc., since I have
some experience with the Boost project, which does almost exactly the
same thing for the C++ community.

Any thoughts?

Peter