15. GHC Language Features

• 15.1. Language options
• 15.2. Unboxed types and primitive operations
  • 15.2.1. Unboxed types
  • 15.2.2. Unboxed type kinds
  • 15.2.3. Unboxed tuples
  • 15.2.4. Unboxed sums
  • 15.2.5. Unlifted Newtypes
• 15.3. Syntactic extensions
  • 15.3.1. Unicode syntax
  • 15.3.2. The magic hash
  • 15.3.3. Negative literals
  • 15.3.4. Fractional looking integer literals
  • 15.3.5. Binary integer literals
  • 15.3.6. Hexadecimal floating point literals
  • 15.3.7. Numeric underscores
  • 15.3.8. Pattern guards
  • 15.3.9. View patterns
  • 15.3.10. n+k patterns
  • 15.3.11. The recursive do-notation
    • 15.3.11.1. Recursive binding groups
    • 15.3.11.2. The mdo notation
  • 15.3.12. Applicative do-notation
    • 15.3.12.1. Strict patterns
    • 15.3.12.2. Things to watch out for
  • 15.3.13. Parallel List Comprehensions
  • 15.3.14. Generalised (SQL-like) List Comprehensions
  • 15.3.15. Monad comprehensions
  • 15.3.16. New monadic failure desugaring mechanism
  • 15.3.17. Rebindable syntax and the implicit Prelude import
    • 15.3.17.1. Things unaffected by RebindableSyntax
  • 15.3.18. Postfix operators
  • 15.3.19. Tuple sections
  • 15.3.20. Lambda-case
  • 15.3.21. Empty case alternatives
  • 15.3.22. Multi-way if-expressions
  • 15.3.23. Local Fixity Declarations
  • 15.3.24. Import and export extensions
    • 15.3.24.1. Hiding things the imported module doesn’t export
    • 15.3.24.2. Package-qualified imports
    • 15.3.24.3. Safe imports
    • 15.3.24.4. Explicit namespaces in import/export
    • 15.3.24.5. Writing qualified in postpositive position
  • 15.3.25. More liberal syntax for function arguments
    • 15.3.25.1. Changes to the grammar
  • 15.3.26. Summary of stolen syntax
• 15.4. Extensions to data types and type synonyms
  • 15.4.1. Data types with no constructors
  • 15.4.2. Data type contexts
  • 15.4.3. Infix type constructors, classes, and type variables
  • 15.4.4. Type operators
  • 15.4.5. Liberalised type synonyms
  • 15.4.6. Existentially quantified data constructors
    • 15.4.6.1. Why existential?
    • 15.4.6.2. Existentials and type classes
    • 15.4.6.3. Record Constructors
    • 15.4.6.4. Restrictions
  • 15.4.7. Declaring data types with explicit constructor signatures
  • 15.4.8. Generalised Algebraic Data Types (GADTs)
• 15.5. Extensions to the record system
  • 15.5.1. Traditional record syntax
  • 15.5.2. Record field disambiguation
  • 15.5.3. Duplicate record fields
    • 15.5.3.1. Selector functions
    • 15.5.3.2. Record updates
    • 15.5.3.3. Import and export of record fields
  • 15.5.4. Record puns
  • 15.5.5. Record wildcards
  • 15.5.6. Record field selector polymorphism
    • 15.5.6.1. Solving HasField constraints
    • 15.5.6.2. Virtual record fields
• 15.6. Extensions to the “deriving” mechanism
  • 15.6.1. Deriving instances for empty data types
  • 15.6.2. Inferred context for deriving clauses
  • 15.6.3. Stand-alone deriving declarations
  • 15.6.4. Deriving instances of extra classes (Data, etc.)
    • 15.6.4.1. Deriving Functor instances
    • 15.6.4.2. Deriving Foldable instances
    • 15.6.4.3. Deriving Traversable instances
    • 15.6.4.4. Deriving Data instances
    • 15.6.4.5. Deriving Typeable instances
    • 15.6.4.6. Deriving Lift instances
  • 15.6.5. Generalised derived instances for newtypes
    • 15.6.5.1. Generalising the deriving clause
    • 15.6.5.2. A more precise specification
    • 15.6.5.3. Associated type families
  • 15.6.6. Deriving any other class
  • 15.6.7. Deriving strategies
    • 15.6.7.1. Default deriving strategy
  • 15.6.8. Deriving via
