Man Linux: Main Page and Category List


       happy - the parser generator for Haskell


       happy [OPTION]... file [OPTION]...


       This manual page documents briefly the happy command.

       This  manual  page  was  written  for the Debian GNU/Linux distribution
       because the original program does not have a manual page.  Instead,  it
       has  documentation  in  various  other formats, including DVI, Info and
       HTML; see below.

       Happy is a parser generator system for Haskell.  ‘HAPPY’ is a  dyslexic
       acronym for ‘A Yacc-like Haskell Parser generator’.

       There  are  two  types  of  grammar files, file.y and, with the
       latter observing the reverse comment bird track convention (i.e.   each
       code  line  must  begin with ‘>’).  The examples distributed with Happy
       are all of the .ly form.

       Caveat:  When  using  hbc  (Chalmers  Haskell)  the  command   argument
       structure  is  slightly  different.   This  is because the hbc run time
       system takes some flags as its own (for setting things  like  the  heap
       size,  etc).   This problem can be circumvented by adding a single dash
       (‘-’) to your command line.  So when using a hbc generated  version  of
       Happy, the argument structure is:

       happy - [OPTION]... file [OPTION]...


       The  programs  follow  the  usual  GNU  command  line syntax, with long
       options starting with two dashes  (‘--’).   A  summary  of  options  is
       included   below.    For   a   complete   description,  see  the  other

       -h, --help
              Show summary of options.

       -v, --version
              Print  version  information  on  standard   output   then   exit

       -a, --array
              Instructs  Happy to generate a parser using an array-based shift
              reduce parser.  When used in conjunction  with  -g,  the  arrays
              will  be  encoded  as  strings,  resulting  in  faster  parsers.
              Without -g, standard Haskell arrays will be used.

       -g, --ghc
              Instructs Happy to generate  a  parser  that  uses  GHC-specific
              extensions to obtain faster code.

       -c, --coerce
              Use  GHC’s  unsafeCoerce#  extension  to generate smaller faster
              parsers.  One drawback is that some type safety is  lost,  which
              means that a parser generated with -c may compile fine but crash
              at run-time.  Be sure to compile your grammar without  -c  first
              to ensure it is type-correct.

              This option has quite a significant effect on the performance of
              the resulting parser, but remember that parsers  generated  this
              way can only be compiled by GHC 3.02 and above.

              This option may only be used in conjuction with -g.

       -d, --debug
              Generate  a  parser  that  will  print  debugging information to
              stderr at run-time, including all the shifts, reductions,  state
              transitions and token inputs performed by the parser.

              This option may only be used in conjuction with -a.

       -i [FILE], --info[=FILE]
              Directs  Happy  to  produce  an  info  file  containing detailed
              information about the grammar, parser  states,  parser  actions,
              and  conflicts.   Info  files  are vital during the debugging of

              The filename argument is optional, and if omitted the info  file
              will  be written to (where FILE is the input file name
              with any extension removed).

       -o FILE, --outfile=FILE
              Specifies the destination of the generated  parser  module.   If
              omitted, the parser will be placed in FILE.hs, where FILE is the
              name of the input file with any extension removed.  If FILE is -
              the generated parser is sent to the standard output.

       -m NAME, --magic-name=NAME
              Happy  prefixes  all  the symbols it uses internally with either
              happy or Happy.  To use a different string, for example  if  the
              use  of  happy  is  conflicting  with one of your own functions,
              specify the prefix using the -m option.

       -t DIR, --template=DIR
              Instructs Happy to use this directory when looking for  template
              files:  these  files contain the static code that Happy includes
              in every generated parser.   You  shouldn’t  need  to  use  this
              option if Happy is properly configured for your computer.

       -l, --glr
              Instructs  Happy  to  output  a GLR parser instead of an LALR(1)

       -k, --decode
              Causes the GLR parser to generate code for  decoding  the  parse
              forest to a list of semantic results (requires --ghc).

       -f, --filter
              Causes  the GLR parser to filter out nodes which aren’t required
              for the semantic results (an experimental optimisation, requires




       /usr/share/doc/happy, the Happy homepage (


       Happy Version 1.18.4

       Copyright  (c)  1993-1996  Andy Gill, Simon Marlow; (c) 1997-2001 Simon


       This manual page was written by  Michael  Weber  <>,
       for the Debian GNU/Linux system (but may be used by others).