NAME

       happy - the parser generator for Haskell

SYNOPSIS

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

DESCRIPTION

       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 file.ly, 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]...

OPTIONS

       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 documentation.

       -h, --help
              Show summary of options.

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

       -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 grammars.

              The filename argument is optional, and if omitted the info file will be written  to
              FILE.info (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) parser.

       -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 --ghc).

FILES

       /usr/share/happy-1.19.0

SEE ALSO

       /usr/share/doc/happy,       the       Happy      homepage      (http://haskell.org/happy/)
       ⟨http://haskell.org/happy/⟩

COPYRIGHT

       Happy Version 1.19.0

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

AUTHOR

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