Glasgow Haskell Compiler Users Guide

9. GHC Language Features¶

9.1. Language options
9.2. Unboxed types and primitive operations
- 9.2.1. Unboxed types
- 9.2.2. Unboxed tuples
9.3. Syntactic extensions
- 9.3.1. Unicode syntax
- 9.3.2. The magic hash
- 9.3.3. Negative literals
- 9.3.4. Fractional looking integer literals
- 9.3.5. Binary integer literals
- 9.3.6. Hierarchical Modules
- 9.3.7. Pattern guards
- 9.3.8. View patterns
- 9.3.9. Pattern synonyms
  - 9.3.9.1. Record Pattern Synonyms
  - 9.3.9.2. Syntax and scoping of pattern synonyms
  - 9.3.9.3. Import and export of pattern synonyms
  - 9.3.9.4. Typing of pattern synonyms
  - 9.3.9.5. Matching of pattern synonyms
- 9.3.10. n+k patterns
- 9.3.11. The recursive do-notation
  - 9.3.11.1. Recursive binding groups
  - 9.3.11.2. The mdo notation
- 9.3.12. Applicative do-notation
  - 9.3.12.1. Things to watch out for
- 9.3.13. Parallel List Comprehensions
- 9.3.14. Generalised (SQL-Like) List Comprehensions
- 9.3.15. Monad comprehensions
- 9.3.16. New monadic failure desugaring mechanism
- 9.3.17. Rebindable syntax and the implicit Prelude import
- 9.3.18. Postfix operators
- 9.3.19. Tuple sections
- 9.3.20. Lambda-case
- 9.3.21. Empty case alternatives
- 9.3.22. Multi-way if-expressions
- 9.3.23. Local Fixity Declarations
- 9.3.24. Import and export extensions
  - 9.3.24.1. Hiding things the imported module doesn’t export
  - 9.3.24.2. Package-qualified imports
  - 9.3.24.3. Safe imports
  - 9.3.24.4. Explicit namespaces in import/export
- 9.3.25. Summary of stolen syntax
9.4. Extensions to data types and type synonyms
- 9.4.1. Data types with no constructors
- 9.4.2. Data type contexts
- 9.4.3. Infix type constructors, classes, and type variables
- 9.4.4. Type operators
- 9.4.5. Liberalised type synonyms
- 9.4.6. Existentially quantified data constructors
- 9.4.7. Declaring data types with explicit constructor signatures
- 9.4.8. Generalised Algebraic Data Types (GADTs)
9.5. Extensions to the record system
- 9.5.1. Traditional record syntax
- 9.5.2. Record field disambiguation
- 9.5.3. Duplicate record fields
- 9.5.4. Record puns
- 9.5.5. Record wildcards
9.6. Extensions to the “deriving” mechanism
- 9.6.1. Inferred context for deriving clauses
- 9.6.2. Stand-alone deriving declarations
- 9.6.3. Deriving instances of extra classes (Data, etc.)
- 9.6.4. Deriving Functor instances
- 9.6.5. Deriving Foldable instances
- 9.6.6. Deriving Traversable instances
- 9.6.7. Deriving Typeable instances
- 9.6.8. Deriving Lift instances
- 9.6.9. Generalised derived instances for newtypes
  - 9.6.9.1. Generalising the deriving clause
  - 9.6.9.2. A more precise specification
- 9.6.10. Deriving any other class
9.7. Class and instances declarations
- 9.7.1. Class declarations
- 9.7.2. Functional dependencies
  - 9.7.2.1. Rules for functional dependencies
  - 9.7.2.2. Background on functional dependencies
    - 9.7.2.2.1. An attempt to use constructor classes
    - 9.7.2.2.2. Adding functional dependencies
- 9.7.3. Instance declarations
- 9.7.4. Overloaded string literals
- 9.7.5. Overloaded lists
9.8. Type families
- 9.8.1. Data families
- 9.8.2. Synonym families
- 9.8.3. Associated data and type families
- 9.8.4. Import and export
  - 9.8.4.1. Examples
  - 9.8.4.2. Instances
- 9.8.5. Type families and instance declarations
- 9.8.6. Injective type families
  - 9.8.6.1. Syntax of injectivity annotation
  - 9.8.6.2. Verifying injectivity annotation against type family equations