• 15.7. Pattern synonyms
  • 15.7.1. Record Pattern Synonyms
  • 15.7.2. Syntax and scoping of pattern synonyms
  • 15.7.3. Import and export of pattern synonyms
  • 15.7.4. Typing of pattern synonyms
  • 15.7.5. Matching of pattern synonyms
• 15.8. Class and instances declarations
  • 15.8.1. Class declarations
    • 15.8.1.1. Multi-parameter type classes
    • 15.8.1.2. The superclasses of a class declaration
    • 15.8.1.3. Constrained class method types
    • 15.8.1.4. Default method signatures
    • 15.8.1.5. Nullary type classes
  • 15.8.2. Functional dependencies
    • 15.8.2.1. Rules for functional dependencies
    • 15.8.2.2. Background on functional dependencies
      • 15.8.2.2.1. An attempt to use constructor classes
      • 15.8.2.2.2. Adding functional dependencies
  • 15.8.3. Instance declarations
    • 15.8.3.1. Instance resolution
    • 15.8.3.2. Relaxed rules for the instance head
    • 15.8.3.3. Relaxed rules for instance contexts
    • 15.8.3.4. Instance termination rules
    • 15.8.3.5. Undecidable instances
    • 15.8.3.6. Overlapping instances
    • 15.8.3.7. Instance signatures: type signatures in instance declarations
  • 15.8.4. Overloaded string literals
  • 15.8.5. Overloaded labels
  • 15.8.6. Overloaded lists
    • 15.8.6.1. The IsList class
    • 15.8.6.2. Rebindable syntax
    • 15.8.6.3. Defaulting
    • 15.8.6.4. Speculation about the future
  • 15.8.7. Undecidable (or recursive) superclasses
• 15.9. Type families
  • 15.9.1. Data families
    • 15.9.1.1. Data family declarations
    • 15.9.1.2. Data instance declarations
    • 15.9.1.3. Overlap of data instances
  • 15.9.2. Synonym families
    • 15.9.2.1. Type family declarations
    • 15.9.2.2. Type instance declarations
    • 15.9.2.3. Closed type families
    • 15.9.2.4. Type family examples
    • 15.9.2.5. Compatibility and apartness of type family equations
    • 15.9.2.6. Decidability of type synonym instances
  • 15.9.3. Wildcards on the LHS of data and type family instances
  • 15.9.4. Associated data and type families
    • 15.9.4.1. Associated instances
    • 15.9.4.2. Associated type synonym defaults
    • 15.9.4.3. Scoping of class parameters
    • 15.9.4.4. Instance contexts and associated type and data instances
  • 15.9.5. Import and export
    • 15.9.5.1. Examples
    • 15.9.5.2. Instances
  • 15.9.6. Type families and instance declarations
  • 15.9.7. Injective type families
    • 15.9.7.1. Syntax of injectivity annotation
    • 15.9.7.2. Verifying the injectivity annotation against type family equations
• 15.10. Datatype promotion
  • 15.10.1. Motivation
  • 15.10.2. Overview
  • 15.10.3. Distinguishing between types and constructors
  • 15.10.4. Promoted list and tuple types
  • 15.10.5. Promoting existential data constructors
