[Haskell-cafe] HaRe (the Haskell Refactorer) in action - short screencast

[Claus Reinke]

I've heard that many Haskellers know HaRe only as a rumour. It has 
been many years since the original project finished, and HaRe hasn't
been maintained for quite some time, so just pointing to the sources 
isn't quite the right answer. 

The sources are still available, and build with GHC 6.8.3 (I had to fix
one lineending issue on windows, iirc, and copy one old bug fix that
hadn't made it into the latest release), but there is currently noone with 
the time or funding for maintenance, fixing bugs, making releases, or 
ironing out practical issues. If anyone would provide funding, people to 
do the work could be found, but the effort would probably be better 
spent on reimplementing the ideas in a GHC / Cabal environment 
(instead of the Haskell'98 environment targetted by our "Refactoring 
Functional Programs" project). If you've got the funding, please get
in touch - even a three month run could get something started at least!-)

In principle, the project experiences and lessons learned are quite well 
documented at the project site 

    http://www.cs.kent.ac.uk/projects/refactor-fp/

but that doesn't give anyone an idea of what working with HaRe was 
like. With the recent interest in screencasts, I thought I'd make a little
demo, for archival purposes. Nothing fancy, using only features that 
were already present in HaRe 0.3 (end of 2004), and not all of those, 
on a tiny 2-module example (screenspace is a bit crowded to keep 
the text readable on YouTube). 

I hope it might give a rough idea of what the papers, slides and reports 
are talking about, for Haskellers who weren't around at the time:

    http://www.youtube.com/watch?v=4I7VZV7elnY

For the old HaRe team,
Claus

------------------- YouTube video description:
HaRe - the Haskell Refactorer (a mini demo) [4:10]

The Haskell Refactorer HaRe was developed in our EPSRC project 
    "Refactoring Functional Programs" 
    http://www.cs.kent.ac.uk/projects/refactor-fp/ 
Building on Programatica's Haskell-in-Haskell frontend and Strafunski's 
generic programming library, it supported module-aware refactorings 
over the full Haskell'98 language standard. Interfaces to the refactoring 
engine were provided for both Vim and Emacs (this demo uses HaRe 
via GVim on Windows).

While HaRe has continued to see occasional contributions by students 
and researchers, who use its Haskell program transformation API as a 
platform for their own work, it is not currently maintained. As the Haskell 
environment marches on, this demo is meant to record a snapshot of 
what working with HaRe could be like when it still built (here with GHC 6.8.3). 

The lessons learned (note, eg, the preservation of comments, and the 
limited use of pretty-printing, to minimize layout changes) are well 
documented at the project site, and should be taken into account 
when porting the ideas to the GHC Api, or other Haskell frontends.