Update on GHC 6.12.1

[Simon Peyton-Jones]

Folks

This is an update on the status of GHC 6.12.  

FIRST, as you probably know, Hackage and the Haskell Platform is
allowing GHC HQ to get out of the libraries business.  So the plan is

 - We release GHC 6.12 with very few libraries
 - Bill Library Author downloads GHC 6.12 and tests his libraries
 - The next Haskell Platform release packages GHC 6.12 with 
     these tested libraries
 - Joe User downloads the Haskell Platform.
 - Four months later there's a new HP release, still with GHC 6.12,
     but with more or better libraries.  The HP release cycle is
     decoupled from GHC

So if you are Joe User, you want to wait for the HP release.  Don't
grab the GHC 6.12 release.  It'll be perfectly usable, but only if you
use (an up to date) cabal-install to download libraries, and accept that
they may not be tested with GHC 6.12.

SECOND, we have produced Release Candidate 1 for GHC 6.12.1, and are
about to produce RC2.  However, before releasing 6.12 we'd like to
compile all of Hackage, in case doing so reveals bugs in GHC's APIs
(which are not supposed to change).  But we can't do that until an
update to cabal-install is ready. (We don't expect this dependency to
happen all the time, but it does hold for 6.12.)

Duncan has been working on the cabal-install update, and expects
to release by end November.  So the timetable looks like this:

 - Very soon: GHC 6.12.1 release candidate 2
 - End Nov: cabal-install release
 - ...test GHC against Hackage...
 - Early Dec: release GHC 6.12
 - ...library authors and HP folk get busy...
 - End Jan (?): Haskell Platform release
 - ...Joe User downloads HP...

FINALLY, below I summarise a late change that's been pending for
a long time, which I propose to sneak into RC2, for reasons explained
below.  If you can see a good reason not to do this, yell.

Simon


Recursive do-notation.
~~~~~~~~~~~~~~~~~~~~~~
The change is this.  Instead of writing

  mdo { a <- getChar
      ; b <- f c
      ; c <- g b
      ; putChar c
      ; return b }

you would write

  do { a <- getChar
     ; rec { b <- f c
           ; c <- g b }
     ; putChar c
     ; return b }

That is, 
  * 'mdo' is eliminated 
  * 'rec' is added, which groups a bunch of statements
    into a single recursive statement
See http://hackage.haskell.org/trac/ghc/ticket/2798

This 'rec' thing is already present for the arrow notation, so it  
makes the two more uniform.  Moreover, 'rec' lets you say more
precisely where the recursion is (if you want to), whereas 'mdo' just
says "there's recursion here somewhere".  Lastly, all this works with
rebindable syntax (which mdo does not).

Currently 'mdo' is enabled by -XRecursiveDo.  So we propose to
deprecate this flag, with another flag -XDoRec to enable the 'rec'
keyword.

The main question is not whether to make this change, but when.  I'm
inclined to do put it into GHC 6.12, even though it's late in the day
because then we can take mdo out of 6.14 altogether. Another minor 
question is whether "-XDoRec" is a good name for the flag.  We can't
really use "-XRecursiveDo" because that's the one we are deprecating!