Symbols

+m, GHCi options

+r, GHCi options

+RTS, Setting RTS options on the command line

+s, GHCi options

+t, Using do-notation at the prompt, GHCi options

--force , Package management (the ghc-pkg command)

--global, Package management (the ghc-pkg command)

--help, Modes of operation, Package management (the ghc-pkg command)

--info, Modes of operation

--install-signal-handlers

RTS option, Miscellaneous RTS options

--interactive, Invoking GHCi

--ipid , Package management (the ghc-pkg command)

--machine-readable

RTS option, RTS options to control the garbage collector

--make, Modes of operation, Using ghc --make

--numeric-version, Modes of operation

--print-libdir, Modes of operation

--RTS, Setting RTS options on the command line

--show-iface, Modes of operation, Other options related to interface files

--show-options, Modes of operation

--supported-extensions, Modes of operation

--user, Package management (the ghc-pkg command)

--verbose

ghc-pkg option, Package management (the ghc-pkg command)

--version, Modes of operation, Package management (the ghc-pkg command)

-?, Package management (the ghc-pkg command)

RTS option, Setting RTS options on the command line

-A

RTS option, RTS options to control the garbage collector

-A<size> RTS option, Sooner: producing a program more quickly , Faster: producing a program that runs quicker

-auto-all, 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

-clear-package-db, Package Databases

-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

-Cs

RTS option, Using Concurrent Haskell

-D, Options affecting the C pre-processor

RTS option, RTS options for hackers, debuggers, and over-interested souls

-dcmm-lint, Checking for consistency

-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-asm, Dumping out compiler intermediate structures

-ddump-bcos, Dumping out compiler intermediate structures

-ddump-cmm, Dumping out compiler intermediate structures

-ddump-core-stats, 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-hi-diffs option, When your program “does the wrong thing”

-ddump-if-trace, Dumping out compiler intermediate structures

-ddump-inlinings, Dumping out compiler intermediate structures

-ddump-llvm, Dumping out compiler intermediate structures

-ddump-minimal-imports, Other options related to interface files

-ddump-occur-anal, Dumping out compiler intermediate structures

-ddump-opt-cmm, Dumping out compiler intermediate structures

-ddump-parsed, Dumping out compiler intermediate structures

-ddump-prep, Dumping out compiler intermediate structures

-ddump-rn, Dumping out compiler intermediate structures

-ddump-rn-trace, Dumping out compiler intermediate structures

-ddump-rule-firings, Dumping out compiler intermediate structures

-ddump-rule-rewrites, Dumping out compiler intermediate structures

-ddump-rules, 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-splices, Dumping out compiler intermediate structures

-ddump-stg, Dumping out compiler intermediate structures

-ddump-stranal, Dumping out compiler intermediate structures

-ddump-strsigs, Dumping out compiler intermediate structures

-ddump-tc, Dumping out compiler intermediate structures

-ddump-tc-trace, Dumping out compiler intermediate structures

-ddump-tv-trace, Dumping out compiler intermediate structures

-ddump-types, Dumping out compiler intermediate structures

-ddump-vect, Dumping out compiler intermediate structures

-ddump-worker-wrapper, Dumping out compiler intermediate structures

-debug, Options affecting linking

-dfaststring-stats, Dumping out compiler intermediate structures

-distrust, Using Packages

-distrust-all, Using Packages

-dno-debug-output, Formatting dumps

-dppr-case-as-let, Formatting dumps

-dppr-colsNNN, Formatting dumps

-dppr-debug, Dumping out compiler intermediate structures

-dppr-user-length, Formatting dumps

-dshow-passes, Dumping out compiler intermediate structures

-dshow-rn-stats, Dumping out compiler intermediate structures

-dstg-lint, Checking for consistency

-dsuppress-all, Suppressing unwanted information

-dsuppress-coercions, Suppressing unwanted information

-dsuppress-idinfo, Suppressing unwanted information

-dsuppress-module-prefixes, Suppressing unwanted information

-dsuppress-type-applications, Suppressing unwanted information

-dsuppress-type-signatures, Suppressing unwanted information

-dsuppress-uniques, Suppressing unwanted information

-dumpdir, Redirecting the compilation output(s)

-dverbose-core2core, Dumping out compiler intermediate structures

-dverbose-stg2stg, Dumping out compiler intermediate structures

