Add 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
in 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-*
form of :browse is available.
- :cd dir
Changes the current working directory to
‘˜’ symbol at the
beginning of dir will be replaced
by the contents of the environment variable
- :def name expr
The command :def
expr defines a new GHCi command
implemented by the Haskell expression
expr, which must have type
String -> IO String. When
args is typed at the
prompt, GHCi will run the expression
args), take the
resulting 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
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 :cd:
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")
- :help, :?
Displays a list of the available commands.
- :info name
Displays information about the given name(s). For
example, if 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 name has
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 module
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
After a :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
- :module [+|-] [*]mod1 ... [*]modn
Sets or modifies the current context for statements
typed at the prompt. See Section 3.4.1 for
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.
- :set [option...]
Sets various options. See Section 3.7
for a list of available options. The
:set command by itself shows which
options are currently set.
- :set args
Sets the list of arguments which are returned when the
program calls System.getArgs.
- :set prog
Sets the string to be returned when the program calls
- :show bindings
Show the bindings made at the prompt and their
- :show modules
Show the list of modules currently load.
- :type expression
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.
- :undef name
Undefines the user-defined command
name (see :def
- :unset option...
Unsets certain options. See Section 3.7
for a list of available options.
- :! command...
Executes the shell command