


HUGS(1)                                                   HUGS(1)


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

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

DESCRIPTION
       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 Haskell User's Gofer System.

       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  mod-
       ule  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.

OPTIONS
       Some options are toggled with + or - to turn them on  or  off,  respec-
       tively.

   Language conformance
       +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 Hugs 98 User Manual.

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

   Module loading
       +l     Treat files whose names end in neither `.hs' nor `.lhs' as  lit-
              erate 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)





                          December 2005                         1





HUGS(1)                                                   HUGS(1)


   Expression evaluation
       +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/local/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 subdi-
              rectories of directory.  The default value is

                     .:{Home}/lib/hugs/packages/*:/usr/local/lib/hugs/pack-
                     ages/*:{Hugs}/packages/*

       -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  EDI-
              TOR  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".




                          December 2005                         2





HUGS(1)                                                   HUGS(1)


       -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 use-
              ful, for example, for passing multiple arguments to runhugs in a
              #! script.

COMMANDS
       Once the interpreter has been loaded, the following commands are avail-
       able:

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

       :also modules     read additional modules.

       :reload           repeat last load command.

       :edit file        edit file.

       :edit             edit last file.

       :module module    set module for evaluating expressions.

       expr              evaluate expression.

       :type expr        print type of expression.

       :?                display this list of commands.

       :set options      set command line options.

       :set              help on command line options.

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

       :info names       describe named objects.

       :browse modules   browse names exported by modules.

       :find name        edit file containing definition of name.

       :!command         shell escape.

       :cd dir           change directory.

       :gc               force garbage collection.




                          December 2005                         3





HUGS(1)                                                   HUGS(1)


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

STANDALONE PROGRAMS
       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/local/bin/runhugs +l

              > module Main where
              > 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.

C INTERFACE
       On architectures that support dynamic linking, Hugs implements the part
       of  the Haskell 98 Foreign Function Interface (FFI) that allows Haskell
       functions to call C routines.  (On the x86, PowerPC and Sparc architec-
       tures,  all  foreign  imports  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.  Addi-
       tional arguments for the C compiler may be supplied via  compiler_argu-
       ments.   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 mod-
       ule with the command

              ffihugs Test.hs test.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 foreign import 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,



                          December 2005                         4





HUGS(1)                                                   HUGS(1)


              as in

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

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

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

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

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

FILES
       /usr/local/bin/hugs
              executable binary.

       /usr/local/lib/hugs
              directory containing support files.

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

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

SEE ALSO
       Mark P. Jones et al. Hugs 98 User Manual, June 1999.

       Hugs 98 User's Guide (distributed with Hugs).

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

       S. Peyton Jones (editor).   Haskell  98  Language  and  Libraries:  The
       Revised Report.  December 2002.

       Manuel  Chakravarty  et al.  Haskell 98 Foreign Function Interface 1.0,
       Addendum to the Haskell Report, September 2003.

AUTHOR
       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                         5


