Now that the Haskell report has appeared in SIGPLAN Notices, it seems
like a good time to broadcast the current status of Haskell 
implementations.  Below appears an up-to-date summary of implementations
known to me.  If there are other implementations about, please let me know!

Simon Peyton Jones

                Haskell:  Current status

        Simon Peyton Jones, Phil Wadler, Will Partain,
        Cordy Hall, Kevin Hammond

        Dept of Computing Science, Glasgow University, 
        Glasgow G12 8QQ,  Scotland.

        email: [EMAIL PROTECTED]

        (April 1991; additions, November 1991, June 1992)

The Haskell language
In September 1987 a meeting was held at the conference on Functional
Programming Languages and Computer Architecture in Portland, Oregon,
to discuss an unfortunate situation in the functional programming
community: there had come into being more than a dozen non-strict,
purely functional programming languages, all similar in expressive
power and semantic underpinnings.  There was a strong consensus at the
meeting that more widespread use of this class of functional languages
was being hampered by the lack of a common language.  It was decided
that a committee should be formed to design such a language, providing
faster communication of new ideas, a stable foundation for real
applications development, and a vehicle through which others would be
encouraged to use functional languages.

The Haskell committee released its report on 1 April 1990. A revised
version (Version 1.2) appeared in SIGPLAN Notices 27(5) (May 1992),
along with a tutorial on Haskell by Hudak and Fasel.

Implementations of Haskell
This is a frank summary of the implementations of Haskell known to

  hbc   Chalmers        A serious and mature compiler.  Use this 
  hbi                   if you want to write large Haskell programs.
                        hbi is an interactive version.  Written in LML.
                        You need a big machine.

  glhc  Glasgow         Another serious compiler, but less mature than
                        hbc.  Intended partly as a framework for
                        implementors.  Written in Haskell, generates
                        C.  You need a big machine.

  yh2.0 Yale            A compiler from Haskell to Lisp, built on top of
                        Common Lisp (EuLisp and Scheme should also work).
                        An interactive, integrated Haskell programming
                        environment.  Supports both large scale Haskell
                        programming and educational use.  Needs a
                        moderately big machine - we expect to release a
                        Mac and PC version soon.  Supports language
                        implementors.  Expected release: August 1992.

  gofer Oxford          An interpreter for a language very similar to
                        Haskell.  A "best buy" if you just want to get
                        started.  Much much faster to use than the
                        compilers below for small programs, because it
                        compiles and loads programs amazingly fast.
                        Written in C, and portable; you don't need a
                        big machine! Only implementation to work on 
                        IBM PCish things.

Below appears a bit more information about each of these

The Haskell mailing list
There is an electronic mailing list to discuss technical issues
related to Haskell.  To join this list, send your request to
"[EMAIL PROTECTED]" (Europe and Australasia) or
"[EMAIL PROTECTED]" (rest of world) as appropriate.

Standard archive sites for Haskell stuff

You can use anonymous FTP (username: anonymous; password: your e-mail
address) to these hosts, where you will find things in "pub/haskell"
and its subdirectories.

        Site     Host name              Raw IP address



The Glasgow compiler
The Glasgow Haskell compiler has the following attributes:

* Freely available (see below).

* Written in Haskell.

* Generates C as its target code -- hence highly portable.

* Specifically designed to act as a "motherboard" into which 
  others can "plug in" their own strictness analyser, profiler, 
  front end, back end, or other special pass.

* Internally, it uses the second-order polymorphic lambda calculus to
  preserve correct type information in the face of substantial program

* Back end based on the Spineless Tagless G-machine -- our abstract
  machine for non-strict functional languages.  (Paper available.)

* Plants code to gather profiling information, of two sorts.  First,
  low-level counts of various aspects of the abstract machine model.
  Second, and more interesting, programmer-level space and time
  profiling of "cost centres".  (Paper available.)

* Heavily configurable runtime system.  For example, the "motherboard"
  comes with three different garbage collectors: two-space, one-space
  compacting, and Appel-style generational.

* New monad-based model for input/output, which allows calls to
  arbitrary C procedures without losing referential transparency.
  Based on this technology, the entire I/O system is implemented in
  Haskell itself.

Current status (June 1992):
        Generates code which runs, but which is larger and slower than hbc.
        If you are a Haskell programmer you don't want it yet.
        If you are a Haskell implementor, it is useful now.

How to get the compiler and papers:  
        Use anonymous FTP to one of the standard archive sites, with
        pub/haskell/glasgow being a particularly likely place to find
        things. is the most likely to have
        up-to-date things (obviously); it also has a Glasgow-specific
        directory, pub/glasgow-fp.

        The same stuff is available by NIFTP (UK only); send email to
        haskell-request if you need details.

The Chalmers compiler: hbc/hbi
The Chalmers Haskell-B compiler implements a dialect of Haskell.  It
is written by Lennart Augustsson, and based on the classic LML
compiler by Augustsson and Johnsson.  

Status (as of August 1992):

* Current version is 0.998.1.

* Has several optional extensions to Haskell.  The most interesting one
  is probably the existentially quantified types.

* Can generate code for both time and heap profiling.

* The interactive system hbi is an interpreter for Haskell, but it can also
  load code compiled with hbc.

* Generates native code and runs on SUN3, SUN4, DECstation, VAX, ARM, 
  and Sequent Symmetry.  (Unsupported versions for NS32000, RT/PC, and Cray.)
  Soon available on RS6000.


        Lennart Augustsson
        Chalmers University

The hbc distribution is available from the standard archive sites, in

The Yale compiler
The Yale Haskell compiler (yh2.0) has the following attributes:

* Freely available.

* Written in Lisp (Common Lisp, EuLisp, or Scheme).

* Generates Lisp as its target code -- hence highly portable.

* Interactive programming environment based on the Emacs editor.  Comes
  with an online Haskell tutorial.

* Easy to call out to Lisp (or C, depending on the Lisp being used)

* Fast compilation.

* High quality code.  The ultimate code quality will depend on the
  underlying Lisp system but the Yale compiler will generate declarations
  which will allow the more sophisticated Lisp systems to produce
  the best possible code.

The Yale system should be ready for general release in August 1992.
Watch for announcements to the mailing list and comp.lang.functional.
For more information contact [EMAIL PROTECTED]

Future releases of Yale Haskell (probably Fall 92) are expected to include
the following features:

* Compiler passes and data structures will be accessable from Haskell,
  allowing new or different phases written in Haskell to be inserted.

* Strict data constructors

* Dynamic typing

* Interfaces tuned to the Mac and PC

* More support for separate compilation and large scale Haskell programs.

* Compiler pragmas to create specialized versions of overloaded operators.

* Language extensions to support efficient manipulation of state 
     (including arrays).

        John Peterson
        Yale University
        Department of Computer Science
        New Haven, CT 06520


The Gofer interpreter
The Gofer interpreter implements a subset of Haskell, and uses an
experimental variant of Haskell's innovative `type classes' for
overloading.  It extends Haskell in some ways, and subsets it in
others.  The most significant features of Haskell not currently
supported are: modules, arrays, overloaded numeric constants, default
declarations, derived instances and contexts in datatype definitions.

It runs on Sun3's, Sun4's, and IBM PC's, Macs, Atari ST, Commodore
Amiga, Acorn Archimedes and others.  


        Mark Jones
        Programming Research Group
        Oxford University
        Oxford  OX1 3QD


(Mark is moving to Yale in Sept 92.)

The Gofer distribution is available from the standard archive sites
(see above), in pub/haskell/gofer.

Reply via email to