• 15.11. Kind polymorphism
  • 15.11.1. Overview of kind polymorphism
  • 15.11.2. Overview of Type-in-Type
  • 15.11.3. Principles of kind inference
  • 15.11.4. Inferring the order of variables in a type/class declaration
  • 15.11.5. Complete user-supplied kind signatures and polymorphic recursion
  • 15.11.6. Standalone kind signatures and polymorphic recursion
  • 15.11.7. Standalone kind signatures and declaration headers
  • 15.11.8. Kind inference in closed type families
  • 15.11.9. Kind inference in class instance declarations
  • 15.11.10. Kind inference in type signatures
  • 15.11.11. Explicit kind quantification
  • 15.11.12. Implicit quantification in type synonyms and type family instances
  • 15.11.13. Kind-indexed GADTs
  • 15.11.14. Higher-rank kinds
  • 15.11.15. Constraints in kinds
  • 15.11.16. The kind Type
  • 15.11.17. Inferring dependency in datatype declarations
  • 15.11.18. Inferring dependency in user-written foralls
  • 15.11.19. Kind defaulting without PolyKinds
  • 15.11.20. Pretty-printing in the presence of kind polymorphism
• 15.12. Levity polymorphism
  • 15.12.1. No levity-polymorphic variables or arguments
  • 15.12.2. Levity-polymorphic bottoms
  • 15.12.3. Printing levity-polymorphic types
• 15.13. Type-Level Literals
  • 15.13.1. Runtime Values for Type-Level Literals
  • 15.13.2. Computing With Type-Level Naturals
• 15.14. Equality constraints, Coercible, and the kind Constraint
  • 15.14.1. Equality constraints
  • 15.14.2. Heterogeneous equality
  • 15.14.3. Unlifted heterogeneous equality
  • 15.14.4. The Coercible constraint
  • 15.14.5. The Constraint kind
• 15.15. Quantified constraints
  • 15.15.1. Motivation
  • 15.15.2. Syntax changes
  • 15.15.3. Typing changes
  • 15.15.4. Superclasses
  • 15.15.5. Overlap
  • 15.15.6. Instance lookup
  • 15.15.7. Termination
  • 15.15.8. Coherence
• 15.16. Extensions to type signatures
  • 15.16.1. Explicit universal quantification (forall)
  • 15.16.2. The context of a type signature
  • 15.16.3. Ambiguous types and the ambiguity check
  • 15.16.4. Explicitly-kinded quantification
• 15.17. Lexically scoped type variables
  • 15.17.1. Overview
  • 15.17.2. Declaration type signatures
  • 15.17.3. Expression type signatures
  • 15.17.4. Pattern type signatures
  • 15.17.5. Class and instance declarations
• 15.18. Bindings and generalisation
  • 15.18.1. Switching off the dreaded Monomorphism Restriction
  • 15.18.2. Let-generalisation
• 15.19. Visible type application
  • 15.19.1. Inferred vs. specified type variables
  • 15.19.2. Ordering of specified variables
• 15.20. Implicit parameters
  • 15.20.1. Implicit-parameter type constraints
  • 15.20.2. Implicit-parameter bindings
  • 15.20.3. Implicit parameters and polymorphic recursion
  • 15.20.4. Implicit parameters and monomorphism
• 15.21. Arbitrary-rank polymorphism
  • 15.21.1. Examples
  • 15.21.2. Type inference
  • 15.21.3. Implicit quantification
• 15.22. Impredicative polymorphism
• 15.23. Typed Holes
  • 15.23.1. Valid Hole Fits
    • 15.23.1.1. Refinement Hole Fits
    • 15.23.1.2. Sorting Valid Hole Fits
• 15.24. Partial Type Signatures
  • 15.24.1. Syntax
    • 15.24.1.1. Type Wildcards
    • 15.24.1.2. Named Wildcards
    • 15.24.1.3. Extra-Constraints Wildcard
  • 15.24.2. Where can they occur?
• 15.25. Custom compile-time errors
• 15.26. Deferring type errors to runtime
  • 15.26.1. Enabling deferring of type errors
  • 15.26.2. Deferred type errors in GHCi
  • 15.26.3. Limitations of deferred type errors
• 15.27. Template Haskell
  • 15.27.1. Syntax
  • 15.27.2. Using Template Haskell
  • 15.27.3. Viewing Template Haskell generated code
  • 15.27.4. A Template Haskell Worked Example
  • 15.27.5. Using Template Haskell with Profiling
  • 15.27.6. Template Haskell Quasi-quotation