-dylib-install-name, Options affecting linking

-dynamic, Options affecting linking

-dynload, Options affecting linking

-E, Modes of operation, Batch compiler mode

-E option, Batch compiler mode

-eventlog, Options affecting linking

-f, Package management (the ghc-pkg command)

-F, Options affecting a Haskell pre-processor

RTS option, RTS options to control the garbage collector

-f* options (GHC), -f*: platform-independent flags

-fasm, Options affecting code generation

-fbyte-code, Options affecting code generation

-fcall-arity, -f*: platform-independent flags

-fcmm-sink, -f*: platform-independent flags

-fcpr-Off, -f*: platform-independent flags

-fcse, -f*: platform-independent flags

-fdefer-type-errors, Warnings and sanity-checking

-fdefer-typed-holes, Warnings and sanity-checking

-fdmd-tx-dict-sel, -f*: platform-independent flags

-feager-blackholing, Compile-time options for SMP parallelism

-felim-common-blocks, -f*: platform-independent flags

-ferror-spans, Verbosity options

-fexcess-precision, -f*: platform-independent flags, Bugs in GHC

-fforce-recomp, The recompilation checker

-ffull-laziness, -f*: platform-independent flags

-ffun-to-thunk, -f*: platform-independent flags

-fghci-hist-size, Tracing and history

-fglasgow-exts, Language options

-fhelpful-errors, Warnings and sanity-checking

-fhpc, Options for instrumenting code for coverage

-fignore-asserts, -f*: platform-independent flags, Assertions

-fignore-interface-pragmas, -f*: platform-independent flags

-flate-dmd-anal, -f*: platform-independent flags

-fliberate-case, -f*: platform-independent flags

-fliberate-case-threshold, -f*: platform-independent flags

-fllvm, Options affecting code generation

-floopification, -f*: platform-independent flags

-fmax-inline-alloc-size, -f*: platform-independent flags

-fmax-inline-memcpy-insn, -f*: platform-independent flags

-fmax-inline-memset-insns, -f*: platform-independent flags

-fmax-relevant-bindings, -f*: platform-independent flags

-fmax-simplifier-iterations, -f*: platform-independent flags

-fmax-worker-args, -f*: platform-independent flags

-fno-* options (GHC), -f*: platform-independent flags

-fno-code, Options affecting code generation

-fno-embed-manifest, Options affecting linking

-fno-force-recomp, The recompilation checker

-fno-gen-manifest, Options affecting linking

-fno-implicit-import-qualified, Qualified names

-fno-opt-coercion, -f*: platform-independent flags

-fno-pre-inlining, -f*: platform-independent flags

-fno-print-bind-result, Using do-notation at the prompt

-fno-prof-cafs, Compiler options for profiling

-fno-prof-count-entries, Compiler options for profiling

-fno-shared-implib, Options affecting linking

-fno-state-hack, -f*: platform-independent flags

-fobject-code, Options affecting code generation

-fomit-interface-pragmas, -f*: platform-independent flags

-fomit-yields, -f*: platform-independent flags

-fpackage-trust, Trust check (-fpackage-trust enabled), Safe Haskell Flag Summary

-fpedantic-bottoms, -f*: platform-independent flags

-fPIC, Options affecting code generation

-fprint-bind-result, Using do-notation at the prompt

-fprint-explicit-foralls, Verbosity options

-fprint-explicit-kinds, Verbosity options

-fprof-auto, Profiling, Compiler options for profiling

-fprof-auto-calls, Compiler options for profiling

-fprof-auto-top, Compiler options for profiling

-fprof-cafs, Rules for attributing costs, Compiler options for profiling

-framework, Options affecting linking

-framework-path, Options affecting linking

-fregs-graph, -f*: platform-independent flags

-fregs-iterative, -f*: platform-independent flags

-fsimpl-tick-factor, -f*: platform-independent flags

-fsimplifier-phases, -f*: platform-independent flags

-fspec-constr, -f*: platform-independent flags

-fspec-constr-count, -f*: platform-independent flags

-fspec-constr-threshold, -f*: platform-independent flags

-fspecialise, -f*: platform-independent flags

-fstatic-argument-transformation, -f*: platform-independent flags

-fstrictness-before, -f*: platform-independent flags

-funbox-small-strict-fields, -f*: platform-independent flags

