Glasgow Haskell Compiler User's Guide

11. GHC Language Features¶

11.1. Language options
11.2. Unboxed types and primitive operations
- 11.2.1. Unboxed types
- 11.2.2. Unboxed type kinds
- 11.2.3. Unboxed tuples
- 11.2.4. Unboxed sums
11.3. Syntactic extensions
- 11.3.1. Unicode syntax
- 11.3.2. The magic hash
- 11.3.3. Negative literals
- 11.3.4. Fractional looking integer literals
- 11.3.5. Binary integer literals
- 11.3.6. Hexadecimal floating point literals
- 11.3.7. Numeric underscores
- 11.3.8. Pattern guards
- 11.3.9. View patterns
- 11.3.10. n+k patterns
- 11.3.11. The recursive do-notation
  - 11.3.11.1. Recursive binding groups
  - 11.3.11.2. The mdo notation
- 11.3.12. Applicative do-notation
  - 11.3.12.1. Strict patterns
  - 11.3.12.2. Things to watch out for
- 11.3.13. Parallel List Comprehensions
- 11.3.14. Generalised (SQL-like) List Comprehensions
- 11.3.15. Monad comprehensions
- 11.3.16. New monadic failure desugaring mechanism
- 11.3.17. Rebindable syntax and the implicit Prelude import
  - 11.3.17.1. Things unaffected by RebindableSyntax
- 11.3.18. Postfix operators
- 11.3.19. Tuple sections
- 11.3.20. Lambda-case
- 11.3.21. Empty case alternatives
- 11.3.22. Multi-way if-expressions
- 11.3.23. Local Fixity Declarations
- 11.3.24. Import and export extensions
  - 11.3.24.1. Hiding things the imported module doesn’t export
  - 11.3.24.2. Package-qualified imports
  - 11.3.24.3. Safe imports
  - 11.3.24.4. Explicit namespaces in import/export
- 11.3.25. More liberal syntax for function arguments
  - 11.3.25.1. Changes to the grammar
- 11.3.26. Summary of stolen syntax
11.4. Extensions to data types and type synonyms
- 11.4.1. Data types with no constructors
- 11.4.2. Data type contexts
- 11.4.3. Infix type constructors, classes, and type variables
- 11.4.4. Type operators
- 11.4.5. Liberalised type synonyms
- 11.4.6. Existentially quantified data constructors
- 11.4.7. Declaring data types with explicit constructor signatures
- 11.4.8. Generalised Algebraic Data Types (GADTs)
11.5. Extensions to the record system
- 11.5.1. Traditional record syntax
- 11.5.2. Record field disambiguation
- 11.5.3. Duplicate record fields
- 11.5.4. Record puns
- 11.5.5. Record wildcards
- 11.5.6. Record field selector polymorphism
  - 11.5.6.1. Solving HasField constraints
  - 11.5.6.2. Virtual record fields
11.6. Extensions to the “deriving” mechanism
- 11.6.1. Deriving instances for empty data types
- 11.6.2. Inferred context for deriving clauses
- 11.6.3. Stand-alone deriving declarations
- 11.6.4. Deriving instances of extra classes (Data, etc.)
- 11.6.5. Generalised derived instances for newtypes
- 11.6.6. Deriving any other class
- 11.6.7. Deriving strategies
  - 11.6.7.1. Default deriving strategy
- 11.6.8. Deriving via
11.7. Pattern synonyms
- 11.7.1. Record Pattern Synonyms
- 11.7.2. Syntax and scoping of pattern synonyms
- 11.7.3. Import and export of pattern synonyms
- 11.7.4. Typing of pattern synonyms
- 11.7.5. Matching of pattern synonyms
11.8. Class and instances declarations
- 11.8.1. Class declarations
- 11.8.2. Functional dependencies
  - 11.8.2.1. Rules for functional dependencies
  - 11.8.2.2. Background on functional dependencies
    - 11.8.2.2.1. An attempt to use constructor classes
    - 11.8.2.2.2. Adding functional dependencies
