Index

Symbols

+r, GHCi options
+RTS, Running a compiled program
+s, GHCi options
+t, Using do-notation at the prompt, GHCi options
-#include, Options affecting the C compiler (if applicable)
--RTS, Running a compiled program
--show-iface, Other options related to interface files
-?, Help and verbosity options, Package management (the ghc-pkg command)
-A
RTS option, RTS options to control the garbage collector
-A<size> option, Sooner: producing a program more quickly
-A<size> RTS option, Faster: producing a program that runs quicker
-auto, Profiling, Compiler options for profiling
-auto-all, Profiling, Compiler options for profiling
-B
RTS option, RTS options for hackers, debuggers, and over-interested souls
-C, Modes of operation, Batch compiler mode
-c, Modes of operation, Batch compiler mode, Options affecting linking
RTS option, RTS options to control the garbage collector
-C<num> RTS option (concurrent, parallel), Scheduling policy for concurrent threads
-C<us> RTS option, RTS options for Concurrent/parallel Haskell
-caf-all, Rules for attributing costs, Compiler options for profiling
-cpp, Batch compiler mode, Options affecting the C pre-processor
-cpp option, Options affecting the C pre-processor
-cpp vs string gaps, CPP and string gaps
-D, Options affecting the C pre-processor
RTS option, RTS options for hackers, debuggers, and over-interested souls
-dcore-lint, Warnings and sanity-checking, Checking for consistency
-dcore-lint option, When the compiler “does the wrong thing”
-ddump options, Dumping out compiler intermediate structures
-ddump-absC, Dumping out compiler intermediate structures
-ddump-asm, Dumping out compiler intermediate structures
-ddump-bcos, Dumping out compiler intermediate structures
-ddump-cpranal, Dumping out compiler intermediate structures
-ddump-cse, Dumping out compiler intermediate structures
-ddump-deriv, Dumping out compiler intermediate structures
-ddump-ds, Dumping out compiler intermediate structures
-ddump-flatC, Dumping out compiler intermediate structures
-ddump-foreign, Dumping out compiler intermediate structures
-ddump-hi, Other options related to interface files
-ddump-hi-diffs, Other options related to interface files
-ddump-inlinings, Dumping out compiler intermediate structures
-ddump-minimal-imports, Other options related to interface files
-ddump-occur-anal, Dumping out compiler intermediate structures
-ddump-parsed, Dumping out compiler intermediate structures
-ddump-realC, Dumping out compiler intermediate structures
-ddump-rn, Dumping out compiler intermediate structures
-ddump-rn-trace, Dumping out compiler intermediate structures
-ddump-rules, Dumping out compiler intermediate structures
-ddump-sat, Dumping out compiler intermediate structures
-ddump-simpl, Dumping out compiler intermediate structures
-ddump-simpl-iterations, Dumping out compiler intermediate structures
-ddump-simpl-stats option, Dumping out compiler intermediate structures
-ddump-spec, Dumping out compiler intermediate structures
-ddump-stg, Dumping out compiler intermediate structures
-ddump-stix, Dumping out compiler intermediate structures
-ddump-stranal, Dumping out compiler intermediate structures
-ddump-tc, Dumping out compiler intermediate structures
-ddump-types, Dumping out compiler intermediate structures
-ddump-usagesp, Dumping out compiler intermediate structures
-ddump-workwrap, Dumping out compiler intermediate structures
-debug, Options affecting linking
-dppr-debug, Dumping out compiler intermediate structures
-dppr-user-length, Dumping out compiler intermediate structures
-dshow-rn-stats, Dumping out compiler intermediate structures
-dshow-unused-imports, Dumping out compiler intermediate structures
-dstg-lint, Checking for consistency
-dverbose-core2core, Dumping out compiler intermediate structures
-dverbose-stg2stg, Dumping out compiler intermediate structures
-dynamic, Options affecting linking
-E, Modes of operation, Batch compiler mode
-E option, Batch compiler mode
-f, Package management (the ghc-pkg command)
RTS option, Running a compiled program
-F, Options affecting a Haskell pre-processor
RTS option, RTS options to control the garbage collector
-f* options (GHC), -f*: platform-independent flags
-fallow-incoherent-instances, Language options, Overlapping instances
-fallow-overlapping-instances, Language options, Overlapping instances
-fallow-undecidable-instances, Language options
-fallow-undecidable-instances option, Undecidable instances
-farrows, Language options
-fasm, Options affecting code generation
-fcontext-stack, Language options
-ferror-spans, Help and verbosity options
-fexcess-precision, -f*: platform-independent flags
-fext-core, Generating and compiling External Core Files
-fffi, Language options, Foreign function interface (FFI)
-ffi, Language options
-fgenerics, Language options
-fglasgow-exts, Language options, Foreign function interface (FFI)
-fignore-asserts, -f*: platform-independent flags, Assertions
-finline-phase, Language options
-fno-* options (GHC), -f*: platform-independent flags
-fno-code, Options affecting code generation
-fno-cse, -f*: platform-independent flags
-fno-full-laziness, -f*: platform-independent flags
-fno-implicit-prelude option, Language options, When the compiler “does the wrong thing”
-fno-monomorphism-restriction, Language options
-fno-state-hack, -f*: platform-independent flags
-fno-strictness, -f*: platform-independent flags
-fno-strictness anti-option, Sooner: producing a program more quickly
-fPIC, Options affecting code generation
-framework, Options affecting linking
-framework-path, Options affecting linking
-fth, Syntax
-funbox-strict-fields, -f*: platform-independent flags
-funfolding-creation-threshold, -f*: platform-independent flags
-funfolding-update-in-place, -f*: platform-independent flags
-funfolding-use-threshold, -f*: platform-independent flags
-funfolding-use-threshold0 option, Smaller: producing a program that is smaller
-fvia-C, Options affecting code generation
-fvia-C option, Sooner: producing a program more quickly
-fwarn-deprecations, Warnings and sanity-checking
-fwarn-duplicate-exports, Warnings and sanity-checking
-fwarn-hi-shadowing, Warnings and sanity-checking
-fwarn-incomplete-patterns, Warnings and sanity-checking
-fwarn-incomplete-record-updates, Warnings and sanity-checking
-fwarn-misc, Warnings and sanity-checking
-fwarn-missing-fields, Warnings and sanity-checking
-fwarn-missing-methods, Warnings and sanity-checking
-fwarn-missing-signatures, Warnings and sanity-checking
-fwarn-missing-signatures option, Faster: producing a program that runs quicker
-fwarn-name-shadowing, Warnings and sanity-checking
-fwarn-orphans, Warnings and sanity-checking
-fwarn-overlapping-patterns, Warnings and sanity-checking
-fwarn-simple-patterns, Warnings and sanity-checking
-fwarn-type-defaults, Warnings and sanity-checking
-fwarn-unused-binds, Warnings and sanity-checking
-fwarn-unused-imports, Warnings and sanity-checking
-fwarn-unused-matches, Warnings and sanity-checking
-G
RTS option, RTS options to control the garbage collector
-G RTS option, Thriftier: producing a program that gobbles less heap space
-H
RTS option, RTS options to control the garbage collector
-h<break-down>, hp2ps––heap profile to PostScript
-hb
RTS option, RTS options for heap profiling
-hc
RTS option, RTS options for heap profiling
-hC
RTS option, RTS options for heap profiling
-hcsuf, Redirecting the compilation output(s)
-hd
RTS option, RTS options for heap profiling
-hi-diffs option, When your program “does the wrong thing”
-hide-package, Using Packages
-hidir, Redirecting the compilation output(s)
-hisuf, Redirecting the compilation output(s)
-hm
RTS option, RTS options for heap profiling
-hr
RTS option, RTS options for heap profiling
-hy
RTS option, RTS options for heap profiling
-I, Options affecting the C pre-processor
-i, RTS options for heap profiling
-idirs , The search path
-ignore-dot-ghci, The .ghci file
-ignore-package, Using Packages
-ignore-scc, Compiler options for profiling
-k
RTS option, RTS options to control the garbage collector
-K
RTS option, RTS options to control the garbage collector
-keep-hc-files, Keeping Intermediate Files
-keep-raw-s-files, Keeping Intermediate Files
-keep-s-files, Keeping Intermediate Files
-keep-tmp-files, Keeping Intermediate Files
-l, Options affecting linking
-L, Options affecting linking
-m
RTS option, RTS options to control the garbage collector
-M
RTS option, RTS options to control the garbage collector
-m* options, Platform-specific Flags
-M<size> option, Sooner: producing a program more quickly
-M<size> RTS option, Faster: producing a program that runs quicker
-main-is, Options affecting linking
-monly-N-regs option (iX86 only), Platform-specific Flags
-mv8 option (SPARC only), Platform-specific Flags
-no-hs-main, Options affecting linking, Using your own main()
-no-recomp, The recompilation checker
-no-user-package-conf, Package Databases
-O, FAQ and Things To Watch Out For, Assertions
-o, Redirecting the compilation output(s)
-O option, -O*: convenient “packages” of optimisation flags.
-O* not specified, -O*: convenient “packages” of optimisation flags.
-O0, -O*: convenient “packages” of optimisation flags.
-O1 option, -O*: convenient “packages” of optimisation flags.
-O2 option, -O*: convenient “packages” of optimisation flags.
-odir, Redirecting the compilation output(s)
-Ofile <file> option, -O*: convenient “packages” of optimisation flags.
-ohi, Redirecting the compilation output(s)
-opta, Forcing options to a particular phase
-optc, Forcing options to a particular phase
-optdep, Forcing options to a particular phase
-optdll, Forcing options to a particular phase
-optF, Forcing options to a particular phase
-optL, Forcing options to a particular phase
-optl, Forcing options to a particular phase
-optP, Forcing options to a particular phase
-osuf, Redirecting the compilation output(s)
-p, Time and allocation profiling
RTS option, Profiling
-P, Cost centres and cost-centre stacks, Time and allocation profiling
-package, Using Packages , Options affecting linking
-package-conf, Package Databases, Package management (the ghc-pkg command)
-parallel option, Using parallel Haskell
-pgma, Replacing the program for one or more phases, Replacing phases
-pgmc, Replacing the program for one or more phases, Replacing phases
-pgmdep, Replacing the program for one or more phases, Replacing phases
-pgmdll, Replacing the program for one or more phases, Replacing phases
-pgmF, Replacing the program for one or more phases, Replacing phases
-pgmL, Replacing the program for one or more phases, Replacing phases
-pgml, Replacing the program for one or more phases, Replacing phases
-pgmP, Replacing the program for one or more phases, Replacing phases
-prof, Profiling, Compiler options for profiling
-px, Time and allocation profiling, Graphical time/allocation profile
-q RTS option, RTS options for Concurrent/parallel Haskell
-qe<num> RTS option (parallel), RTS options for Concurrent/parallel Haskell
-qg<num> RTS option (parallel), RTS options for Concurrent/parallel Haskell
-qh<num> RTS option (parallel), RTS options for Concurrent/parallel Haskell
-qP RTS option (concurrent, parallel), parallelism profiles
-qp<N> RTS option, RTS options for Concurrent/parallel Haskell
-qQ<num> RTS option (parallel), RTS options for Concurrent/parallel Haskell
-qt<num> RTS option, RTS options for Concurrent/parallel Haskell
-r
RTS option, RTS options for hackers, debuggers, and over-interested souls
-r RTS option, Using “ticky-ticky” profiling (for implementors)
-read-dot-ghci, The .ghci file
-recomp, The recompilation checker
-RTS, Running a compiled program
-S, Modes of operation, Batch compiler mode
RTS option, RTS options to control the garbage collector
-s
RTS option, RTS options to control the garbage collector
-S RTS option, Faster: producing a program that runs quicker
-split-objs, Options affecting linking
-Sstderr RTS option, Other useful info about running parallel programs, Thriftier: producing a program that gobbles less heap space
-static, Options affecting linking
-t
RTS option, RTS options to control the garbage collector
-t <num> RTS option (concurrent, parallel), Scheduling policy for concurrent threads
-threaded, Options affecting linking
-ticky, RTS options for hackers, debuggers, and over-interested souls
-tmpdir, Redirecting temporary files
-tmpdir <dir> option, Redirecting temporary files
-U, Options affecting the C pre-processor
-unreg, Unregisterised compilation
-v, Help and verbosity options, Sooner: producing a program more quickly
-V, Help and verbosity options, Package management (the ghc-pkg command)
-w, Warnings and sanity-checking
-W option, Warnings and sanity-checking
-Wall, Warnings and sanity-checking
-Werror, Warnings and sanity-checking
-xc
RTS option, RTS options for hackers, debuggers, and over-interested souls, Time and allocation profiling
-xt
RTS option, RTS options for heap profiling
-Z
RTS option, RTS options for hackers, debuggers, and over-interested souls
.ghci
file, The .ghci file
.hc files, saving, Keeping Intermediate Files
.hi files, Output files
.o files, Output files
.s files, saving, Keeping Intermediate Files
:!, GHCi commands
:?, GHCi commands
:add, GHCi commands
:browse, GHCi commands
:cd, GHCi commands
:def, GHCi commands
:help, GHCi commands
:info, GHCi commands
:kind, GHCi commands
:load, Loading source files, GHCi commands
:module, GHCi commands
:quit, GHCi commands
:reload, Making changes and recompilation, GHCi commands
:set, GHCi commands, The :set command
:show bindings, GHCi commands
:show modules, GHCi commands
:type, GHCi commands
:undef, GHCi commands
:unset, GHCi commands
__CONCURRENT_HASKELL__, Options affecting the C pre-processor
__GLASGOW_HASKELL__, GHC version numbering policy, Options affecting the C pre-processor
__HASKELL1__, Options affecting the C pre-processor
__HASKELL98__, Options affecting the C pre-processor
__HASKELL__=98, Options affecting the C pre-processor
__PARALLEL_HASKELL__, Options affecting the C pre-processor
––force , Package management (the ghc-pkg command)
––help, Help and verbosity options
––interactive, Invoking GHCi
––make, Modes of operation, Using ghc ––make
––mk-dll, Creating a DLL
––numeric-version, Help and verbosity options
––print-libdir, Help and verbosity options
––user, Package management (the ghc-pkg command)
––version, Help and verbosity options