-funbox-strict-fields, -f*: platform-independent flags

-funfolding-creation-threshold, -f*: platform-independent flags

-funfolding-dict-discount, -f*: platform-independent flags

-funfolding-fun-discount, -f*: platform-independent flags

-funfolding-keeness-factor, -f*: platform-independent flags

-funfolding-use-threshold, -f*: platform-independent flags

-funfolding-use-threshold0 option, Smaller: producing a program that is smaller

-fvia-C, C Code Generator (-fvia-C)

-fwarn-amp, Warnings and sanity-checking

-fwarn-auto-orphans, Warnings and sanity-checking

-fwarn-context-quantification, Warnings and sanity-checking

-fwarn-deprecated-flags, Warnings and sanity-checking

-fwarn-dodgy-exports, Warnings and sanity-checking

-fwarn-dodgy-foreign-imports, Warnings and sanity-checking

-fwarn-dodgy-imports, Warnings and sanity-checking

-fwarn-duplicate-constraints, Warnings and sanity-checking

-fwarn-duplicate-exports, Warnings and sanity-checking

-fwarn-empty-enumerations, Warnings and sanity-checking

-fwarn-hi-shadowing, Warnings and sanity-checking

-fwarn-identities, Warnings and sanity-checking

-fwarn-implicit-prelude, Warnings and sanity-checking

-fwarn-import-lists, Warnings and sanity-checking

-fwarn-incomplete-patterns, Warnings and sanity-checking

-fwarn-incomplete-record-updates, Warnings and sanity-checking

-fwarn-incomplete-uni-patterns, Warnings and sanity-checking

-fwarn-inline-rule-shadowing, Warnings and sanity-checking

-fwarn-lazy-unlifted-bindings, Warnings and sanity-checking

-fwarn-missing-exported-sigs, Warnings and sanity-checking

-fwarn-missing-fields, Warnings and sanity-checking

-fwarn-missing-local-sigs, 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-monomorphism-restriction, Warnings and sanity-checking

-fwarn-name-shadowing, Warnings and sanity-checking

-fwarn-orphans, Warnings and sanity-checking

-fwarn-overflowed-literals, Warnings and sanity-checking

-fwarn-overlapping-patterns, Warnings and sanity-checking

-fwarn-partial-type-signatures, Warnings and sanity-checking

-fwarn-pointless-pragmas, Warnings and sanity-checking

-fwarn-safe, Safe Haskell Flag Summary

-fwarn-tabs, Warnings and sanity-checking

-fwarn-trustworthy-safe, Safe Haskell Flag Summary

-fwarn-type-defaults, Warnings and sanity-checking

-fwarn-typed-holes, Warnings and sanity-checking

-fwarn-unrecognised-pragmas, Warnings and sanity-checking

-fwarn-unsafe, Safe Haskell Flag Summary

-fwarn-unsupported-calling-conventions, Warnings and sanity-checking

-fwarn-unticked-promoted-constructors, Warnings and sanity-checking

-fwarn-unused-binds, Warnings and sanity-checking

-fwarn-unused-do-bind, Warnings and sanity-checking

-fwarn-unused-imports, Warnings and sanity-checking

-fwarn-unused-matches, Warnings and sanity-checking

-fwarn-warnings-deprecations, Warnings and sanity-checking

-fwarn-wrong-do-bind, Warnings and sanity-checking

-fwrite-interface, Options affecting code generation

-G

RTS option, RTS options to control the garbage collector

-G RTS option, Thriftier: producing a program that gobbles less heap space

-ghci-script, The .ghci file

-global-package-db, Package Databases

-H, Verbosity options, Sooner: producing a program more quickly

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

-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

-hT

RTS option, RTS options for profiling

-hy

RTS option, RTS options for heap profiling

-I, Options affecting the C pre-processor

RTS option, RTS options to control the garbage collector

-i, RTS options for heap profiling

-idirs , The search path

-ignore-dot-ghci, The .ghci file

-ignore-package, Using Packages

-k

RTS option, RTS options to control the garbage collector

-K

RTS option, RTS options to control the garbage collector

-kc

RTS option, RTS options to control the garbage collector

-keep-hc-file, Keeping Intermediate Files

-keep-hc-files, Keeping Intermediate Files

-keep-llvm-file, Keeping Intermediate Files

-keep-llvm-files, Keeping Intermediate Files

