Yale Haskell 2.1 Released

Fri, 29 Jul 1994 14:42:31 GMT

          From comp.compilers

Related articles
Yale Haskell 2.1 Released jcp@NEBULA.SYSTEMSZ.CS.YALE.EDU (1994-07-29)
| List of all articles for this month |

Newsgroups: comp.compilers
From: jcp@NEBULA.SYSTEMSZ.CS.YALE.EDU (John C. Peterson)
Keywords: Haskell, available, FTP
Organization: Compilers Central
Date: Fri, 29 Jul 1994 14:42:31 GMT

*** Announcing the Latest and Greatest Release of Yale Haskell ***

Yale Haskell 2.1 has many significant new features and improvements,
including substantially improved compiled code. Thus we'd like to take
this opportunity to briefly describe the entire system rather than give an
incremental status report.

The Yale Haskell system is a fully integrated Haskell programming
environment. It provides tightly coupled interactive editing, incremental
compilation, and dynamic execution of Haskell programs. Two major modes
of compilation, corresponding to Lisp's traditional "interpreted" and
"compiled" modes, allow one to rapidly develop software (using the
interpreted mode), saving performance gains till the software has
stabilized (using the compilation mode). Compiled and interpreted modules
may be freely mixed in any combination.

Yale Haskell is run using either a command-line interface or as an
inferior process running under the Emacs editor. Using the Emacs
interface, simple two-keystroke commands evaluate expressions, run
dialogues, compile modules, turn specific compiler diagnostics on and off,
enable and disable various optimizers, etc. Commands may be queued up
arbitrarily, thus allowing, for example, a compilation to be running in
the background as the editing of a source file continues in Emacs in the

In addition, to further enhance incremental compilation, a "scratch pad"
may be automatically created for any module. Such a pad is a logical
extension of the module, in which additional function and value
definitions may be added, but whose evaluation does not result in
recompilation of the module.

A tutorial on Haskell is also provided in the Emacs environment. It
follows the Sigplan Notices Hudak/Fasel "Gentle Introduction"
section-by-section, and encourages user interaction. This is a very
popular teaching device for novice users.

We also support a Macintosh version of Yale Haskell that includes its own
integrated programming environment, complete with an Emacs-like editor,
pull-down menus, etc.

Yale Haskell is a complete implementation of the Haskell language, but
also contains a number of extensions, including:

(1) Instead of the old-style stream based I/O, a monadic I/O system is
        used. Although similar to what will be part of the new Haskell 1.3
        report, the I/O system will change yet again when 1.3 becomes official.

(2) Haskell programs can call both Lisp and C functions using a
        flexible foreign function interface.

(3) Yale Haskell includes a dynamic typing system. Dynamic typing has
        been used to implement derived instances in a user extensible manner.

(4) A number of small Haskell 1.3 changes have been added, including
        polymorphic recursion and the use of @_@ in an expression to denote
        bottom. Although the 1.3 report is not yet complete, these changes
        will almost certainly be part of the new report.

(5) A complete X window interface, based on the CLX system, is included.

(6) A number of annotations are available for controlling the optimizer,
        including those for specifying both function and data constructor
        strictness properties, "inlining" functions, and specializing
        over-loaded functions. Many standard prelude functions have been
        specialized for better performance using these annotations.

(7) Separate compilation (including mutually recursive modules) is
        supported using a notion of a UNIT file, which is a kind of localized
        makefile that tells the compiler about compiler options and
        logical dependencies amongst program files.

(8) Yale Haskell supports both standard and "literate" Haskell syntax.

Performance of Yale Haskell's compiled code has been improved considerably
over previous releases. Although still not as good as the Glasgow and
Chalmers compilers, the flexibility afforded by the features described
earlier makes Yale Haskell a good choice for large systems development.
For some idea of performance, Hartel's latest "Nuc" benchmark runs at
about the same speed under both Yale Haskell and hbc. (Our experiments
suggest, however, that Yale Haskell's compiled code is on average about 3
times slower than hbc.)

The Yale Haskell systems is available on a number of popular systems;
binaries are provided for Sun/Sparc and Macintosh, but it is possible to
build the system on virtually any system that runs one of a number of
Common Lisp implementations. We do NOT support either akcl (gcl) or
CLisp; these systems do not have adaquate performance for our compiler.
See the manual for details.

Our system is available for anonymous ftp from the Yale Haskell ftp site:
(other Haskell ftp sites may also have these files)

                Site Host name Raw IP address
                Yale nebula.cs.yale.edu

All files are in the directory pub/haskell/yale. Consult the README in
this directory for further details.

To obtain Yale Haskell via ftp:

    - Move to the directory where you intend to place Yale Haskell
    - Ftp to nebula and login anonymously
    - cd to pub/haskell/yale
    - Get the tar file: get haskell-2.1-?.tar.gz
    - Unzip the file: (your zip utility may have a different name)
                      gzip -d *.gz
    - Untar the file: tar xf *.tar
    - Consult the documentation for further instructions. The manual
        is provided in Postscript form as doc/manual/haskell.ps.

Please send any comments or questions to haskell-request@cs.yale.edu

Post a followup to this message

Return to the comp.compilers page.
Search the comp.compilers archives again.