B

binary distribution, layout, GHC binary distributions
binary installations, Installing GHC
binds, unused, Warnings and sanity-checking
bug reports
contents, What to put in a bug report
bugs
reporting, Reporting bugs in GHC
bundles of binary stuff, GHC binary distributions
bundles, binary, What bundles there are
bundles, gransim, What bundles there are
bundles, parallel, What bundles there are
bundles, profiling, What bundles there are
bundles, ticky-ticky, What bundles there are

C

C calls, function headers, Using function headers
C compiler options, Options affecting the C compiler (if applicable)
C pre-processor options, Options affecting the C pre-processor
CAFs
in GHCi, GHCi options
category
package specification, InstalledPackageInfo: a package specification
Char
size of, GHC's interpretation of undefined behaviour in Haskell 98
command-line
arguments, command-line arguments
compacting garbage collection, RTS options to control the garbage collector
compiled code
in GHCi, Loading compiled code
compiler problems, When the compiler “does the wrong thing”
compiling faster, Sooner: producing a program more quickly
Concurrent Haskell, Concurrent and Parallel Haskell
Concurrent Haskell—RTS options, RTS options for Concurrent/parallel Haskell
Concurrent Haskell—use, Using Concurrent Haskell
Concurrent scheduling, Scheduling policy for concurrent threads
configure, Installing
consistency checks, Checking for consistency
Constant Applicative Form (see CAFs)
constructor fields, strict, -f*: platform-independent flags
copyright
package specification, InstalledPackageInfo: a package specification
CORE pragma, CORE pragma
Core syntax, how to read, How to read Core syntax (from some -ddump flags)
core, annotation, CORE pragma
cost centres
automatically inserting, Compiler options for profiling
cost-centre profiling, Profiling
cpp, pre-processing with, Options affecting the C pre-processor
Creating a Win32 DLL, Creating a DLL
CTAGS for Haskell, Ctags and Etags for Haskell: hasktags

