# Introduction to GHC

This is a guide to using the Glasgow Haskell Compiler (GHC): an interactive and batch compilation system for the Haskell 98 language.

GHC has two main components: an interactive Haskell interpreter (also known as GHCi), described in , and a batch compiler, described throughout . In fact, GHC consists of a single program which is just run with different options to provide either the interactive or the batch system.

The batch compiler can be used alongside GHCi: compiled modules can be loaded into an interactive session and used in the same way as interpreted code, and in fact when using GHCi most of the library code will be pre-compiled. This means you get the best of both worlds: fast pre-compiled library code, and fast compile turnaround for the parts of your program being actively developed.

GHC supports numerous language extensions, including concurrency, a foreign function interface, exceptions, type system extensions such as multi-parameter type classes, local universal and existential quantification, functional dependencies, scoped type variables and explicit unboxed types. These are all described in .

GHC has a comprehensive optimiser, so when you want to Really Go For It (and you've got time to spare) GHC can produce pretty fast code. Alternatively, the default option is to compile as fast as possible while not making too much effort to optimise the generated code (although GHC probably isn't what you'd describe as a fast compiler :-).

GHC's profiling system supports “cost centre stacks”: a way of seeing the profile of a Haskell program in a call-graph like structure. See for more details.

GHC comes with a large collection of libraries, with everything from parser combinators to networking. The libraries are described in separate documentation.

## Meta-information: Web sites, mailing lists, etc.

On the World-Wide Web, there are several URLs of likely interest:

- Haskell home page

- GHC home page

- comp.lang.functional FAQ

We run the following mailing lists about Glasgow Haskell. We encourage you to join, as you feel is appropriate.

glasgow-haskell-users:

  This list is for GHC users to chat among themselves. If you have a specific question about GHC, please check the FAQ first.

  list email address:

    glasgow-haskell-users@haskell.org

  subscribe at:

    `http://www.haskell.org/mailman/listinfo/glasgow-haskell-users`.

  admin email address:

    glasgow-haskell-users-admin@haskell.org

  list archives:

    `http://www.haskell.org/pipermail/glasgow-haskell-users/`

glasgow-haskell-bugs:

  Send bug reports for GHC to this address! The sad and lonely people who subscribe to this list will muse upon what's wrong and what you might do about it.

  list email address:

    glasgow-haskell-bugs@haskell.org

  subscribe at:

    `http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs`.

  admin email address:

    glasgow-haskell-bugs-admin@haskell.org

  list archives:

    `http://www.haskell.org/pipermail/glasgow-haskell-bugs/`

cvs-ghc:

  The hardcore GHC developers hang out here. This list also gets commit message from the CVS repository. There are several other similar lists for other parts of the CVS repository (eg. `cvs-hslibs`, `cvs-happy`, `cvs-hdirect` etc.)

  list email address:

    cvs-ghc@haskell.org

  subscribe at:

    `http://www.haskell.org/mailman/listinfo/cvs-ghc`.

  admin email address:

    cvs-ghc-admin@haskell.org

  list archives:

    `http://www.haskell.org/pipermail/cvs-ghc/`

There are several other haskell and GHC-related mailing lists served by `www.haskell.org`. Go to `http://www.haskell.org/mailman/listinfo/` for the full list.

Some Haskell-related discussion also takes place in the Usenet newsgroup `comp.lang.functional`.

## Reporting bugs in GHC

Glasgow Haskell is a changing system so there are sure to be bugs in it.

To report a bug, either:

- Preferred: Create a new bug, and enter your bug report. You can also search the bug database here to make sure your bug hasn't already been reported (if it has, it might still help to add information from your experience to the existing report).

- Bug reports can also be emailed to glasgow-haskell-bugs@haskell.org.

### How do I tell if I should report my bug?

Take a look at the FAQ and , which will give you some guidance as to whether the behaviour you're seeing is really a bug or not.

If it is a bug, then it might have been reported before: try searching on the bug tracker, and failing that, try Google.

If in doubt, just report it.

### What to put in a bug report

The name of the bug-reporting game is: facts, facts, facts. Don't omit them because “Oh, they won't be interested…”

1. What kind of machine are you running on, and exactly what version of the operating system are you using? (on a Unix system, `uname -a` or `cat /etc/motd` will show the desired information.) In the bug tracker, this information can be given in the “Architecture” and “Operating system” fields.

2. What version of GCC are you using? `gcc -v` will tell you.

3. Run the sequence of compiles/runs that caused the offending behaviour, cut-and-paste the whole session into the bug report. We'd prefer to see the whole thing.

4. Add the -v flag when running GHC, so we can see exactly what was run, what versions of things you have, etc.

5. What is the program behaviour that is wrong, in your opinion?

6. If practical, please attach or send enough source files for us to duplicate the problem.

7. If you are a Hero and track down the problem in the compilation-system sources, please send us patches (either `darcs send`, plain patches, or just whole files if you prefer).

## GHC version numbering policy

As of GHC version 6.0, we have adopted the following policy for numbering GHC versions:

Stable Releases

  These are numbered `x.y.z`, where y is even, and z is the patchlevel number (the trailing `.z` can be omitted if z is zero). Patchlevels are bug-fix releases only, and never change the programmer interface to any system-supplied code. However, if you install a new patchlevel over an old one you will need to recompile any code that was compiled against the old libraries.

  The value of `__GLASGOW_HASKELL__` (see ) for a major release `x.y.z` is the integer xyy (if y is a single digit, then a leading zero is added, so for example in version 6.2 of GHC, `__GLASGOW_HASKELL__==602`).

Snapshots/unstable releases

  We may make snapshot releases of the current development sources from time to time, and the current sources are always available via the CVS repository (see the GHC web site for details).

  Snapshot releases are named `x.y.YYYYMMDD` where `YYYYMMDD` is the date of the sources from which the snapshot was built. In theory, you can check out the exact same sources from the CVS repository using this date.

  If y is odd, then this is a snapshot of the CVS HEAD (the main development branch). If y is even, then it is a snapshot of the stable branch between patchlevel releases. For example, `6.3.20040225` would be a snapshot of the HEAD, but `6.2.20040225` would be a snapshot of the `6.2` branch.

  The value of `__GLASGOW_HASKELL__` for a snapshot release is the integer xyy. You should never write any conditional code which tests for this value, however: since interfaces change on a day-to-day basis, and we don't have finer granularity in the values of `__GLASGOW_HASKELL__`, you should only conditionally compile using predicates which test whether `__GLASGOW_HASKELL__` is equal to, later than, or earlier than a given major release.

The version number of your copy of GHC can be found by invoking `ghc` with the `––version` flag (see ).

&relnotes;