-keep-s-file, Keeping Intermediate Files

-keep-s-files, Keeping Intermediate Files

-keep-tmp-files, Keeping Intermediate Files

-l, Options affecting linking

RTS option, Tracing

-L, Options affecting linking

RTS option, RTS options for heap profiling

-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> RTS option, Faster: producing a program that runs quicker

-main-is, Options affecting linking

-msse2, Bugs in GHC

-n

RTS option, RTS options to control the garbage collector

-no-auto-link-packages, Using Packages

-no-fprof-auto, Compiler options for profiling

-no-global-package-db, Package Databases

-no-hs-main, Options affecting linking, Using your own main()

-no-user-package-db, Package Databases

-Nx

RTS option, Options affecting linking, Using Concurrent Haskell, RTS options for SMP parallelism

-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)

-Odph, -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

-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

-optlc, Forcing options to a particular phase

-optlo, Forcing options to a particular phase

-optP, Forcing options to a particular phase

-optwindres, Forcing options to a particular phase

-osuf, Redirecting the compilation output(s), Using Template Haskell with Profiling

-outputdir, Redirecting the compilation output(s)

-p, Time and allocation profiling

RTS option, Profiling

-P, Cost centres and cost-centre stacks, Time and allocation profiling

-pa, Time and allocation profiling

-package, Using Packages , Options affecting linking

-package-db, Package Databases, Package management (the ghc-pkg command)

-package-id, Using Packages

-pgma, Replacing the program for one or more phases, Replacing phases

-pgmc, 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

-pgmlc, Replacing the program for one or more phases, Replacing phases

-pgmlibtool, Replacing the program for one or more phases

-pgmlo, Replacing the program for one or more phases, Replacing phases

-pgmP, Replacing the program for one or more phases, Replacing phases

-pgms, Replacing the program for one or more phases

-pgmwindres, Replacing the program for one or more phases

-prof, Compiler options for profiling, Using Template Haskell with Profiling

-qa

RTS option, RTS options for SMP parallelism

-qbRTS option, RTS options to control the garbage collector

-qgRTS option, RTS options to control the garbage collector

-qm

RTS option, RTS options for SMP parallelism

-r

RTS option, RTS options for hackers, debuggers, and over-interested souls

-rdynamic, Options affecting linking

-Rghc-timing, Verbosity options

-RTS, Setting RTS options on the command line

-rtsopts, Options affecting linking, Using your own main()

-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, Thriftier: producing a program that gobbles less heap space

-shared, Options affecting linking, Creating a DLL

-split-objs, Options affecting linking

-static, Options affecting linking

-staticlib, Options affecting linking

-stubdir, Redirecting the compilation output(s)

-T

RTS option, RTS options to control the garbage collector

-t

RTS option, RTS options to control the garbage collector

-this-package-key, Using Packages

-threaded, Options affecting linking

-tmpdir, Redirecting temporary files

-tmpdir <dir> option, Redirecting temporary files

-trust, Using Packages

-U, Options affecting the C pre-processor

-user-package-db, Package Databases

-V, Modes of operation, Package management (the ghc-pkg command)

RTS option, Miscellaneous RTS options, Time and allocation profiling

-v, Verbosity options, Sooner: producing a program more quickly

ghc-pkg option, Package management (the ghc-pkg command)

RTS option, Tracing

-w, Warnings and sanity-checking

-W option, Warnings and sanity-checking

-Wall, Warnings and sanity-checking

-Werror, Warnings and sanity-checking

-with-rtsopts, Options affecting linking

-Wwarn, Warnings and sanity-checking

-x, Overriding the default behaviour for a file

-xc

RTS option, RTS options for hackers, debuggers, and over-interested souls, Time and allocation profiling

-XForeignFunctionInterface, Foreign function interface (FFI)

-XIncoherentInstances , Overlapping instances

-xm

RTS option, Miscellaneous RTS options

-XNoImplicitPrelude option, Rebindable syntax and the implicit Prelude import, When the compiler “does the wrong thing”

-XNoMonomorphismRestriction, Switching off the dreaded Monomorphism Restriction

-XNoTraditionalRecordSyntax, Traditional record syntax

-XNPlusKPatterns, n+k patterns

-XOverlappingInstances , Overlapping instances

-xq

RTS option, Miscellaneous RTS options

