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:

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 5.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 5.6.3, “The search path”).

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

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:

Thus, a common invocation would be:

ghc -c Foo.hs

to compile the Haskell source file Foo.hs to an object file Foo.o.

Note: What the Haskell compiler proper produces depends on whether a native-code generator is used (producing assembly language) or not (producing C). See Section 5.10.6, “Options affecting code generation” for more details.

Note: C pre-processing is optional, the -cpp flag turns it on. See Section 5.10.3, “Options affecting the C pre-processor” for more details.

Note: The option -E runs just the pre-processing passes of the compiler, dumping the result in a file.