D

debugging options (for GHC), Debugging the compiler
defaulting mechanism, warning, Warnings and sanity-checking
dependencies in Makefiles, Dependency generation
dependency-generation mode, Modes of operation
depends
package specification, InstalledPackageInfo: a package specification
DEPRECATED, DEPRECATED pragma
deprecations, Warnings and sanity-checking
description
package specification, InstalledPackageInfo: a package specification
directories, installation, Installing
directory layout (binary distributions), GHC binary distributions
do-notation
in GHCi, Using do-notation at the prompt
dumping GHC intermediates, Dumping out compiler intermediate structures
duplicate exports, warning, Warnings and sanity-checking
dynamic
options, Setting GHC command-line options in GHCi, Static vs. Dynamic options

E

environment variable
for setting RTS options, Setting global RTS options
eval mode, Modes of operation
export lists, duplicates, Warnings and sanity-checking
exposed
package specification, InstalledPackageInfo: a package specification
exposed-modules
package specification, InstalledPackageInfo: a package specification
extensions
options controlling, Language options
extensions, GHC, GHC Language Features
extra-cc-opts
package specification, InstalledPackageInfo: a package specification
extra-frameworks
package specification, InstalledPackageInfo: a package specification
extra-hugs-opts
package specification, InstalledPackageInfo: a package specification
extra-ld-opts
package specification, InstalledPackageInfo: a package specification
extra-libs
package specification, InstalledPackageInfo: a package specification