• 15.28. Arrow notation
  • 15.28.1. do-notation for commands
  • 15.28.2. Conditional commands
  • 15.28.3. Defining your own control structures
  • 15.28.4. Primitive constructs
  • 15.28.5. Differences with the paper
  • 15.28.6. Portability
• 15.29. Bang patterns and Strict Haskell
  • 15.29.1. Bang patterns
  • 15.29.2. Strict-by-default data types
  • 15.29.3. Strict-by-default pattern bindings
  • 15.29.4. Modularity
  • 15.29.5. Dynamic semantics of bang patterns
• 15.30. Assertions
• 15.31. Static pointers
  • 15.31.1. Using static pointers
  • 15.31.2. Static semantics of static pointers
• 15.32. Pragmas
  • 15.32.1. LANGUAGE pragma
  • 15.32.2. OPTIONS_GHC pragma
  • 15.32.3. INCLUDE pragma
  • 15.32.4. WARNING and DEPRECATED pragmas
  • 15.32.5. MINIMAL pragma
  • 15.32.6. INLINE and NOINLINE pragmas
    • 15.32.6.1. INLINE pragma
    • 15.32.6.2. INLINABLE pragma
    • 15.32.6.3. NOINLINE pragma
    • 15.32.6.4. CONLIKE modifier
    • 15.32.6.5. Phase control
  • 15.32.7. LINE pragma
  • 15.32.8. COLUMN pragma
  • 15.32.9. RULES pragma
  • 15.32.10. SPECIALIZE pragma
    • 15.32.10.1. SPECIALIZE INLINE
    • 15.32.10.2. SPECIALIZE for imported functions
  • 15.32.11. SPECIALIZE instance pragma
  • 15.32.12. UNPACK pragma
  • 15.32.13. NOUNPACK pragma
  • 15.32.14. SOURCE pragma
  • 15.32.15. COMPLETE pragmas
  • 15.32.16. OVERLAPPING, OVERLAPPABLE, OVERLAPS, and INCOHERENT pragmas
• 15.33. Rewrite rules
  • 15.33.1. Syntax
  • 15.33.2. Semantics
  • 15.33.3. How rules interact with INLINE/NOINLINE pragmas
  • 15.33.4. How rules interact with CONLIKE pragmas
  • 15.33.5. How rules interact with class methods
  • 15.33.6. List fusion
  • 15.33.7. Specialisation
  • 15.33.8. Controlling what’s going on in rewrite rules
• 15.34. Special built-in functions
• 15.35. Generic classes
• 15.36. Generic programming
  • 15.36.1. Deriving representations
  • 15.36.2. Writing generic functions
  • 15.36.3. Unlifted representation types
  • 15.36.4. Generic defaults
  • 15.36.5. More information
• 15.37. Roles
  • 15.37.1. Nominal, Representational, and Phantom
  • 15.37.2. Role inference
  • 15.37.3. Role annotations
• 15.38. HasCallStack
  • 15.38.1. Compared with other sources of stack traces
• 15.39. Concurrent and Parallel Haskell
  • 15.39.1. Concurrent Haskell
  • 15.39.2. Software Transactional Memory
  • 15.39.3. Parallel Haskell
  • 15.39.4. Annotating pure code for parallelism
• 15.40. Safe Haskell
  • 15.40.1. Uses of Safe Haskell
    • 15.40.1.1. Strict type-safety (good style)
    • 15.40.1.2. Building secure systems (restricted IO Monads)
  • 15.40.2. Safe Language
    • 15.40.2.1. Safe Overlapping Instances
  • 15.40.3. Safe Imports
  • 15.40.4. Trust and Safe Haskell Modes
    • 15.40.4.1. Trust check (-fpackage-trust disabled)
    • 15.40.4.2. Trust check (-fpackage-trust enabled)
    • 15.40.4.3. Example
    • 15.40.4.4. Trustworthy Requirements
    • 15.40.4.5. Package Trust
  • 15.40.5. Safe Haskell Inference
  • 15.40.6. Safe Haskell Flag Summary
  • 15.40.7. Safe Compilation