GHCi commands all begin with
:’ and consist of a single command
name followed by zero or more parameters. The command name may be
abbreviated, with ambiguities being resolved in favour of the more
commonly used commands.
module(s) to the
current target set, and perform a
Displays the identifiers defined by the module
module, which must be either
loaded into GHCi or be a member of a package. If the
* symbol is placed before the module
name, then all the identifiers defined
module are shown; otherwise
the list is limited to the exports of
*-form is only available for modules
which are interpreted; for compiled modules (including
modules from packages) only the non-
:browse is available.
Changes the current working directory to
˜’ symbol at the
dir will be replaced
by the contents of the environment variable
NOTE: changing directories causes all currently loaded modules to be unloaded. This is because the search path is usually expressed using relative directories, and changing the search path in the middle of a session is not supported.
expr defines a new GHCi command
implemented by the Haskell expression
expr, which must have type
String -> IO String. When
: is typed at the
prompt, GHCi will run the expression
(, take the
String, and feed it back into
GHCi as a new sequence of commands. Separate commands in
the result must be separated by
That's all a little confusing, so here's a few examples. To start with, here's a new GHCi command which doesn't take any arguments or produce any results, it just outputs the current date & time:
Prelude> let date _ = Time.getClockTime >>= print >> return "" Prelude> :def date date Prelude> :date Fri Mar 23 15:16:40 GMT 2001
Here's an example of a command that takes an argument.
It's a re-implementation of
Prelude> let mycd d = Directory.setCurrentDirectory d >> return "" Prelude> :def mycd mycd Prelude> :mycd ..
Or I could define a simple way to invoke
ghc ––make Main” in the
Prelude> :def make (\_ -> return ":! ghc ––make Main")
We can define a command that reads GHCi input from a file. This might be useful for creating a set of bindings that we want to repeatedly load into the GHCi session:
Prelude> :def . readFile Prelude> :. cmds.ghci
Notice that we named the command
:., by analogy with the
.’ Unix shell command that
does the same thing.
Opens an editor to edit the file
file, or the most recently loaded
file is omitted. The
editor to invoke is taken from the
environment variable, or a default editor on your system if
EDITOR is not set. You can change the
Displays a list of the available commands.
Displays information about the given name(s). For
name is a class, then
the class methods and their types will be printed; if
name is a type constructor, then
its definition will be printed; if
name is a function, then its type
will be printed. If
been loaded from a source file, then GHCi will also display
the location of its definition in the source.
Recursively loads the specified
modules, and all the modules they
depend on. Here, each
must be a module name or filename, but may not be the name
of a module in a package.
All previously loaded modules, except package modules,
are forgotten. The new set of modules is known as the
target set. Note that
:load can be used without any arguments
to unload all the currently loaded modules and
:load command, the current
context is set to:
module, if it was loaded
the most recently successfully loaded module, if
any other modules were loaded as a result of the current
When a program is compiled and executed, it can use the
getArgs function to access the
However, we cannot simply pass the arguments to the
main function while we are testing in ghci,
main function doesn't take its
Instead, we can use the
This runs whatever
main is in scope, with
any arguments being treated the same as command-line arguments,
Prelude> let main = System.Environment.getArgs >>= print Prelude> :main foo bar ["foo","bar"]
:module [+|-] [*]
Sets or modifies the current context for statements typed at the prompt. See Section 3.4.3, “What's really in scope at the prompt?” for more details.
Quits GHCi. You can also quit by typing a control-D at the prompt.
Attempts to reload the current target set (see
:load) if any of the modules in the set,
or any dependent module, has changed. Note that this may
entail loading new modules, or dropping modules which are no
longer indirectly required by the target.
Sets various options. See Section 3.7, “The
for a list of available options. The
:set command by itself shows which
options are currently set.
Sets the command used by
Sets the string to be used as the prompt in GHCi.
prompt, the sequence
%s is replaced by the names of the
modules currently in scope, and
Show the bindings made at the prompt and their types.
Show the list of modules currently load.
Generates a “tags” file for Vi-style editors
:ctags) or Emacs-style editors (
no filename is specified, the defaulit
used, respectively. Tags for all the functions, constructors and
types in the currently loaded modules are created. All modules must
be interpreted for these commands to work.
Infers and prints the type of
expression, including explicit
forall quantifiers for polymorphic types. The monomorphism
restriction is not applied to the
expression during type inference.
Infers and prints the kind of
type. The latter can be an arbitrary
type expression, including a partial application of a type constructor,
Undefines the user-defined command
Unsets certain options. See Section 3.7, “The
for a list of available options.
Executes the shell command