-XRoleAnnotations, Role annotations

-XSafe, Safe Haskell Flag Summary

-xt

RTS option, RTS options for heap profiling

-XTemplateHaskell, Syntax

-XTrustworthy, Safe Haskell Flag Summary

-XUndecidableInstances, Undecidable instances

-XUnicodeSyntax, Unicode syntax

-XUnsafe, Safe Haskell Flag Summary

-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

.ll files, saving, Keeping Intermediate Files

.o files, Output files

.s files, saving, Keeping Intermediate Files

:, GHCi commands

:!, GHCi commands

:?, GHCi commands

:abandon, GHCi commands

:add, GHCi commands

:back, GHCi commands

:break, GHCi commands

:browse, GHCi commands

:cd, GHCi commands

:cmd, GHCi commands

:complete, GHCi commands

:continue, GHCi commands

:def, GHCi commands

:delete, GHCi commands

:edit, GHCi commands

:etags, GHCi commands

:force, GHCi commands

:forward, GHCi commands

:help, GHCi commands

:history, GHCi commands

:info, GHCi commands

:issafe, GHCi commands

:kind, GHCi commands

:list, GHCi commands

:load, Loading source files, GHCi commands

:main, GHCi commands

:module, GHCi commands

:print, GHCi commands

:quit, GHCi commands

:reload, Making changes and recompilation, GHCi commands

:run, GHCi commands

:script, GHCi commands

:set, GHCi commands, The :set and :seti commands

:set +m, Multiline input

:set args, GHCi commands

:set prog, GHCi commands

:seti, GHCi commands, The :set and :seti commands

:show, GHCi commands

:show bindings, GHCi commands

:show breaks, GHCi commands

:show context, GHCi commands

:show imports, GHCi commands

:show language, GHCi commands

:show modules, GHCi commands

:show packages, GHCi commands

:show paths, GHCi commands

:showi language, GHCi commands

:sprint, GHCi commands

:step, GHCi commands

:steplocal, GHCi commands

:stepmodule, GHCi commands

:trace, GHCi commands

:type, GHCi commands

:undef, GHCi commands

:unset, GHCi commands

__GLASGOW_HASKELL_LLVM__, Options affecting the C pre-processor

__GLASGOW_HASKELL_PATCHLEVEL1__, Options affecting the C pre-processor

__GLASGOW_HASKELL_PATCHLEVEL2__, Options affecting the C pre-processor

__GLASGOW_HASKELL_TH__, Options affecting the C pre-processor

__GLASGOW_HASKELL__, GHC version numbering policy, Options affecting the C pre-processor

__PARALLEL_HASKELL__, Options affecting the C pre-processor

, -f*: platform-independent flags

A

allocation area, chunk size, RTS options to control the garbage collector

allocation area, size, RTS options to control the garbage collector

amp, Warnings and sanity-checking

ANN, Annotating values, Annotating types, Annotating modules

ANN module, Annotating modules

ANN type, Annotating types

apparently erroneous do binding, warning, Warnings and sanity-checking

applicative-monad proposal, Warnings and sanity-checking

arguments

command-line, Command-line arguments

ASCII, Haskell source files

Assertions, Assertions

author

package specification, InstalledPackageInfo: a package specification

auto

package specification, InstalledPackageInfo: a package specification

B

Bang patterns, Bang patterns

binds, unused, Warnings and sanity-checking

bugs

reporting, Reporting bugs in GHC

C

C calls, function headers, Using header files

C code generator, C Code Generator (-fvia-C)

C pre-processor options, Options affecting the C pre-processor

CAFs

in GHCi, GHCi options

category

package specification, InstalledPackageInfo: a package specification

cc-options

package specification, InstalledPackageInfo: a package specification

Char

size of, GHC's interpretation of undefined behaviour in Haskell 98 and Haskell 2010

code coverage, Observing Code Coverage

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

using, Using Concurrent Haskell

CONLIKE, CONLIKE modifier

consistency checks, Checking for consistency

Constant Applicative Form (see CAFs)

constructor fields, strict, -f*: platform-independent flags

context, implicit quantification, Warnings and sanity-checking

copyright

package specification, InstalledPackageInfo: a package specification

Core syntax, how to read, How to read Core syntax (from some -ddump flags)

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

D

debugger

in GHCi, The GHCi Debugger

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, WARNING and DEPRECATED pragmas

