The Haggis User Interface System
		   ++++++++++++++++++++++++++++++++

We are proud to announce the first public release of the Haggis user
interface system.  Sources and binaries are freely available by anon
FTP and via the World-Wide Web; details follow.

Haggis is a graphical user interface framework for the lazy functional
programming language Haskell. It compiles and runs with the Glasgow
Haskell Compiler (GHC), using its concurrent extensions
(aka. Concurrent Haskell). GHC is available on most Unix platforms
(see below for details), and interfaces with the X Window system,
X11R[56].

Haggis is a root-and-branch approach to bringing graphical user
interfaces to Haskell and functional programming, having been designed
from the bottom up in Haskell (version 1.2). Apart from a basic
framework for building user interfaces by composing user interface
components together, Haggis comes with a large collection of common
user interface abstractions.


Highlights of this first release include:
------------------------------------------

* Multi-threaded, concurrent user interface framework.

    To help structuring the high degree of interaction with the user
    and the outside world, Haggis uses concurrency to separate
    concerns. Haggis is built on top of the concurrent extensions to
    the Glasgow Haskell Compiler (aka. Concurrent Haskell).

* An extensible framework for building user interfaces.

    Haggis offers a simple framework for building user interfaces from
    parts. Using only a few primitive abstractions and combinators for
    glueing `components' together, complete applications or new user
    interface abstractions can be built. Indeed, one of the goals
    behind Haggis is to try to eradicate the boundary between
    building user interface abstractions (`widgets') and writing
    applications.

* An (almost) complete set of common user interface abstractions.

    Using the Haggis core set of combinators, a large collection of
    user interface abstractions have been built. In scope, this
    collection is equal to what toolkits such as Tk, Athena, Java's
    AWT or Fudgets (the `standard' FP toolkit) offers.

    A caveat to this (bold) claim is that the set of abstractions for
    handling text input and output is somewhat lacking at the moment,
    as there is no support for multi-line text editing or a proper
    abstraction for viewing large chunks of text. Expect this to
    change though.

* A simple model of structured graphics.

    To describe graphical output, Haggis opt for a non-procedural
    approach. Instead of describing graphical output as a sequence of
    side-effecting operations on some drawing surface, a simple model
    of structured, declarative graphics is used. A picture is
    described by an abstract value that can be manipulated and
    combined together with other picture values to compose complete
    graphical scenes. These picture values can then be converted into
    actual graphical output on the screen, or can be printed out as
    PostScript.

    In the cases where the graphical output have no apparent or
    simple compositional structure, Haggis also provide a
    procedural drawing interface.

    Haggis currently groks the XBM, XPM and P[B,P]M image formats.

* An abstract view of the underlying window system.

    To try and save the user from having to learn about Haggis
    *and* the details of the underlying window system (the X Window
    system), Haggis tries to hide its current X11 parentage by
    providing some (we hope!) window system independent
    interfaces for accessing and communicating with the window system.
    (If you want to see what's under the bonnet and deal with X11
     directly, you can.)

* Uses modern functional I/O model.

    Haggis uses the now standard Haskell way of expressing I/O, 
    the IO monad. Interacting with the user interface components
    is presented as interaction with any other device, like a file or
    channel.
    
* A reasonably complete set of documentation describing the system.
    


Relevant URLs on the World-Wide Wait:

Haggis home page  http://www.dcs.gla.ac.uk/fp/software/haggis
GHC home page     http://www.dcs.gla.ac.uk/fp/software/ghc.html


For directions on how to build the system, please consult the file
INSTALL in the distribution.

WARNING: this is 0.1, so bloat&bugs are still present. No prizes for
finding bugs I'm afraid, but bug reports are most welcome (send them
to sof@dcs.gla.ac.uk), as we are very keen to stamp out any problems
and get this monster flying. 

Glasgow 12/4/96 - Sigbjorn Finne and Simon Peyton Jones

======================================================================
How to get Haggis 0.1:

This release is available by anonymous FTP from Glasgow,
in the directory pub/haskell/glasgow:

	ftp.dcs.glasgow.ac.uk  (130.209.240.50)

The Glasgow site is mirrored by src.doc.ic.ac.uk (146.169.43.1), in
computing/programming/languages/haskell/glasgow.

These are the available files (.gz files are gzipped) -- binary
bundles are `on demand', ask if you don't see them:

 haggis-0.1.tar.gz             The source distribution; (580K)

 haggis-0.1.ANNOUNCE           What you are now reading.

 haggis-0.1.README             From the distribution.

 haggis-0.1-<platform>.tar.gz  Binary distributions for a particular
                               <platform> - unpack and go.

            platform  ==>      alpha-dec-osf2
			       i386-unknown-linuxaout
			       i386-unknown-solaris2
  			       sparc-sun-sunos4
			       sparc-sun-solaris2