Glasgow Haskell Compiler User's Guide

Welcome to the GHC User’s Guide¶

Contents:

1. The Glasgow Haskell Compiler License
2. Introduction to GHC
- 2.1. Obtaining GHC
- 2.2. Meta-information: Web sites, mailing lists, etc.
- 2.3. Reporting bugs in GHC
- 2.4. GHC version numbering policy
3. Release notes for version 8.10.1
- 3.1. Highlights
- 3.2. Full details
- 3.3. Included libraries
4. Release notes for version 8.10.2
- 4.1. Highlights
- 4.2. Full details
- 4.3. Known issues
- 4.4. Included libraries
5. Release notes for version 8.10.3
- 5.1. Highlights
- 5.2. Full details
  - 5.2.1. Compiler
  - 5.2.2. Runtime system
- 5.3. Known issues
- 5.4. Included libraries
6. Release notes for version 8.10.4
- 6.1. Bug Fixes
- 6.2. Known issues
- 6.3. Included libraries
7. Release notes for version 8.10.5
- 7.1. General bug fixes
- 7.2. Portability fixes
- 7.3. Known issues
- 7.4. Included libraries
8. Using GHCi
- 8.1. Introduction to GHCi
- 8.2. Loading source files
  - 8.2.1. Modules vs. filenames
  - 8.2.2. Making changes and recompilation
- 8.3. Loading compiled code
- 8.4. Interactive evaluation at the prompt
- 8.5. The GHCi Debugger
- 8.6. Invoking GHCi
  - 8.6.1. Packages
  - 8.6.2. Extra libraries
- 8.7. GHCi commands
- 8.8. The :set and :seti commands
- 8.9. The .ghci and .haskeline files
  - 8.9.1. The .ghci files
  - 8.9.2. The .haskeline file
- 8.10. Compiling to object code inside GHCi
- 8.11. Running the interpreter in a separate process
- 8.12. Running the interpreter on a different host
- 8.13. FAQ and Things To Watch Out For
9. Using runghc
- 9.1. Usage
- 9.2. runghc flags
- 9.3. GHC Flags
10. Using GHC
- 10.1. Using GHC
- 10.2. Warnings and sanity-checking
- 10.3. Optimisation (code improvement)
  - 10.3.1. -O*: convenient “packages” of optimisation flags.
  - 10.3.2. -f*: platform-independent flags
- 10.4. Using Concurrent Haskell
- 10.5. Using SMP parallelism
- 10.6. Flag reference
- 10.7. Running a compiled program
- 10.8. Filenames and separate compilation
- 10.9. Packages
- 10.10. GHC Backends
- 10.11. Options related to a particular phase
- 10.12. Using shared libraries
- 10.13. Debugging the compiler
11. Profiling
- 11.1. Cost centres and cost-centre stacks
  - 11.1.1. Inserting cost centres by hand
  - 11.1.2. Rules for attributing costs
- 11.2. Compiler options for profiling
- 11.3. Time and allocation profiling
  - 11.3.1. JSON profile format
- 11.4. Profiling memory usage
- 11.5. hp2ps – Rendering heap profiles to PostScript
- 11.6. Profiling Parallel and Concurrent Programs
- 11.7. Observing Code Coverage
- 11.8. Using “ticky-ticky” profiling (for implementors)
12. Advice on: sooner, faster, smaller, thriftier
- 12.1. Sooner: producing a program more quickly
- 12.2. Faster: producing a program that runs quicker
- 12.3. Smaller: producing a program that is smaller
- 12.4. Thriftier: producing a program that gobbles less heap space
13. GHC Language Features
- 13.1. Language options
- 13.2. Unboxed types and primitive operations
  - 13.2.1. Unboxed types
  - 13.2.2. Unboxed type kinds
  - 13.2.3. Unboxed tuples
  - 13.2.4. Unboxed sums
  - 13.2.5. Unlifted Newtypes