- 11.8.3. Instance declarations
- 11.8.4. Overloaded string literals
- 11.8.5. Overloaded labels
- 11.8.6. Overloaded lists
- 11.8.7. Undecidable (or recursive) superclasses
11.9. Type families
- 11.9.1. Data families
- 11.9.2. Synonym families
- 11.9.3. Wildcards on the LHS of data and type family instances
- 11.9.4. Associated data and type families
- 11.9.5. Import and export
  - 11.9.5.1. Examples
  - 11.9.5.2. Instances
- 11.9.6. Type families and instance declarations
- 11.9.7. Injective type families
  - 11.9.7.1. Syntax of injectivity annotation
  - 11.9.7.2. Verifying injectivity annotation against type family equations
11.10. Datatype promotion
- 11.10.1. Motivation
- 11.10.2. Overview
- 11.10.3. Distinguishing between types and constructors
- 11.10.4. Promoted list and tuple types
- 11.10.5. Promoting existential data constructors
11.11. Kind polymorphism
- 11.11.1. Overview of kind polymorphism
- 11.11.2. Overview of Type-in-Type
- 11.11.3. Principles of kind inference
- 11.11.4. Inferring the order of variables in a type/class declaration
- 11.11.5. Complete user-supplied kind signatures and polymorphic recursion
- 11.11.6. Kind inference in closed type families
- 11.11.7. Kind inference in class instance declarations
- 11.11.8. Kind inference in type signatures
- 11.11.9. Explicit kind quantification
- 11.11.10. Kind-indexed GADTs
- 11.11.11. Higher-rank kinds
- 11.11.12. The kind Type
- 11.11.13. Inferring dependency in datatype declarations
- 11.11.14. Inferring dependency in user-written foralls
- 11.11.15. Kind defaulting without PolyKinds
- 11.11.16. Pretty-printing in the presence of kind polymorphism
11.12. Levity polymorphism
- 11.12.1. No levity-polymorphic variables or arguments
- 11.12.2. Levity-polymorphic bottoms
- 11.12.3. Printing levity-polymorphic types
11.13. Type-Level Literals
- 11.13.1. Runtime Values for Type-Level Literals
- 11.13.2. Computing With Type-Level Naturals
11.14. Equality constraints, Coercible, and the kind Constraint
- 11.14.1. Equality constraints
- 11.14.2. Heterogeneous equality
- 11.14.3. Unlifted heterogeneous equality
- 11.14.4. The Coercible constraint
- 11.14.5. The Constraint kind
11.15. Quantified constraints
- 11.15.1. Motivation
- 11.15.2. Syntax changes
- 11.15.3. Typing changes
- 11.15.4. Superclasses
- 11.15.5. Overlap
- 11.15.6. Instance lookup
- 11.15.7. Termination
- 11.15.8. Coherence
11.16. Extensions to type signatures
- 11.16.1. Explicit universal quantification (forall)
- 11.16.2. The context of a type signature
- 11.16.3. Ambiguous types and the ambiguity check
- 11.16.4. Explicitly-kinded quantification
11.17. Lexically scoped type variables
- 11.17.1. Overview
- 11.17.2. Declaration type signatures
- 11.17.3. Expression type signatures
- 11.17.4. Pattern type signatures
- 11.17.5. Class and instance declarations
11.18. Bindings and generalisation
- 11.18.1. Switching off the dreaded Monomorphism Restriction
- 11.18.2. Let-generalisation
11.19. Visible type application
- 11.19.1. Inferred vs. specified type variables
- 11.19.2. Ordering of specified variables
11.20. Implicit parameters
- 11.20.1. Implicit-parameter type constraints
- 11.20.2. Implicit-parameter bindings
- 11.20.3. Implicit parameters and polymorphic recursion
- 11.20.4. Implicit parameters and monomorphism
11.21. Arbitrary-rank polymorphism
- 11.21.1. Examples
- 11.21.2. Type inference
- 11.21.3. Implicit quantification
11.22. Impredicative polymorphism
11.23. Typed Holes
- 11.23.1. Valid Hole Fits
  - 11.23.1.1. Refinement Hole Fits
  - 11.23.1.2. Sorting Valid Hole Fits
