hugs, runhugs, ffihugs - Hugs 98, functional programming system

       Hugs 98: Mark Jones and others, June 1999.

       Manual page: Jonathan Bowen, modified by Gary Leavens, and then (with apologies to the original  authors)
       by  Mark  Jones.  Updated for Hugs 98 by Antti-Juhani Kaijanaho and Ross Paterson.  Updated for the March
       2005 ffihugs changes by Joseph P. Skudlarek.

                                                  December 2005                                          HUGS(1)

       On architectures that support dynamic linking, Hugs  implements  the  part  of  the  Haskell98ForeignFunctionInterface  (FFI)  that  allows  Haskell functions to call C routines.  (On the x86, PowerPC and
       Sparc architectures, all foreignimports are supported; on others, only  static  imports  are  provided.)
       Modules  containing  such foreign declarations must be compiled using the ffihugs command before use with
       hugs.  Additional arguments for the C compiler may be  supplied  via  compiler_arguments.   For  example,
       suppose  you have some C functions in test.c and some FFI declarations for those functions in Test.hs and
       the code in test.c needs to be compiled with -lm.  Then you would compile the module with the command

              ffihugsTest.hstest.c-lm

       which generates an object file Test.so.  Then when hugs loads Test.hs, it will also load Test.so.

       In the standard FFI, each foreignimport declaration should name a C header file containing the prototype
       of the function.  Because this is often cumbersome, ffihugs provides the following additional option:

       -istr  Specify an include for the generated C file.  The include string  should  be  something  that  can
              follow "#include" in a C program, as in

              ffihugs'-i<math.h>''-i"mydefs.h"'Test.hstest.c-lm

       Once the interpreter has been loaded, the following commands are available:

       :load [modules]   clear all modules except the prelude, and load the specified modules.

       :alsomodules     read additional modules.

       :reload           repeat last load command.

       :editfile        edit file.

       :edit             edit last file.

       :modulemodule    set module for evaluating expressions.

       expr              evaluate expression.

       :typeexpr        print type of expression.

       :?                display this list of commands.

       :setoptions      set command line options.

       :set              help on command line options.

       :names [patterns] list names currently in scope matching any of the shell-style patterns.

       :infonames       describe named objects.

       :browsemodules   browse names exported by modules.

       :findname        edit file containing definition of name.

       :!command         shell escape.

       :cddir           change directory.

       :gc               force garbage collection.

       :version          print Hugs version.

       :quit             exit Hugs interpreter.

       Any  command  may be abbreviated to :c where c is the first character in the full name.  On most systems,
       you can also exit from Hugs by typing the end-of-file character (^D).

       Note that the interrupt key (^C on most systems) can  be  used  at  any time whilst using Hugs to abandon
       the process of reading in a file  of function definitions or the evaluation  of   an   expression.   When
       the  interrupt is detected, Hugs prints the string "{Interrupted!}" and prints the prompt so that further
       commands can be entered.

       Hugs  is  an  interpreter  for  Haskell,  a  standard  non-strict  functional programming language.  Hugs
       implements almost all of the Haskell 98 standard, except for mutually recursive modules.  The  name  Hugs
       is a mnemonic for the HaskellUser'sGoferSystem.

       The  interpreter  is  started  using  the  hugs command.  After processing options, it loads the standard
       module Prelude and any other modules listed on the command line.

       Each Haskell module is stored in a separate file.  When loading a module name, Hugs replaces each `.'  in
       name with a `/' and looks in each of the directories on its search path (see -P under  OPTIONS)  for  the
       files name.hs and name.lhs.  (The recognized suffixes may be changed using the -S option, described under
       OPTIONS.)   It  also  tries  name  as a literal filename.  Files ending in ".lhs" are treated as literate
       scripts.

HUGSFLAGS
              Additional options for hugs, processed before any given on the command line.

       HUGSDIR
              The Hugs library directory (default: /usr/lib/hugs).

       EDITOR The default editor, if -E is not given.

       SHELL  Used to specify the shell that is invoked by the :! command.