- 13.3. Syntactic extensions
  - 13.3.1. Unicode syntax
  - 13.3.2. The magic hash
  - 13.3.3. Negative literals
  - 13.3.4. Fractional looking integer literals
  - 13.3.5. Binary integer literals
  - 13.3.6. Hexadecimal floating point literals
  - 13.3.7. Numeric underscores
  - 13.3.8. Pattern guards
  - 13.3.9. View patterns
  - 13.3.10. n+k patterns
  - 13.3.11. The recursive do-notation
    - 13.3.11.1. Recursive binding groups
    - 13.3.11.2. The mdo notation
  - 13.3.12. Applicative do-notation
    - 13.3.12.1. Strict patterns
    - 13.3.12.2. Things to watch out for
  - 13.3.13. Parallel List Comprehensions
  - 13.3.14. Generalised (SQL-like) List Comprehensions
  - 13.3.15. Monad comprehensions
  - 13.3.16. New monadic failure desugaring mechanism
  - 13.3.17. Rebindable syntax and the implicit Prelude import
    - 13.3.17.1. Things unaffected by RebindableSyntax
  - 13.3.18. Postfix operators
  - 13.3.19. Tuple sections
  - 13.3.20. Lambda-case
  - 13.3.21. Empty case alternatives
  - 13.3.22. Multi-way if-expressions
  - 13.3.23. Local Fixity Declarations
  - 13.3.24. Import and export extensions
    - 13.3.24.1. Hiding things the imported module doesn’t export
    - 13.3.24.2. Package-qualified imports
    - 13.3.24.3. Safe imports
    - 13.3.24.4. Explicit namespaces in import/export
    - 13.3.24.5. Writing qualified in postpositive position
  - 13.3.25. More liberal syntax for function arguments
    - 13.3.25.1. Changes to the grammar
  - 13.3.26. Summary of stolen syntax
- 13.4. Extensions to data types and type synonyms
  - 13.4.1. Data types with no constructors
  - 13.4.2. Data type contexts
  - 13.4.3. Infix type constructors, classes, and type variables
  - 13.4.4. Type operators
  - 13.4.5. Liberalised type synonyms
  - 13.4.6. Existentially quantified data constructors
  - 13.4.7. Declaring data types with explicit constructor signatures
  - 13.4.8. Generalised Algebraic Data Types (GADTs)
- 13.5. Extensions to the record system
  - 13.5.1. Traditional record syntax
  - 13.5.2. Record field disambiguation
  - 13.5.3. Duplicate record fields
  - 13.5.4. Record puns
  - 13.5.5. Record wildcards
  - 13.5.6. Record field selector polymorphism
    - 13.5.6.1. Solving HasField constraints
    - 13.5.6.2. Virtual record fields
- 13.6. Extensions to the “deriving” mechanism
  - 13.6.1. Deriving instances for empty data types
  - 13.6.2. Inferred context for deriving clauses
  - 13.6.3. Stand-alone deriving declarations
  - 13.6.4. Deriving instances of extra classes (Data, etc.)
  - 13.6.5. Generalised derived instances for newtypes
  - 13.6.6. Deriving any other class
  - 13.6.7. Deriving strategies
    - 13.6.7.1. Default deriving strategy
  - 13.6.8. Deriving via
- 13.7. Pattern synonyms
  - 13.7.1. Record Pattern Synonyms
  - 13.7.2. Syntax and scoping of pattern synonyms
  - 13.7.3. Import and export of pattern synonyms
  - 13.7.4. Typing of pattern synonyms
  - 13.7.5. Matching of pattern synonyms
- 13.8. Class and instances declarations
  - 13.8.1. Class declarations
  - 13.8.2. Functional dependencies
    - 13.8.2.1. Rules for functional dependencies
    - 13.8.2.2. Background on functional dependencies
  - 13.8.3. Instance declarations
  - 13.8.4. Overloaded string literals
  - 13.8.5. Overloaded labels
  - 13.8.6. Overloaded lists
  - 13.8.7. Undecidable (or recursive) superclasses