F

faster compiling, Sooner: producing a program more quickly
faster programs, how to produce, Faster: producing a program that runs quicker
FFI
GHCi support, Using GHCi
fields, missing, Warnings and sanity-checking
file suffixes for GHC, Meaningful file suffixes
filenames
of modules, Modules vs. filenames
finding interface files, The search path
floating-point exceptions, GHC's interpretation of undefined behaviour in Haskell 98
forcing GHC-phase options, Forcing options to a particular phase
foreign export
with GHC, Using foreign export and foreign import ccall "wrapper" with GHC
Foreign Function Interface
GHCi support, Using GHCi
foreign import ccall "wrapper"
with GHC, Using foreign import ccall "wrapper" with GHC
framework-dirs
package specification, InstalledPackageInfo: a package specification
fromInteger, GHC's interpretation of undefined behaviour in Haskell 98
fromIntegral, GHC's interpretation of undefined behaviour in Haskell 98

I

import-dirs
package specification, InstalledPackageInfo: a package specification
importing, hi-boot files, How to compile mutually recursive modules
imports, unused, Warnings and sanity-checking
improvement, code, Optimisation (code improvement)
in-place installation, Installing
include-dirs
package specification, InstalledPackageInfo: a package specification
include-file options, Options affecting the C compiler (if applicable)
includes
package specification, InstalledPackageInfo: a package specification
incomplete patterns, warning, Warnings and sanity-checking
incomplete record updates, warning, Warnings and sanity-checking
INLINE, INLINE pragma
INLINE pragma, INLINE pragma
inlining, controlling, -f*: platform-independent flags
installation directories, Installing
installation, of binaries, Installing GHC
installing in-place, Installing
Int
size of, GHC's interpretation of undefined behaviour in Haskell 98
interactive (see GHCi)
interactive mode, Modes of operation
Interface files, GHC binary distributions
interface files, Output files
interface files, finding them, The search path
interface files, options, Other options related to interface files
intermediate code generation, Generating and compiling External Core Files
intermediate files, saving, Keeping Intermediate Files
intermediate passes, output, Dumping out compiler intermediate structures
interpreter (see GHCi)
invoking
GHCi, Invoking GHCi
it, The it variable

