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

hugs [ options ] [ modules ]

runhugs [ options ] module [ args ]

ffihugs +G [ options ] [ +Larg ] ... module

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

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

Language conformance

Module loading

Expression evaluation

Parameters

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

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

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

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

#!/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.

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 architectures, all foreign import are supported; on others, only static imports are provided.) Modules containing such foreign declarations must be compiled using the ffihugs command with the +G option. Additional arguments for the C compiler may be supplied with +L options. 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

ffihugs +G +L"test.c" +L"-lm" Test.hs

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

HUGSFLAGS

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

HUGSDIR

The Hugs library directory (default: ).

EDITOR

The default editor, if -E is not given.

SHELL

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

/hugs

executable binary.

directory containing support files.

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.

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.

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.