- 13.9. Type families
  - 13.9.1. Data families
  - 13.9.2. Synonym families
  - 13.9.3. Wildcards on the LHS of data and type family instances
  - 13.9.4. Associated data and type families
  - 13.9.5. Import and export
    - 13.9.5.1. Examples
    - 13.9.5.2. Instances
  - 13.9.6. Type families and instance declarations
  - 13.9.7. Injective type families
    - 13.9.7.1. Syntax of injectivity annotation
    - 13.9.7.2. Verifying the injectivity annotation against type family equations
- 13.10. Datatype promotion
  - 13.10.1. Motivation
  - 13.10.2. Overview
  - 13.10.3. Distinguishing between types and constructors
  - 13.10.4. Promoted list and tuple types
  - 13.10.5. Promoting existential data constructors
- 13.11. Kind polymorphism
  - 13.11.1. Overview of kind polymorphism
  - 13.11.2. Overview of Type-in-Type
  - 13.11.3. Principles of kind inference
  - 13.11.4. Inferring the order of variables in a type/class declaration
  - 13.11.5. Complete user-supplied kind signatures and polymorphic recursion
  - 13.11.6. Standalone kind signatures and polymorphic recursion
  - 13.11.7. Standalone kind signatures and declaration headers
  - 13.11.8. Kind inference in closed type families
  - 13.11.9. Kind inference in class instance declarations
  - 13.11.10. Kind inference in type signatures
  - 13.11.11. Explicit kind quantification
  - 13.11.12. Implicit quantification in type synonyms and type family instances
  - 13.11.13. Kind-indexed GADTs
  - 13.11.14. Higher-rank kinds
  - 13.11.15. Constraints in kinds
  - 13.11.16. The kind Type
  - 13.11.17. Inferring dependency in datatype declarations
  - 13.11.18. Inferring dependency in user-written foralls
  - 13.11.19. Kind defaulting without PolyKinds
  - 13.11.20. Pretty-printing in the presence of kind polymorphism
- 13.12. Levity polymorphism
  - 13.12.1. No levity-polymorphic variables or arguments
  - 13.12.2. Levity-polymorphic bottoms
  - 13.12.3. Printing levity-polymorphic types
- 13.13. Type-Level Literals
  - 13.13.1. Runtime Values for Type-Level Literals
  - 13.13.2. Computing With Type-Level Naturals
- 13.14. Equality constraints, Coercible, and the kind Constraint
  - 13.14.1. Equality constraints
  - 13.14.2. Heterogeneous equality
  - 13.14.3. Unlifted heterogeneous equality
  - 13.14.4. The Coercible constraint
  - 13.14.5. The Constraint kind
- 13.15. Quantified constraints
  - 13.15.1. Motivation
  - 13.15.2. Syntax changes
  - 13.15.3. Typing changes
  - 13.15.4. Superclasses
  - 13.15.5. Overlap
  - 13.15.6. Instance lookup
  - 13.15.7. Termination
  - 13.15.8. Coherence
- 13.16. Extensions to type signatures
  - 13.16.1. Explicit universal quantification (forall)
  - 13.16.2. The context of a type signature
  - 13.16.3. Ambiguous types and the ambiguity check
  - 13.16.4. Explicitly-kinded quantification
- 13.17. Lexically scoped type variables
  - 13.17.1. Overview
  - 13.17.2. Declaration type signatures
  - 13.17.3. Expression type signatures
  - 13.17.4. Pattern type signatures
  - 13.17.5. Class and instance declarations
- 13.18. Bindings and generalisation
  - 13.18.1. Switching off the dreaded Monomorphism Restriction
  - 13.18.2. Let-generalisation
- 13.19. Visible type application
  - 13.19.1. Inferred vs. specified type variables
  - 13.19.2. Ordering of specified variables