/usr/bin/hugs
              executable binary.

       /usr/lib/hugs
              directory containing support files.

       hugs, runhugs, ffihugs - Hugs 98, functional programming system

       Some options are toggled with + or - to turn them on or off, respectively.

   Languageconformance+98    Accept only Haskell 98 (cannot be changed within Hugs; default: on).   Turning  this  off  enables
              several special Hugs extensions, which are described in the Hugs98UserManual.

       +o     Allow overlapping instances (a Hugs extension; default: off)

       +O     Allow unsafe overlapping instances (a Hugs extension; default: off)

       +H     Allow `here documents' (a Hugs extension; default: off)

   Moduleloading+l     Treat files whose names end in neither `.hs' nor `.lhs' as literate scripts (default: off)

       +.     Print dots to show progress while loading modules (default: off)

       +q     Print nothing to show progress while loading modules (default: on)

       +w     Always show which files are loaded (default: off)

   Expressionevaluation+s     Print number of reductions/cells after each evaluation (default: off)

       +t     Print type after each evaluation (default: off)

       +T     Apply the Haskell defaulting rules before printing types (default: off)

       +g     Print number of cells recovered after each garbage collection (default: off)

       +Q     Qualify names when printing (default: off)

       +k     Show kind errors in full (default: off)

       +u     Use "show" to display results (default: on)

       +I     Display results of IO programs (default: off)

   Parameters
       Other options (in which - could be replaced by +, the choice making no difference) are:

       -hnum  Set heap size (cannot be changed within Hugs; default: 250K)

       -pstr  Set  prompt string to str (default: `%s> ').  Any %s in the prompt will be replaced by the current
              module name.

       -rstr  Set repeat last expression string to str (default: $$).

       -Pstr  Set search path for source files to str, which should be a colon-separated list of directories.  A
              null entry in this list will be replaced by the previous search path; a null str means the default
              path.  Any occurrence of {Hugs} in this string is expanded to the Hugs library  directory,  namely
              /usr/lib/hugs.   Similarly,  {Home}  is  expanded  to  your  home directory (the value of the HOME
              environment variable).  An entry of the form `directory/*' means all the immediate  subdirectories
              of directory.  The default value is

                     .:{Home}/lib/hugs/packages/*:/usr/local/lib/hugs/packages/*:{Hugs}/packages/*:{Hugs}/libraries-Sstr  Set  the colon-separated list of source file suffixes to str (default: .hs:.lhs).  A null entry in
              this list will be replaced by the previous suffix list; a null str means the default list.

       -Estr  Use editor setting given by str (default: the value of  the  EDITOR  environment  variable).   Any
              occurrences  of  %d and %s in the editor option are replaced by the start line number and the name
              of the file to be edited, respectively.  A common setting is "vi+%d%s".

       -cnum  Set constraint cutoff limit in the type checker to num (default: 40).

       -Fcmd  Set preprocessor filter for source files to cmd (unset by default).  Instead of reading  a  source
              file  directly,  Hugs  will  read  the  standard  output  of  cmd run with the source file name as
              argument.

       -Xstr  The string str is interpreted as an option string.  This  is  useful,  for  example,  for  passing
              multiple arguments to runhugs in a #! script.

       Mark P. Jones et al. Hugs98UserManual, June 1999.

       Hugs98User'sGuide (distributed with Hugs).

       Paul Hudak & Joseph H. Fasel.  A gentle introduction to Haskell.  ACMSIGPLANNotices, 27(5), May 1992.

       S. Peyton Jones (editor).  Haskell98LanguageandLibraries:TheRevisedReport.  December 2002.

       Manuel  Chakravarty  et  al.   Haskell98ForeignFunctionInterface1.0, AddendumtotheHaskellReport,
       September 2003.

       The runhugs command is an interpreter for an executable Hugs script, which must contain  a  Haskell  Main
       module.  For example, the executable file hello might contain the lines

              #!/usr/bin/runhugs+l>moduleMainwhere>main=putStr"Hello,World\n"

       When  this  file  is executed, runhugs will invoke the main function.  Any arguments given on the command
       line will be available through getArgs.

       Note that #! passes only one orgument to the script.  The -X option may be used to get around this.

hugs [ options ] [ modules ]
       runhugs [ options ] module [ args ]
       ffihugs [ options ] module [ compiler_argument ] ...

http://www.haskell.org/hugs/
              The Hugs home page.

       http://www.haskell.org/
              The Haskell home page, including the language definition, various mailing lists and much more.