L

language
option, Language options
language, GHC, GHC Language Features
ld options, Options affecting linking
lhs suffix, Meaningful file suffixes
libdir, Help and verbosity options
libraries
with GHCi, Extra libraries
library-dirs
package specification, InstalledPackageInfo: a package specification
license-file
package specification, InstalledPackageInfo: a package specification
LINE
pragma, LINE pragma
link, installed as ghc, Installing
linker options, Options affecting linking
linking Haskell libraries with foreign code, Options affecting linking
lint, Checking for consistency
list comprehensions
parallel, Parallel List Comprehensions

M

machine-specific options, Platform-specific Flags
mailing lists, Glasgow Haskell, Meta-information: Web sites, mailing lists, etc.
maintainer
package specification, InstalledPackageInfo: a package specification
make, Using make
make and recompilation, Filenames and separate compilation
make mode, Modes of operation
Makefile dependencies, Dependency generation
Makefiles
avoiding, Using ghc ––make
MallocFailHook, “Hooks” to change RTS behaviour
matches, unused, Warnings and sanity-checking
memory, using less heap, Thriftier: producing a program that gobbles less heap space
methods, missing, Warnings and sanity-checking
missing fields, warning, Warnings and sanity-checking
missing methods, warning, Warnings and sanity-checking
module system, recursion, How to compile mutually recursive modules
modules
and filenames, Modules vs. filenames