- 13.20. Implicit parameters
  - 13.20.1. Implicit-parameter type constraints
  - 13.20.2. Implicit-parameter bindings
  - 13.20.3. Implicit parameters and polymorphic recursion
  - 13.20.4. Implicit parameters and monomorphism
- 13.21. Arbitrary-rank polymorphism
  - 13.21.1. Examples
  - 13.21.2. Type inference
  - 13.21.3. Implicit quantification
- 13.22. Impredicative polymorphism
- 13.23. Typed Holes
  - 13.23.1. Valid Hole Fits
    - 13.23.1.1. Refinement Hole Fits
    - 13.23.1.2. Sorting Valid Hole Fits
- 13.24. Partial Type Signatures
  - 13.24.1. Syntax
  - 13.24.2. Where can they occur?
- 13.25. Custom compile-time errors
- 13.26. Deferring type errors to runtime
  - 13.26.1. Enabling deferring of type errors
  - 13.26.2. Deferred type errors in GHCi
  - 13.26.3. Limitations of deferred type errors
- 13.27. Template Haskell
  - 13.27.1. Syntax
  - 13.27.2. Using Template Haskell
  - 13.27.3. Viewing Template Haskell generated code
  - 13.27.4. A Template Haskell Worked Example
  - 13.27.5. Using Template Haskell with Profiling
  - 13.27.6. Template Haskell Quasi-quotation
- 13.28. Arrow notation
  - 13.28.1. do-notation for commands
  - 13.28.2. Conditional commands
  - 13.28.3. Defining your own control structures
  - 13.28.4. Primitive constructs
  - 13.28.5. Differences with the paper
  - 13.28.6. Portability
- 13.29. Bang patterns and Strict Haskell
  - 13.29.1. Bang patterns
  - 13.29.2. Strict-by-default data types
  - 13.29.3. Strict-by-default pattern bindings
  - 13.29.4. Modularity
  - 13.29.5. Dynamic semantics of bang patterns
- 13.30. Assertions
- 13.31. Static pointers
  - 13.31.1. Using static pointers
  - 13.31.2. Static semantics of static pointers
- 13.32. Pragmas
  - 13.32.1. LANGUAGE pragma
  - 13.32.2. OPTIONS_GHC pragma
  - 13.32.3. INCLUDE pragma
  - 13.32.4. WARNING and DEPRECATED pragmas
  - 13.32.5. MINIMAL pragma
  - 13.32.6. INLINE and NOINLINE pragmas
  - 13.32.7. LINE pragma
  - 13.32.8. COLUMN pragma
  - 13.32.9. RULES pragma
  - 13.32.10. SPECIALIZE pragma
    - 13.32.10.1. SPECIALIZE INLINE
    - 13.32.10.2. SPECIALIZE for imported functions
  - 13.32.11. SPECIALIZE instance pragma
  - 13.32.12. UNPACK pragma
  - 13.32.13. NOUNPACK pragma
  - 13.32.14. SOURCE pragma
  - 13.32.15. COMPLETE pragmas
  - 13.32.16. OVERLAPPING, OVERLAPPABLE, OVERLAPS, and INCOHERENT pragmas
- 13.33. Rewrite rules
  - 13.33.1. Syntax
  - 13.33.2. Semantics
  - 13.33.3. How rules interact with INLINE/NOINLINE pragmas
  - 13.33.4. How rules interact with CONLIKE pragmas
  - 13.33.5. How rules interact with class methods
  - 13.33.6. List fusion
  - 13.33.7. Specialisation
  - 13.33.8. Controlling what’s going on in rewrite rules
- 13.34. Special built-in functions
- 13.35. Generic classes
- 13.36. Generic programming
  - 13.36.1. Deriving representations
  - 13.36.2. Writing generic functions
  - 13.36.3. Unlifted representation types
  - 13.36.4. Generic defaults
  - 13.36.5. More information