9.9. Kind polymorphism
- 9.9.1. Overview of kind polymorphism
- 9.9.2. Principles of kind inference
- 9.9.3. Polymorphic kind recursion and complete kind signatures
- 9.9.4. Kind inference in closed type families
- 9.9.5. Kind inference in class instance declarations
9.10. Datatype promotion
- 9.10.1. Motivation
- 9.10.2. Overview
- 9.10.3. Distinguishing between types and constructors
- 9.10.4. Promoted list and tuple types
- 9.10.5. Promoting existential data constructors
- 9.10.6. Promoting type operators
9.11. Type-Level Literals
- 9.11.1. Runtime Values for Type-Level Literals
- 9.11.2. Computing With Type-Level Naturals
9.12. Equality constraints
- 9.12.1. The Coercible constraint
9.13. The Constraint kind
9.14. Other type system extensions
- 9.14.1. Explicit universal quantification (forall)
- 9.14.2. The context of a type signature
- 9.14.3. Ambiguous types and the ambiguity check
- 9.14.4. Implicit parameters
- 9.14.5. Explicitly-kinded quantification
- 9.14.6. Arbitrary-rank polymorphism
- 9.14.7. Impredicative polymorphism
- 9.14.8. Lexically scoped type variables
- 9.14.9. Bindings and generalisation
9.15. Typed Holes
9.16. Partial Type Signatures
- 9.16.1. Syntax
- 9.16.2. Where can they occur?
9.17. Deferring type errors to runtime
- 9.17.1. Enabling deferring of type errors
- 9.17.2. Deferred type errors in GHCi
9.18. Template Haskell
- 9.18.1. Syntax
- 9.18.2. Using Template Haskell
- 9.18.3. Viewing Template Haskell generated code
- 9.18.4. A Template Haskell Worked Example
- 9.18.5. Using Template Haskell with Profiling
- 9.18.6. Template Haskell Quasi-quotation
9.19. Arrow notation
- 9.19.1. do-notation for commands
- 9.19.2. Conditional commands
- 9.19.3. Defining your own control structures
- 9.19.4. Primitive constructs
- 9.19.5. Differences with the paper
- 9.19.6. Portability
9.20. Bang patterns
- 9.20.1. Informal description of bang patterns
- 9.20.2. Syntax and semantics
9.21. Assertions
9.22. Static pointers
- 9.22.1. Using static pointers
- 9.22.2. Static semantics of static pointers
9.23. Pragmas
- 9.23.1. LANGUAGE pragma
- 9.23.2. OPTIONS_GHC pragma
- 9.23.3. INCLUDE pragma
- 9.23.4. WARNING and DEPRECATED pragmas
- 9.23.5. MINIMAL pragma
- 9.23.6. INLINE and NOINLINE pragmas
- 9.23.7. LINE pragma
- 9.23.8. RULES pragma
- 9.23.9. SPECIALIZE pragma
- 9.23.10. SPECIALIZE instance pragma
- 9.23.11. UNPACK pragma
- 9.23.12. NOUNPACK pragma
- 9.23.13. SOURCE pragma
- 9.23.14. OVERLAPPING, OVERLAPPABLE, OVERLAPS, and INCOHERENT pragmas
9.24. Rewrite rules
- 9.24.1. Syntax
- 9.24.2. Semantics
- 9.24.3. How rules interact with INLINE/NOINLINE pragmas
- 9.24.4. How rules interact with CONLIKE pragmas
- 9.24.5. How rules interact with class methods
- 9.24.6. List fusion
- 9.24.7. Specialisation
- 9.24.8. Controlling what’s going on in rewrite rules
9.25. Special built-in functions
9.26. Generic classes
9.27. Generic programming
- 9.27.1. Deriving representations
- 9.27.2. Writing generic functions
- 9.27.3. Unlifted representation types
- 9.27.4. Generic defaults
- 9.27.5. More information
9.28. Roles
- 9.28.1. Nominal, Representational, and Phantom
- 9.28.2. Role inference
- 9.28.3. Role annotations -XRoleAnnotations
9.29. Strict Haskell
- 9.29.1. Strict-by-default data types
- 9.29.2. Strict-by-default pattern bindings
- 9.29.3. Modularity
- 9.29.4. Recursive and polymorphic let bindings
9.30. Concurrent and Parallel Haskell
- 9.30.1. Concurrent Haskell
- 9.30.2. Software Transactional Memory
- 9.30.3. Parallel Haskell
- 9.30.4. Annotating pure code for parallelism
- 9.30.5. Data Parallel Haskell
9.31. Safe Haskell
- 9.31.1. Uses of Safe Haskell
  - 9.31.1.1. Strict type-safety (good style)
  - 9.31.1.2. Building secure systems (restricted IO Monads)
- 9.31.2. Safe Language
  - 9.31.2.1. Safe Overlapping Instances
- 9.31.3. Safe Imports
- 9.31.4. Trust and Safe Haskell Modes
- 9.31.5. Safe Haskell Inference
- 9.31.6. Safe Haskell Flag Summary
- 9.31.7. Safe Compilation