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 conjunction 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 conjunction 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.11

SEE ALSO

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

COPYRIGHT

       Happy Version 1.19.11

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