- 13.37. Roles
  - 13.37.1. Nominal, Representational, and Phantom
  - 13.37.2. Role inference
  - 13.37.3. Role annotations
- 13.38. HasCallStack
  - 13.38.1. Compared with other sources of stack traces
- 13.39. Concurrent and Parallel Haskell
  - 13.39.1. Concurrent Haskell
  - 13.39.2. Software Transactional Memory
  - 13.39.3. Parallel Haskell
  - 13.39.4. Annotating pure code for parallelism
- 13.40. Safe Haskell
  - 13.40.1. Uses of Safe Haskell
    - 13.40.1.1. Strict type-safety (good style)
    - 13.40.1.2. Building secure systems (restricted IO Monads)
  - 13.40.2. Safe Language
    - 13.40.2.1. Safe Overlapping Instances
  - 13.40.3. Safe Imports
  - 13.40.4. Trust and Safe Haskell Modes
  - 13.40.5. Safe Haskell Inference
  - 13.40.6. Safe Haskell Flag Summary
  - 13.40.7. Safe Compilation
14. Foreign function interface (FFI)
- 14.1. GHC differences to the FFI Chapter
  - 14.1.1. Guaranteed call safety
  - 14.1.2. Varargs not supported by ccall calling convention
- 14.2. GHC extensions to the FFI Chapter
- 14.3. Using the FFI with GHC
15. Extending and using GHC as a Library
- 15.1. Source annotations
- 15.2. Using GHC as a Library
- 15.3. Compiler Plugins
16. What to do when something goes wrong
- 16.1. When the compiler “does the wrong thing”
- 16.2. When your program “does the wrong thing”
17. Debugging compiled programs
- 17.1. Tutorial
- 17.2. Requesting a stack trace from Haskell code
- 17.3. Requesting a stack trace with SIGQUIT
- 17.4. Implementor’s notes: DWARF annotations
  - 17.4.1. Debugging information entities
    - 17.4.1.1. DW_TAG_ghc_src_note
- 17.5. Further Reading
18. Other Haskell utility programs
- 18.1. “Yacc for Haskell”: happy
- 18.2. Writing Haskell interfaces to C code: hsc2hs
19. Running GHC on Win32 systems
- 19.1. Starting GHC on Windows platforms
- 19.2. Running GHCi on Windows
- 19.3. Interacting with the terminal
- 19.4. Differences in library behaviour
- 19.5. File paths under Windows
- 19.6. Using GHC (and other GHC-compiled executables) with Cygwin
- 19.7. Building and using Win32 DLLs
  - 19.7.1. Creating a DLL
  - 19.7.2. Making DLLs to be called from other languages
    - 19.7.2.1. Using from VBA
    - 19.7.2.2. Using from C++
20. Known bugs and infelicities
- 20.1. Haskell standards vs. Glasgow Haskell: language non-compliance
  - 20.1.1. Divergence from Haskell 98 and Haskell 2010
  - 20.1.2. GHC’s interpretation of undefined behaviour in Haskell 98 and Haskell 2010
- 20.2. Known bugs or infelicities
  - 20.2.1. Bugs in GHC
  - 20.2.2. Bugs in GHCi (the interactive GHC)
21. Eventlog encodings
- 21.1. Event log format
- 21.2. Runtime system diagnostics
- 21.3. Heap profiler event log output
  - 21.3.1. Metadata event types
- 21.4. Time profiler event log output
  - 21.4.1. Profile begin event
  - 21.4.2. Profile sample event
- 21.5. Biographical profile sample event
- 21.6. Non-moving GC event output
  - 21.6.1. Non-moving heap census
22. Care and feeding of your GHC User’s Guide
- 22.1. Basics
- 22.2. Citations
- 22.3. Admonitions
- 22.4. Documenting command-line options and GHCi commands
  - 22.4.1. Command-line options
  - 22.4.2. GHCi commands
- 22.5. Style Conventions
- 22.6. ReST reference materials

Indices and tables¶