ANNOUNCE: HaRe, the Haskell Refactorer, version 0.1

C.Reinke C.Reinke at
Thu Oct 2 12:19:47 EDT 2003

Dear Haskellers,

as part of our project on Refactoring Functional Programs

we are pleased to announce the availability of HaRe 0.1 (also 
known as HaRe 01/10/2003 ;-), a snapshot of our Haskell Refactorer
prototype. You can get it via

Please see the README.txt for build/use instructions and known
issues, and let us know about any problems, bugs, suggestions, or
additional platforms you can confirm as working: our project address
at is refactor-fp (which we'd like to keep spam-free).

An initial catalogue describing the refactorings implemented in HaRe
(with slightly different names) is included in the doc/ directory.

Happy Refactoring!

  The HaRe Team (Huiqing Li, Claus Reinke, Simon Thompson)



  Refactoring is the process of changing the structure of programs
  without changing their functionality, i.e., refactorings are
  meaning-preserving program transformations that implement design
  changes. For more details about refactoring, about our project and
  for background on HaRe, see our project pages and the
  papers/presentations/catalogue/demo/etc. available there, especially
  our contribution to this year's Haskell Workshop.

HaRe - the Haskell Refactorer:

  HaRe is our prototype tool supporting a first few basic refactorings
  for Haskell 98 (see README.txt for known issues and limitations).

  It is implemented as a separate refactoring engine (on top of
  Programatica's Haskell frontend and Strafunski's generic traversal
  strategy library), with small scripting frontends that call this
  engine from either Vim or Emacs. The refactoring engine itself has
  been seen to build (with ghc-5.04.3) and run on most flavours of
  Windows (cygwin needed to build) and on Suns (binutils recommended
  to build), so we expect it to build and work on other unix-like
  platforms with almost no changes.  

  In other words, we've tried to make sure that most of you should be
  able to build and use HaRe from your favourite OS/editor. 

  Currently supported refactorings: 

     removeDef      : remove an unused definition
     duplicateDef   : duplicate a definition under a new name

     liftToTopLevel : move a local definition to top level
     liftOneLevel   : move a local definition one level up
     demote         : move a definition local to point of use

     rename         : rename an identifier
     introNewDef    : turn expression into use of new definition
     unfoldDef      : replace use of identifier by right-hand side

     addOneParameter: add parameter to definition
     rmOneParameter : remove unused parameter from definition
     generaliseDef  : turn expression on rhs of definition into 
                      new parameter of that definition

  A series of screenshots illustrating some of the tasks one might
  want to accomplish with these refactorings can be found via the 
  HaRe page (see above for URL).

Caveats (see also README.txt):

  Please keep in mind that this is a prototype, so we do not recommend
  to use it on your productions sources just yet. Just play with it
  to get an idea of tool-supported refactoring in Haskell, and send us
  your feedback and bug-reports. Our goal is to develop this into a
  tool that many of you will find indispensible for Haskell
  development, and while we won't be able to follow every suggestion,
  we've got almost two more years in which to work towards this goal!-)


  Functionally, this is still roughly the snapshot you've seen at the
  Haskell workshop, packaged up for relative ease of build/use.
  Indeed, interim snapshots have been available all through September,
  and some of you have already played with those. The earliest
  snapshots were somewhat buggy, but over the last weeks the software
  has stabilised to the extent that we are back to Bug 0 (aka:
  insufficient test-coverage!-), and the time has come to distribute
  the current snapshot more widely.

More information about the Haskell mailing list