11.24. Partial Type Signatures
- 11.24.1. Syntax
- 11.24.2. Where can they occur?
11.25. Custom compile-time errors
11.26. Deferring type errors to runtime
- 11.26.1. Enabling deferring of type errors
- 11.26.2. Deferred type errors in GHCi
- 11.26.3. Limitations of deferred type errors
11.27. Template Haskell
- 11.27.1. Syntax
- 11.27.2. Using Template Haskell
- 11.27.3. Viewing Template Haskell generated code
- 11.27.4. A Template Haskell Worked Example
- 11.27.5. Using Template Haskell with Profiling
- 11.27.6. Template Haskell Quasi-quotation
11.28. Arrow notation
- 11.28.1. do-notation for commands
- 11.28.2. Conditional commands
- 11.28.3. Defining your own control structures
- 11.28.4. Primitive constructs
- 11.28.5. Differences with the paper
- 11.28.6. Portability
11.29. Bang patterns and Strict Haskell
- 11.29.1. Bang patterns
- 11.29.2. Strict-by-default data types
- 11.29.3. Strict-by-default pattern bindings
- 11.29.4. Modularity
- 11.29.5. Dynamic semantics of bang patterns
11.30. Assertions
11.31. Static pointers
- 11.31.1. Using static pointers
- 11.31.2. Static semantics of static pointers
11.32. Pragmas
- 11.32.1. LANGUAGE pragma
- 11.32.2. OPTIONS_GHC pragma
- 11.32.3. INCLUDE pragma
- 11.32.4. WARNING and DEPRECATED pragmas
- 11.32.5. MINIMAL pragma
- 11.32.6. INLINE and NOINLINE pragmas
- 11.32.7. LINE pragma
- 11.32.8. COLUMN pragma
- 11.32.9. RULES pragma
- 11.32.10. SPECIALIZE pragma
  - 11.32.10.1. SPECIALIZE INLINE
  - 11.32.10.2. SPECIALIZE for imported functions
- 11.32.11. SPECIALIZE instance pragma
- 11.32.12. UNPACK pragma
- 11.32.13. NOUNPACK pragma
- 11.32.14. SOURCE pragma
- 11.32.15. COMPLETE pragmas
- 11.32.16. Disambiguating between multiple COMPLETE pragmas
- 11.32.17. OVERLAPPING, OVERLAPPABLE, OVERLAPS, and INCOHERENT pragmas
11.33. Rewrite rules
- 11.33.1. Syntax
- 11.33.2. Semantics
- 11.33.3. How rules interact with INLINE/NOINLINE pragmas
- 11.33.4. How rules interact with CONLIKE pragmas
- 11.33.5. How rules interact with class methods
- 11.33.6. List fusion
- 11.33.7. Specialisation
- 11.33.8. Controlling what’s going on in rewrite rules
11.34. Special built-in functions
11.35. Generic classes
11.36. Generic programming
- 11.36.1. Deriving representations
- 11.36.2. Writing generic functions
- 11.36.3. Unlifted representation types
- 11.36.4. Generic defaults
- 11.36.5. More information
11.37. Roles
- 11.37.1. Nominal, Representational, and Phantom
- 11.37.2. Role inference
- 11.37.3. Role annotations
11.38. HasCallStack
- 11.38.1. Compared with other sources of stack traces
11.39. Concurrent and Parallel Haskell
- 11.39.1. Concurrent Haskell
- 11.39.2. Software Transactional Memory
- 11.39.3. Parallel Haskell
- 11.39.4. Annotating pure code for parallelism
11.40. Safe Haskell
- 11.40.1. Uses of Safe Haskell
  - 11.40.1.1. Strict type-safety (good style)
  - 11.40.1.2. Building secure systems (restricted IO Monads)
- 11.40.2. Safe Language
  - 11.40.2.1. Safe Overlapping Instances
- 11.40.3. Safe Imports
- 11.40.4. Trust and Safe Haskell Modes
- 11.40.5. Safe Haskell Inference
- 11.40.6. Safe Haskell Flag Summary
- 11.40.7. Safe Compilation