P

package-url
package specification, InstalledPackageInfo: a package specification
packages, Packages
building, Building a package from Haskell source
management, Package management (the ghc-pkg command)
using, Using Packages
with GHCi, Packages
parallel bundles, What bundles there are
Parallel Haskell, Concurrent and Parallel Haskell
Parallel Haskell—features, Features specific to Parallel Haskell
parallel Haskell—PVM use, Dummy's guide to using PVM
parallel Haskell—RTS options, RTS options for Concurrent/parallel Haskell
parallel Haskell—use, Using parallel Haskell
Parallel interface, The Parallel interface (recommended)
parallel list comprehensions, Parallel List Comprehensions
Parallel scheduling, Scheduling policy for parallel threads
parallelism primitives, Underlying functions and primitives
parallelism profiles, parallelism profiles
parser generator for Haskell, “Yacc for Haskell”: happy
Pattern guards (Glasgow extension), Pattern guards
patterns, incomplete, Warnings and sanity-checking
patterns, overlapping, Warnings and sanity-checking
phases, changing, Replacing the program for one or more phases
platform-specific options, Platform-specific Flags
postscript, from heap profiles, hp2ps––heap profile to PostScript
pragma, Pragmas
LINE, LINE pragma
OPTIONS_GHC, OPTIONS_GHC pragma
pragma, CORE, CORE pragma
pragma, RULES, Rewrite rules
pragma, SPECIALIZE, SPECIALIZE pragma
pre-processing: cpp, Options affecting the C pre-processor
pre-processing: custom, Options affecting a Haskell pre-processor
Pre-processor options, Options affecting a Haskell pre-processor
primitives for parallelism, Underlying functions and primitives
problems, What to do when something goes wrong
problems running your program, When your program “does the wrong thing”
problems with the compiler, When the compiler “does the wrong thing”
profiles, parallelism, parallelism profiles
profiling, Profiling
options, Compiler options for profiling
ticky ticky, RTS options for hackers, debuggers, and over-interested souls
profiling bundles, What bundles there are
profiling, ticky-ticky, Using “ticky-ticky” profiling (for implementors)
prompt
GHCi, Introduction to GHCi
pvm command, Dummy's guide to using PVM
PVM, how to use, Dummy's guide to using PVM

S

sanity-checking options, Warnings and sanity-checking
Scheduling—concurrent, Scheduling policy for concurrent threads
Scheduling—parallel, Scheduling policy for parallel threads
search path, The search path
segmentation fault, When your program “does the wrong thing”
separate compilation, Using ghc ––make, Filenames and separate compilation
shadowing
interface files, Warnings and sanity-checking
shadowing, warning, Warnings and sanity-checking
shell commands
in GHCi, GHCi commands
Show class, Type defaulting in GHCi
smaller programs, how to produce, Smaller: producing a program that is smaller
source-file options, command line options in source files
space-leaks, avoiding, Thriftier: producing a program that gobbles less heap space
SPECIALIZE pragma, Faster: producing a program that runs quicker, SPECIALIZE pragma, SPECIALIZE instance pragma
specifying your own main function, Options affecting linking
stability
package specification, InstalledPackageInfo: a package specification
stack, maximum size, RTS options to control the garbage collector
stack, minimum size, RTS options to control the garbage collector
StackOverflowHook, “Hooks” to change RTS behaviour
startup
files, GHCi, The .ghci file
statements
in GHCi, Using do-notation at the prompt
static
options, Setting GHC command-line options in GHCi, Static vs. Dynamic options
strict constructor fields, -f*: platform-independent flags
string gaps vs -cpp, CPP and string gaps
structure, command-line, command-line arguments
suffixes, file, Meaningful file suffixes

U

Unboxed types (Glasgow extension), Unboxed types
unfolding, controlling, -f*: platform-independent flags
UNPACK, UNPACK pragma
unregisterised compilation, Unregisterised compilation
unused binds, warning, Warnings and sanity-checking
unused imports, warning, Warnings and sanity-checking
unused matches, warning, Warnings and sanity-checking
using GHC, Using GHC
utilities, Haskell, Other Haskell utility programs

V

verbosity options, Help and verbosity options
version
package specification, InstalledPackageInfo: a package specification
version, of ghc, GHC version numbering policy
visualisation tools, parallelism profiles