deprecated-flags, Warnings and sanity-checking

deprecations, Warnings and sanity-checking

description

package specification, InstalledPackageInfo: a package specification

DLL-creation mode, Modes of operation

DLLs, Win32, Building and using Win32 DLLs

do binding, apparently erroneous, Warnings and sanity-checking

do binding, unused, Warnings and sanity-checking

do-notation

in GHCi, Using do-notation at the prompt

dumping GHC intermediates, Dumping out compiler intermediate structures

duplicate constraints, warning, Warnings and sanity-checking

duplicate exports, warning, Warnings and sanity-checking

dynamic

options, Setting GHC command-line options in GHCi, Static, Dynamic, and Mode options

Dynamic libraries

using, Using shared libraries

Dynamic link libraries, Win32, Building and using Win32 DLLs

E

encoding, Haskell source files

Environment variable

GHC_PACKAGE_PATH, The GHC_PACKAGE_PATH environment variable

environment variable

for setting RTS options, Setting RTS options with the GHCRTS environment variable

eval mode, Modes of operation

eventlog files, Tracing

events, Tracing

export lists, duplicates, Warnings and sanity-checking

exposed

package specification, InstalledPackageInfo: a package specification

exposed-modules

package specification, InstalledPackageInfo: a package specification

extended list comprehensions, Generalised (SQL-Like) List Comprehensions

extensions

options controlling, Language options

extensions, GHC, GHC Language Features

extra-libraries

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, Haskell source files

of modules, Modules vs. filenames

finding interface files, The search path

floating-point exceptions, GHC's interpretation of undefined behaviour in Haskell 98 and Haskell 2010

forall, Summary of stolen syntax

forcing GHC-phase options, Forcing options to a particular phase

foreign, Summary of stolen syntax

foreign export

with GHC, Using foreign export and foreign import ccall "wrapper" with GHC

Foreign Function Interface

GHCi support, Using GHCi

formatting dumps, Formatting dumps

framework-dirs

package specification, InstalledPackageInfo: a package specification

frameworks

package specification, InstalledPackageInfo: a package specification

fromInteger, GHC's interpretation of undefined behaviour in Haskell 98 and Haskell 2010

fromIntegral, GHC's interpretation of undefined behaviour in Haskell 98 and Haskell 2010

G

garbage collection

compacting, RTS options to control the garbage collector

garbage collector

options, RTS options to control the garbage collector

generations, number of, RTS options to control the garbage collector

getArgs, GHCi commands

getProgName, GHCi commands

ghc backends, GHC Backends

ghc code generators, GHC Backends

GHC vs the Haskell standards, Haskell standards vs. Glasgow Haskell: language non-compliance

GHC, using, Using GHC

GHCi, Using GHCi

ghci, Modes of operation

GHCRTS, Setting RTS options with the GHCRTS environment variable

GHC_PACKAGE_PATH, The GHC_PACKAGE_PATH environment variable

Glasgow Haskell mailing lists, Meta-information: Web sites, mailing lists, etc.

Glasgow Parallel Haskell, Parallel Haskell

group, Generalised (SQL-Like) List Comprehensions

H

haddock-html

package specification, InstalledPackageInfo: a package specification

haddock-interfaces

package specification, InstalledPackageInfo: a package specification

Happy, “Yacc for Haskell”: happy

happy parser generator, “Yacc for Haskell”: happy

Haskell Program Coverage, Observing Code Coverage

Haskell standards vs GHC, Haskell standards vs. Glasgow Haskell: language non-compliance

heap profiles, hp2ps--heap profile to PostScript

heap size, factor, RTS options to control the garbage collector

heap size, maximum, RTS options to control the garbage collector

heap size, suggested, RTS options to control the garbage collector

heap space, using less, Thriftier: producing a program that gobbles less heap space

heap, minimum free, RTS options to control the garbage collector

help options, Modes of operation

hidden-modules

package specification, InstalledPackageInfo: a package specification

homepage

package specification, InstalledPackageInfo: a package specification

hooks

RTS, “Hooks” to change RTS behaviour

hp2ps, hp2ps--heap profile to PostScript

hp2ps program, hp2ps--heap profile to PostScript

hpc, Observing Code Coverage

hs-boot files, How to compile mutually recursive modules

hs-libraries

package specification, InstalledPackageInfo: a package specification

hsc2hs, Writing Haskell interfaces to C code: hsc2hs

Hugs, Using GHCi

hugs-options

package specification, InstalledPackageInfo: a package specification

I

id

package specification, InstalledPackageInfo: a package specification

idle GC, RTS options to control the garbage collector

implicit context quantification, warning, Warnings and sanity-checking

implicit parameters, Summary of stolen syntax

implicit prelude, warning, Warnings and sanity-checking

import lists, missing, Warnings and sanity-checking

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)

include-dirs

package specification, InstalledPackageInfo: a package specification

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

installer detection, Options affecting linking

Int

size of, GHC's interpretation of undefined behaviour in Haskell 98 and Haskell 2010

interactive (see GHCi)

interactive mode, Modes of operation

interface files, Output files

interface files, finding them, The search path

interface files, options, Other options related to interface 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

pragma, LANGUAGE pragma

language, GHC, GHC Language Features

Latin-1, Haskell source files

ld options, Options affecting linking

ld-options

package specification, InstalledPackageInfo: a package specification

lhs suffix, Meaningful file suffixes

libdir, Modes of operation

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

linker options, Options affecting linking

linking Haskell libraries with foreign code, Options affecting linking

lint, Checking for consistency

list comprehensions

generalised, Generalised (SQL-Like) List Comprehensions

parallel, Parallel List Comprehensions

LLVM code generator, LLVM Code Generator (-fllvm)

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

manifest, Options affecting linking

matches, unused, Warnings and sanity-checking

mdo, Summary of stolen syntax

memory, using less heap, Thriftier: producing a program that gobbles less heap space

methods, missing, Warnings and sanity-checking

MINIMAL, MINIMAL pragma

MIN_VERSION_GLASGOW_HASKELL, Options affecting the C pre-processor

missing fields, warning, Warnings and sanity-checking

missing import lists, warning, Warnings and sanity-checking

missing methods, warning, Warnings and sanity-checking

mode

options, Static, Dynamic, and Mode options

module system, recursion, How to compile mutually recursive modules

modules

and filenames, Modules vs. filenames

monad comprehensions, Monad comprehensions

monomorphism restriction, warning, Warnings and sanity-checking

multicore, Options affecting linking, Using Concurrent Haskell

multiprocessor, Options affecting linking, Using Concurrent Haskell

N

name

package specification, InstalledPackageInfo: a package specification

native code generator, Native code Generator (-fasm)

NOINLINE, NOINLINE pragma

NOTINLINE, NOINLINE pragma

NOUNPACK, NOUNPACK pragma

O

object files, Output files

optimisation, Optimisation (code improvement)

optimise

aggressively, -O*: convenient “packages” of optimisation flags.

DPH, -O*: convenient “packages” of optimisation flags.

normally, -O*: convenient “packages” of optimisation flags.

options

for profiling, Compiler options for profiling

GHCi, GHCi options

language, Language options

OPTIONS_GHC, OPTIONS_GHC pragma

OPTIONS_GHC pragma, Command line options in source files

orphan instance, Orphan modules and instance declarations

orphan instances, warning, Warnings and sanity-checking

orphan module, Orphan modules and instance declarations

orphan rule, Orphan modules and instance declarations

orphan rules, warning, Warnings and sanity-checking

OutOfHeapHook, “Hooks” to change RTS behaviour

output-directing options, Redirecting the compilation output(s)

overflow

Int, GHC's interpretation of undefined behaviour in Haskell 98 and Haskell 2010

overlapping patterns, warning, Warnings and sanity-checking

overloading, death to, Faster: producing a program that runs quicker, SPECIALIZE pragma, SPECIALIZE instance pragma

P

package environments, Package environments

package trust, Package Trust

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 list comprehensions, Parallel List Comprehensions

parallelism, Options affecting linking, Using Concurrent Haskell, Using SMP parallelism, Concurrent and Parallel Haskell

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

LANGUAGE, LANGUAGE pragma

LINE, LINE pragma

OPTIONS_GHC, OPTIONS_GHC pragma

pragma, RULES, Rewrite rules

pragma, SPECIALIZE, SPECIALIZE pragma

pragmas, Warnings and sanity-checking

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

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”

proc, Summary of stolen syntax

profiling, Profiling

options, Compiler options for profiling

ticky ticky, RTS options for hackers, debuggers, and over-interested souls

with Template Haskell, Using Template Haskell with Profiling

promoted constructor, warning, Warnings and sanity-checking

prompt

GHCi, Introduction to GHCi

Q

quasi-quotation, Summary of stolen syntax

R

reading Core syntax, How to read Core syntax (from some -ddump flags)

recompilation checker, Filenames and separate compilation, The recompilation checker

record updates, incomplete, Warnings and sanity-checking

recursion, between modules, How to compile mutually recursive modules

redirecting compilation output, Redirecting the compilation output(s)

reexported-modules

reexport specification, InstalledPackageInfo: a package specification

reporting bugs, Reporting bugs in GHC

rewrite rules, Rewrite rules

roles, Roles

RTS, Getting information about the RTS

RTS behaviour, changing, “Hooks” to change RTS behaviour

RTS hooks, “Hooks” to change RTS behaviour

RTS options, Running a compiled program

from the environment, Setting RTS options with the GHCRTS environment variable

garbage collection, RTS options to control the garbage collector

RTS options, concurrent, Using Concurrent Haskell

RTS options, hacking/debugging, RTS options for hackers, debuggers, and over-interested souls

RTS options, setting, Setting RTS options

RULES pragma, Rewrite rules

runghc, Using runghc

running, compiled program, Running a compiled program

runtime control of Haskell programs, Running a compiled program

S

safe compilation, Safe Compilation

safe haskell, Safe Haskell

safe haskell flags, Safe Haskell Flag Summary

safe haskell trust, Trust and Safe Haskell Modes

safe haskell uses, Uses of Safe Haskell

safe imports, Safe Imports

safe inference, Safe Haskell Inference

safe language, Safe Language

sanity-checking options, Warnings and sanity-checking

search path, The search path

secure haskell, Building secure systems (restricted IO Monads)

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

Shared libraries

using, Using shared libraries

shell commands

in GHCi, GHCi commands

Show class, Type defaulting in GHCi

smaller programs, how to produce, Smaller: producing a program that is smaller

SMP, Options affecting linking, Using Concurrent Haskell, Using SMP parallelism, Parallel Haskell

SOURCE, SOURCE pragma

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

sql, Generalised (SQL-Like) List Comprehensions

stability

package specification, InstalledPackageInfo: a package specification

stack

chunk buffer size, RTS options to control the garbage collector

chunk size, RTS options to control the garbage collector

stack, initial size, RTS options to control the garbage collector

stack, maximum 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, Dynamic, and Mode options

Static pointers, Static pointers

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

suppression, Suppressing unwanted information

T

tabs, warning, Warnings and sanity-checking

Template Haskell, Summary of stolen syntax

temporary files

keeping, Keeping Intermediate Files

redirecting, Redirecting temporary files

ThreadScope, Tracing

ticky ticky profiling, RTS options for hackers, debuggers, and over-interested souls

ticky-ticky profiling, Using “ticky-ticky” profiling (for implementors)

time profile, Time and allocation profiling

TMPDIR environment variable, Redirecting temporary files

tracing, Tracing

trust, Trust and Safe Haskell Modes

trust check, Trust check (-fpackage-trust disabled), Trust check (-fpackage-trust enabled)

trusted

package specification, InstalledPackageInfo: a package specification

trustworthy, Trustworthy Requirements

Type default, Type defaulting in GHCi

type signatures, missing, Warnings and sanity-checking

U

Unboxed types (Glasgow extension), Unboxed types

unfolding, controlling, -f*: platform-independent flags

unicode, Haskell source files

UNPACK, UNPACK pragma

unregisterised compilation, Unregisterised compilation

unused binds, warning, Warnings and sanity-checking

unused do binding, warning, Warnings and sanity-checking

unused imports, warning, Warnings and sanity-checking

unused matches, warning, Warnings and sanity-checking

using GHC, Using GHC

UTF-8, Haskell source files

utilities, Haskell, Other Haskell utility programs

V

verbosity options, Verbosity options

version

package specification, InstalledPackageInfo: a package specification

version, of ghc, GHC version numbering policy

W

WARNING, WARNING and DEPRECATED pragmas

warnings, Warnings and sanity-checking

windres, Options affecting linking

Y

Yacc for Haskell, “Yacc for Haskell”: happy