W3cubDocs

/Haskell 8

9. GHC Language Features

9.1. Language options
9.2. Unboxed types and primitive operations
- 9.2.1. Unboxed types
- 9.2.2. Unboxed type kinds
- 9.2.3. Unboxed tuples
- 9.2.4. Unboxed sums
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. Pattern guards
- 9.3.7. View patterns
- 9.3.8. n+k patterns
- 9.3.9. The recursive do-notation
  - 9.3.9.1. Recursive binding groups
  - 9.3.9.2. The mdo notation
- 9.3.10. Applicative do-notation
  - 9.3.10.1. Existential patterns and GADTs
  - 9.3.10.2. Things to watch out for
- 9.3.11. Parallel List Comprehensions
- 9.3.12. Generalised (SQL-like) List Comprehensions
- 9.3.13. Monad comprehensions
- 9.3.14. New monadic failure desugaring mechanism
- 9.3.15. Rebindable syntax and the implicit Prelude import
  - 9.3.15.1. Things unaffected by -XRebindableSyntax
- 9.3.16. Postfix operators
- 9.3.17. Tuple sections
- 9.3.18. Lambda-case
- 9.3.19. Empty case alternatives
- 9.3.20. Multi-way if-expressions
- 9.3.21. Local Fixity Declarations
- 9.3.22. Import and export extensions
  - 9.3.22.1. Hiding things the imported module doesn’t export
  - 9.3.22.2. Package-qualified imports
  - 9.3.22.3. Safe imports
  - 9.3.22.4. Explicit namespaces in import/export
- 9.3.23. 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.5.6. Record field selector polymorphism
  - 9.5.6.1. Solving HasField constraints
  - 9.5.6.2. Virtual record fields
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 Data instances
- 9.6.8. Deriving Typeable instances
- 9.6.9. Deriving Lift instances
- 9.6.10. Generalised derived instances for newtypes
- 9.6.11. Deriving any other class
- 9.6.12. Deriving strategies
9.7. Pattern synonyms
- 9.7.1. Record Pattern Synonyms
- 9.7.2. Syntax and scoping of pattern synonyms
- 9.7.3. Import and export of pattern synonyms
- 9.7.4. Typing of pattern synonyms
- 9.7.5. Matching of pattern synonyms
9.8. Class and instances declarations
- 9.8.1. Class declarations
- 9.8.2. Functional dependencies
  - 9.8.2.1. Rules for functional dependencies
  - 9.8.2.2. Background on functional dependencies
    - 9.8.2.2.1. An attempt to use constructor classes
    - 9.8.2.2.2. Adding functional dependencies
- 9.8.3. Instance declarations
- 9.8.4. Overloaded string literals
- 9.8.5. Overloaded labels
- 9.8.6. Overloaded lists
- 9.8.7. Undecidable (or recursive) superclasses
9.9. Type families
- 9.9.1. Data families
- 9.9.2. Synonym families
- 9.9.3. Wildcards on the LHS of data and type family instances
- 9.9.4. Associated data and type families
- 9.9.5. Import and export
  - 9.9.5.1. Examples
  - 9.9.5.2. Instances
