A N N O U N C E M E N T
Happy v0.7 (alpha)
The LALR(1) Parser Generator for Haskell
This is the first public release of our parser generator system for
Haskell, called Happy (a dyslexic acronym for 'A Yacc-like Haskell
Parser generator'). Happy is written in Haskell, uses a parser
generated by itself, and can be compiled using ghc, hbc or gofer.
Happy cannot currently be compiled using Yale Haskell because of its
lack of support for stream IO (Happy uses an implementation of monadic
IO built on top of stream IO, but this should change when the Haskell
1.3 standard has been agreed on and implemented).
Happy can be obtained by anonymous ftp from
ftp.dcs.gla.ac.uk 130.209.240.50
in the directory
pub/haskell/happy
Happy is covered by the GNU General Public License, see the
documentation for details.
Please send any bug reports, comments, and money to
{andy,simonm}@dcs.gla.ac.uk.
This is the introduction from the manual:
---------------------------------------------------------------------------
Happy is a parser generator system for Haskell, similar to the tool
`yacc' for C. Like `yacc', it takes a file containing an annotated
BNF specification of a grammar and produces a Haskell module
containing a parser for the grammar.
Happy is flexible; unlike `yacc', you can have several Happy parsers
in the same program. Happy can work in conjunction with a lexical
analyser supplied by the user (either hand-written or generated by
another program), or it can parse a stream of characters directly
(but this isn't practical in most cases). In a future version we hope
to include a lexical analyser generator with Happy as a single
package.
Happy can currently generate three types of parser from a given
grammar, the intention being that we can experiment with different
kinds of functional code to see which is the best, and compiler
writers can use the different types of parser to tune their
compilers. The types of parser supported are:
1. `standard' Haskell (should work with any compiler that compiles
the Haskell language).
2. standard Haskell using arrays (this is not the default because we
have found this generates slower parsers than 1).
3. Haskell with ghc (Glasgow Haskell) extensions. This is a slighty
faster option than 1 for Glasgow Haskell users.
Parser type 1 will also work with Gofer, as will parser type 2 given a
suitable implementation of arrays.
-----------------------------------------------------------------------------
