4.4. Modes of operation

GHC's behaviour is firstly controlled by a mode flag. Only
one of these flags may be given, but it does not necessarily need
to be the first option on the command-line. The available modes
are:

ghc --interactive

Interactive mode, which is also available as
ghci. Interactive mode is described in
more detail in Chapter 2, Using GHCi.

ghc --make

In this mode, GHC will build a multi-module Haskell
program automatically, figuring out dependencies for itself.
If you have a straightforward Haskell program, this is
likely to be much easier, and faster, than using
make. Make mode is described in Section 4.4.1, “Using ghc––make”.

ghc -eexpr

Expression-evaluation mode. This is very similar to
interactive mode, except that there is a single expression
to evaluate (expr) which is given
on the command line. See Section 4.4.2, “Expression evaluation mode” for
more details.

ghc -Eghc -cghc -Sghc -c

This is the traditional batch-compiler mode, in which
GHC can compile source files one at a time, or link objects
together into an executable. This mode also applies if
there is no other mode flag specified on the command line,
in which case it means that the specified files should be
compiled and then linked to form a program. See Section 4.4.3, “Batch compiler mode”.

Cause GHC to spew a long usage message to standard
output and then exit.

ghc --show-iface file

Read the interface in
file and dump it as text to
stdout. For example ghc --show-iface M.hi.

ghc --supported-languages

Print the supported language extensions.

ghc --info

Print information about the compiler.

ghc --versionghc -V

Print a one-line string including GHC's version number.

ghc --numeric-version

Print GHC's numeric version number only.

ghc --print-libdir

Print the path to GHC's library directory. This is
the top of the directory tree containing GHC's libraries,
interfaces, and include files (usually something like
/usr/local/lib/ghc-5.04 on Unix). This
is the value of
$libdir
in the package configuration file
(see Section 4.8, “
Packages
”).

4.4.1. Using ghc––make

When given the ––make option,
GHC will build a multi-module Haskell program by following
dependencies from one or more root modules (usually just
Main). For example, if your
Main module is in a file called
Main.hs, you could compile and link the
program like this:

ghc ––make Main.hs

The command line may contain any number of source file
names or module names; GHC will figure out all the modules in
the program by following the imports from these initial modules.
It will then attempt to compile each module which is out of
date, and finally, if there is a Main module,
the program will also be linked into an executable.

The main advantages to using ghc
––make over traditional
Makefiles are:

GHC doesn't have to be restarted for each compilation,
which means it can cache information between compilations.
Compiling a multi-module program with ghc
––make can be up to twice as fast as
running ghc individually on each source
file.

You don't have to write a Makefile.

GHC re-calculates the dependencies each time it is
invoked, so the dependencies never get out of sync with the
source.

Any of the command-line options described in the rest of
this chapter can be used with
––make, but note that any options
you give on the command line will apply to all the source files
compiled, so if you want any options to apply to a single source
file only, you'll need to use an OPTIONS_GHC
pragma (see Section 4.1.2, “Command line options in source files”).

If the program needs to be linked with additional objects
(say, some auxiliary C code), then the object files can be
given on the command line and GHC will include them when linking
the executable.

Note that GHC can only follow dependencies if it has the
source file available, so if your program includes a module for
which there is no source file, even if you have an object and an
interface file for the module, then GHC will complain. The
exception to this rule is for package modules, which may or may
not have source files.

The source files for the program don't all need to be in
the same directory; the -i option can be used
to add directories to the search path (see Section 4.6.3, “The search path”).

4.4.2. Expression evaluation mode

This mode is very similar to interactive mode, except that
there is a single expression to evaluate which is specified on
the command line as an argument to the -e
option:

ghc -e expr

Haskell source files may be named on the command line, and
they will be loaded exactly as in interactive mode. The
expression is evaluated in the context of the loaded
modules.

For example, to load and run a Haskell program containing
a module Main, we might say

ghc -e Main.main Main.hs

or we can just use this mode to evaluate expressions in
the context of the Prelude:

$ ghc -e "interact (unlines.map reverse.lines)"
hello
olleh

4.4.3. Batch compiler mode

In batch mode, GHC will compile one or more source files
given on the command line.

The first phase to run is determined by each input-file
suffix, and the last phase is determined by a flag. If no
relevant flag is present, then go all the way through to linking.
This table summarises: