Index
Prev   

Index

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
--install-signal-handlers
RTS option, Miscellaneous RTS options
--machine-readable
RTS option, RTS options to control the garbage collector
--RTS, Setting RTS options on the command line
--show-iface, Other options related to interface files
--verbose
ghc-pkg option, 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
-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-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-phases, 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-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
-feager-blackholing, Compile-time options for SMP parallelism
-ferror-spans, Help and verbosity options
-fexcess-precision, -f*: platform-independent flags
-fext-core, Generating and compiling External Core Files
-fforce-recomp, The recompilation checker
-fglasgow-exts, Language options
-fhpc, Options for instrumenting code for coverage
-fignore-asserts, -f*: platform-independent flags, Assertions
-fignore-interface-pragmas, -f*: platform-independent flags
-fliberate-case, -f*: platform-independent flags
-fllvm, Options affecting code generation
-fno-* options (GHC), -f*: platform-independent flags
-fno-code, Options affecting code generation
-fno-cse, -f*: platform-independent flags
-fno-embed-manifest, Options affecting linking
-fno-float-in, -f*: platform-independent flags
-fno-force-recomp, The recompilation checker
-fno-full-laziness, -f*: platform-independent flags
-fno-gen-manifest, Options affecting linking
-fno-implicit-import-qualified, Qualified names
-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-specialise, -f*: platform-independent flags
-fno-state-hack, -f*: platform-independent flags
-fno-strictness, -f*: platform-independent flags
-fobject-code, Options affecting code generation
-fomit-interface-pragmas, -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
-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
-fsimpl-tick-factor, -f*: platform-independent flags
-fspec-constr, -f*: platform-independent flags
-fstatic-argument-transformation, -f*: platform-independent flags
-funbox-strict-fields, -f*: platform-independent flags
-funfolding-creation-threshold, -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-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-exports, 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-lazy-unlifted-bindings, 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-overlapping-patterns, Warnings and sanity-checking
-fwarn-safe, Safe Haskell Flag Summary
-fwarn-tabs, Warnings and sanity-checking
-fwarn-type-defaults, Warnings and sanity-checking
-fwarn-unrecognised-pragmas, Warnings and sanity-checking
-fwarn-unsafe, Safe Haskell Flag Summary
-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
-G
RTS option, RTS options to control the garbage collector
-G RTS option, Thriftier: producing a program that gobbles less heap space
-H, Help and 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
-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
-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
-no-auto-link-packages, Using Packages
-no-fprof-auto, Compiler options for profiling
-no-hs-main, Options affecting linking, Using your own main()
-no-user-package-conf, 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)
-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
-optm, 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-conf, Package Databases, Package management (the ghc-pkg command)
-package-id, Using Packages
-package-name, 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
-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
-r RTS option, Using “ticky-ticky” profiling (for implementors)
-read-dot-ghci, The .ghci file
-Rghc-timing, Help and 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
-split-objs, Options affecting linking
-static, 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
-threaded, Options affecting linking
-tmpdir, Redirecting temporary files
-tmpdir <dir> option, Redirecting temporary files
-trust, Using Packages
-U, Options affecting the C pre-processor
-V, Modes of operation, Package management (the ghc-pkg command)
RTS option, Miscellaneous RTS options, Time and allocation profiling
-v, Help and 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
-XMonoPatBinds, Monomorphic pattern bindings
-XNoImplicitPrelude option, Rebindable syntax and the implicit Prelude import, When the compiler “does the wrong thing”
-XNoMonomorphismRestriction, Switching off the dreaded Monomorphism Restriction
-XNoMonoPatBinds, Monomorphic pattern bindings
-XNoTraditionalRecordSyntax, Traditional record syntax
-XNPlusKPatterns, n+k patterns
-XOverlappingInstances , Overlapping instances
-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
: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
:kind, 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 command
:set +m, Multiline input
:set args, GHCi commands
:set prog, GHCi commands
:show, GHCi commands
:show bindings, GHCi commands
:show breaks, GHCi commands
:show context, GHCi commands
:show imports, GHCi commands
:show languages, GHCi commands
:show modules, GHCi commands
:show packages, GHCi commands
:sprint, GHCi commands
:step, GHCi commands
:trace, GHCi commands
:type, GHCi commands
:undef, GHCi commands
:unset, GHCi commands
__GLASGOW_HASKELL__, GHC version numbering policy, Options affecting the C pre-processor
__PARALLEL_HASKELL__, Options affecting the C pre-processor
–shared, Creating a DLL
––--show-iface, Modes of operation
––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
––interactive, Invoking GHCi
––make, Modes of operation, Using ghc ––make
––numeric-version, Modes of operation
––print-libdir, Modes of operation
––supported-extensions, Modes of operation
––user, Package management (the ghc-pkg command)
––version, Modes of operation, Package management (the ghc-pkg command)

A

allocation area, size, RTS options to control the garbage collector
ANN, Annotating values, Annotating types, Annotating modules
ANN module, Annotating modules
ANN type, Annotating types
apparently erroneous do binding, warning, 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
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

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 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, Help and verbosity options
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 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 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
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
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.
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 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, CORE, CORE 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
profiling, ticky-ticky, Using “ticky-ticky” profiling (for implementors)
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)
reporting bugs, Reporting bugs in GHC
rewrite rules, Rewrite rules
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 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
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, Help and 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
Prev   
13.2. Known bugs or infelicities Home