- 9.9.6. Type families and instance declarations
- 9.9.7. Injective type families
  - 9.9.7.1. Syntax of injectivity annotation
  - 9.9.7.2. Verifying injectivity annotation against type family equations
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.11. Kind polymorphism and Type-in-Type
- 9.11.1. The difference between -XTypeInType and -XPolyKinds
- 9.11.2. Overview of kind polymorphism
- 9.11.3. Overview of Type-in-Type
- 9.11.4. Principles of kind inference
- 9.11.5. Complete user-supplied kind signatures and polymorphic recursion
- 9.11.6. Kind inference in closed type families
- 9.11.7. Kind inference in class instance declarations
- 9.11.8. Kind inference in type signatures
- 9.11.9. Explicit kind quantification
- 9.11.10. Kind-indexed GADTs
- 9.11.11. Constraints in kinds
- 9.11.12. The kind *
- 9.11.13. Inferring dependency in datatype declarations
- 9.11.14. Kind defaulting without -XPolyKinds
- 9.11.15. Pretty-printing in the presence of kind polymorphism
9.12. Levity polymorphism
- 9.12.1. No levity-polymorphic variables or arguments
- 9.12.2. Levity-polymorphic bottoms
- 9.12.3. Printing levity-polymorphic types
9.13. Type-Level Literals
- 9.13.1. Runtime Values for Type-Level Literals
- 9.13.2. Computing With Type-Level Naturals
9.14. Constraints in types
- 9.14.1. Equality constraints
- 9.14.2. Heterogeneous equality
- 9.14.3. Unlifted heterogeneous equality
- 9.14.4. The Coercible constraint
- 9.14.5. The Constraint kind
9.15. Extensions to type signatures
- 9.15.1. Explicit universal quantification (forall)
- 9.15.2. The context of a type signature
- 9.15.3. Ambiguous types and the ambiguity check
- 9.15.4. Explicitly-kinded quantification
9.16. Lexically scoped type variables
- 9.16.1. Overview
- 9.16.2. Declaration type signatures
- 9.16.3. Expression type signatures
- 9.16.4. Pattern type signatures
- 9.16.5. Class and instance declarations
9.17. Bindings and generalisation
- 9.17.1. Switching off the dreaded Monomorphism Restriction
- 9.17.2. Let-generalisation
- 9.17.3. Kind generalisation
9.18. Visible type application
9.19. Implicit parameters
- 9.19.1. Implicit-parameter type constraints
- 9.19.2. Implicit-parameter bindings
- 9.19.3. Implicit parameters and polymorphic recursion
- 9.19.4. Implicit parameters and monomorphism
9.20. Arbitrary-rank polymorphism
- 9.20.1. Examples
- 9.20.2. Type inference
- 9.20.3. Implicit quantification
9.21. Impredicative polymorphism
9.22. Typed Holes
9.23. Partial Type Signatures
- 9.23.1. Syntax
- 9.23.2. Where can they occur?
9.24. Custom compile-time errors
9.25. Deferring type errors to runtime
- 9.25.1. Enabling deferring of type errors
- 9.25.2. Deferred type errors in GHCi
9.26. Template Haskell
- 9.26.1. Syntax
- 9.26.2. Using Template Haskell
- 9.26.3. Viewing Template Haskell generated code
- 9.26.4. A Template Haskell Worked Example
- 9.26.5. Using Template Haskell with Profiling
- 9.26.6. Template Haskell Quasi-quotation
9.27. Arrow notation
- 9.27.1. do-notation for commands
- 9.27.2. Conditional commands
- 9.27.3. Defining your own control structures
- 9.27.4. Primitive constructs
- 9.27.5. Differences with the paper
- 9.27.6. Portability
9.28. Bang patterns and Strict Haskell
- 9.28.1. Bang patterns
- 9.28.2. Strict-by-default data types
- 9.28.3. Strict-by-default pattern bindings
- 9.28.4. Modularity
- 9.28.5. Dynamic semantics of bang patterns
9.29. Assertions
9.30. Static pointers
- 9.30.1. Using static pointers
- 9.30.2. Static semantics of static pointers
9.31. Pragmas
- 9.31.1. LANGUAGE pragma
- 9.31.2. OPTIONS_GHC pragma
- 9.31.3. INCLUDE pragma
- 9.31.4. WARNING and DEPRECATED pragmas
- 9.31.5. MINIMAL pragma
- 9.31.6. INLINE and NOINLINE pragmas
- 9.31.7. LINE pragma
- 9.31.8. COLUMN pragma
- 9.31.9. RULES pragma
- 9.31.10. SPECIALIZE pragma
- 9.31.11. SPECIALIZE instance pragma
- 9.31.12. UNPACK pragma
- 9.31.13. NOUNPACK pragma
- 9.31.14. SOURCE pragma
- 9.31.15. COMPLETE pragmas
- 9.31.16. OVERLAPPING, OVERLAPPABLE, OVERLAPS, and INCOHERENT pragmas
9.32. Rewrite rules
- 9.32.1. Syntax
- 9.32.2. Semantics
- 9.32.3. How rules interact with INLINE/NOINLINE pragmas
- 9.32.4. How rules interact with CONLIKE pragmas
- 9.32.5. How rules interact with class methods
- 9.32.6. List fusion
- 9.32.7. Specialisation
- 9.32.8. Controlling what’s going on in rewrite rules
9.33. Special built-in functions
9.34. Generic classes
9.35. Generic programming
- 9.35.1. Deriving representations
- 9.35.2. Writing generic functions
- 9.35.3. Unlifted representation types
- 9.35.4. Generic defaults
- 9.35.5. More information
9.36. Roles
- 9.36.1. Nominal, Representational, and Phantom
- 9.36.2. Role inference
- 9.36.3. Role annotations
9.37. HasCallStack
- 9.37.1. Compared with other sources of stack traces
9.38. Concurrent and Parallel Haskell
- 9.38.1. Concurrent Haskell
- 9.38.2. Software Transactional Memory
- 9.38.3. Parallel Haskell
- 9.38.4. Annotating pure code for parallelism
- 9.38.5. Data Parallel Haskell
9.39. Safe Haskell
- 9.39.1. Uses of Safe Haskell
  - 9.39.1.1. Strict type-safety (good style)
  - 9.39.1.2. Building secure systems (restricted IO Monads)
- 9.39.2. Safe Language
  - 9.39.2.1. Safe Overlapping Instances
- 9.39.3. Safe Imports
- 9.39.4. Trust and Safe Haskell Modes
- 9.39.5. Safe Haskell Inference
- 9.39.6. Safe Haskell Flag Summary
- 9.39.7. Safe Compilation

© 2002–2007 The University Court of the University of Glasgow. All rights reserved.
Licensed under the Glasgow Haskell Compiler License.
https://downloads.haskell.org/~ghc/8.2.1/docs/html/users_guide/lang.html