6.1.2. Overview of all language extensions — Glasgow Haskell Compiler 9.14.0.20251028 User's Guide

# 6.1.2. Overview of all language extensions

GHC supports these language extensions:

Extension | Description
--- | ---
`AllowAmbiguousTypes` | Allow the user to write ambiguous types, and the type inference engine to infer them.
`ApplicativeDo` | Allow do-notation statements to be desugared via `Applicative`.
`Arrows` | Allow arrow notation (e.g. `proc`)
`BangPatterns` | Allow bang pattern syntax.
`BinaryLiterals` | Allow binary literal syntax.
`BlockArguments` | Allow `do` blocks and other constructs as function arguments.
`CApiFFI` | Allow `foreign import`s to be declared with the `capi` calling convention.
`ConstrainedClassMethods` | Allow class methods to have non-empty contexts.
`ConstraintKinds` | Allow constraints to be used as types of kind `Constraint`.
`CPP` | Resolve C preprocessor directives.
`CUSKs` | Detect complete user-supplied kind signatures.
`DataKinds` | Allow use of data constructors in types.
`DatatypeContexts` | Allow contexts on `data` types.
`DeepSubsumption` | Use GHC's deep subsumption checking.
`DefaultSignatures` | Allow default signatures for typeclass methods.
`DeriveAnyClass` | Allow `deriving` syntax to be used for any class.
`DeriveDataTypeable` | Allow deriving for the `Data` class.
`DeriveFoldable` | Allow deriving for the `Foldable` class.
`DeriveFunctor` | Allow deriving for the `Functor` class.
`DeriveGeneric` | Allow deriving of `Generic` instances.
`DeriveLift` | Allow deriving for the `Lift` class
`DeriveTraversable` | Allow deriving for the `Traversable` class.
`DerivingStrategies` | Allow use of instance deriving strategies.
`DerivingVia` | Allow deriving instances `via` types of the same runtime representation.
`DisambiguateRecordFields` | Automatically disambiguate some record field references.
`DoAndIfThenElse` | Allow semicolons in `if` expressions.
`DuplicateRecordFields` | Allow definition of record types with identically-named fields.
`EmptyCase` | Allow `case` expressions with no alternatives.
`EmptyDataDecls` | Allow definition of empty `data` types.
`EmptyDataDeriving` | Allow deriving instances of standard type classes for empty data types.
`ExistentialQuantification` | Allow existentially quantified type variables in types.
`ExplicitForAll` | Allow explicit universal quantification.
`ExplicitLevelImports` | Allow explicit level imports in Template Haskell.
`ExplicitNamespaces` | Allow use of the `type` and `data` keywords to specify the namespace of entries in import/export lists and in other contexts.
`ExtendedDefaultRules` | Use GHCi's extended default rules in a normal module.
`ExtendedLiterals` | Allow numeric literal postfix syntax for unboxed integers.
`FieldSelectors` | Make record field selector functions visible in expressions.
`FlexibleContexts` | Remove some restrictions on class contexts
`FlexibleInstances` | Allow instance heads to mention arbitrary nested types.
`ForeignFunctionInterface` | Allow foreign function interface syntax.
`FunctionalDependencies` | Allow functional dependencies to be given on typeclass declarations.
`GADTs` | Allow definition of generalised algebraic data types.
`GADTSyntax` | Allow generalised algebraic data type syntax.
`GeneralisedNewtypeDeriving` | Allow instances to be derived via `newtype` deriving.
`GHC2021` | Use GHC’s set of default language extensions from 2021
`GHC2024` | Use GHC’s set of default language extensions from 2024
`GHCForeignImportPrim` | Allow `prim` calling convention. Intended for internal use only.
`Haskell2010` | Use the Haskell 2010 language edition.
`Haskell98` | Use the Haskell 98 language edition.
`HexFloatLiterals` | Allow hexadecimal floating-point literal syntax.
`ImplicitParams` | Allow implicit parameter constraints.
`ImplicitPrelude` | Implicitly import `Prelude`.
`ImplicitStagePersistence` | Allow identifiers to be used at different levels from where they are defined.
`ImportQualifiedPost` | Allows the syntax `import M qualified`
`ImpredicativeTypes` | Allow impredicative types.
`IncoherentInstances` | Allow definitions of instances that may result in incoherence.
`InstanceSigs` | Allow type signatures to be written for instance methods.
`InterruptibleFFI` | Allow `interruptible` FFI imports.
`KindSignatures` | Allow kind signatures to be given for types.
`LambdaCase` | Allow `\case` expressions.
`LexicalNegation` | Use whitespace to determine whether the minus sign stands for negation or subtraction.
`LiberalTypeSynonyms` | Relax many of Haskell 98's rules on type synonym definitions.
`LinearTypes` | Allow writing of linear arrow types. Implies `MonoLocalBinds`.
`ListTuplePuns` | Enable punning for list, tuple and sum types.
`MagicHash` | Allow `#` as a postfix modifier on identifiers.
`MonadComprehensions` | Allow list comprehension syntax to be used at monads other than `List`.
`MonoLocalBinds` | Do not generalise types of local bindings.
`MonomorphismRestriction` | Apply the Haskell 2010 monomorphism restriction.
`MultilineStrings` | Enable multiline string literals.
`MultiParamTypeClasses` | Enable multi-parameter type classes.
`MultiWayIf` | Allow multi-way `if`-expressions.
`NamedDefaults` | Enable `default` declarations with explicitly named class, extending Type class defaulting.
`NamedFieldPuns` | Allow record field punning syntax.
`NamedWildCards` | Allow named wildcards in types.
`NegativeLiterals` | Allow negative numeric literal syntax.
`NondecreasingIndentation` | Allow nested contexts to be at the same indentation level as its enclosing context.
`NPlusKPatterns` | Allow use of `n+k` patterns.
`NullaryTypeClasses` | Deprecated, does nothing. nullary type classes are now enabled using `MultiParamTypeClasses`.
`NumDecimals` | Allow use of scientific notation syntax for integer literals.
`NumericUnderscores` | Allow underscores in numeric literals.
`OrPatterns` | Enable or-patterns.
`OverlappingInstances` | Allow definition of overlapping instances.
`OverloadedLabels` | Allow overloaded label syntax.
`OverloadedLists` | Desugar list syntax via the `IsList` class.
`OverloadedRecordDot` | Allow `.` to be used for record field access.
`OverloadedRecordUpdate` | Allow `.` syntax in record updates
`OverloadedStrings` | Desugar string literals via `IsString` class.
`PackageImports` | Allow package-qualified `import` syntax.
`ParallelListComp` | Allow parallel list comprehension syntax.
`PartialTypeSignatures` | Allow type signatures to contain wildcards.
`PatternGuards` | Allow pattern guards syntax.
`PatternSynonyms` | Allow definition of pattern synonyms.
`PolyKinds` | Allow kind polymorphism.
`PostfixOperators` | Allow the use of postfix operators.
`QualifiedDo` | Allow qualified `do`-notation desugaring.
`QuantifiedConstraints` | Allow `forall` quantifiers in constraints.
`QuasiQuotes` | Allow quasiquotation syntax.
`Rank2Types` | Enable rank-2 types.
`RankNTypes` | Allow types of rank greater than one.
`RebindableSyntax` | Allow rebinding of builtin syntax.
`RecordWildCards` | Allow use of record wildcard syntax.
`RecursiveDo` | Allow recursive do (e.g. `mdo`) notation.
`RequiredTypeArguments` | Allow use of required type argument syntax in terms.
`RoleAnnotations` | Allow role annotation syntax.
`Safe` | Enable the Safe Haskell Safe mode.
`ScopedTypeVariables` | Lexically scope explicitly-introduced type variables.
`StandaloneDeriving` | Allow standalone instance deriving declarations.
`StandaloneKindSignatures` | Allow standalone kind signature declarations.
`StarIsType` | Treat `*` as `Data.Kind.Type`.
`StaticPointers` | Allow `static` syntax.
`Strict` | Make bindings in the current module strict by default.
`StrictData` | Treat datatype fields as strict by default.
`TemplateHaskell` | Allow Template Haskell's splice and quotation syntax.
`TemplateHaskellQuotes` | Allow Template Haskell's quotation syntax.
`TraditionalRecordSyntax` | Allow traditional record syntax (e.g. `C {f = x}`).
`TransformListComp` | Allow generalised list comprehension syntax.
`Trustworthy` | Enable the Safe Haskell Trustworthy mode.
`TupleSections` | Allow use of tuple section synxtax.
`TypeAbstractions` | Allow type abstraction syntax in patterns and type variable binders.
`TypeApplications` | Allow type application syntax in terms and types.
`TypeData` | Allow `type data` declarations.
`TypeFamilies` | Allow definition of type families.
`TypeFamilyDependencies` | Allow injectivity annotations on type families.
`TypeInType` | Deprecated. Enable kind polymorphism and datatype promotion.
`TypeOperators` | Allow type constructors to be given operator names.
`TypeSynonymInstances` | Allow type synonyms to be mentioned in instance heads.
`UnboxedSums` | Allow the use of unboxed sum syntax.
`UnboxedTuples` | Allow the use of unboxed tuple syntax.
`UndecidableInstances` | Allow definition of instances which may make solving undecidable.
`UndecidableSuperClasses` | Allow all superclass constraints, including those that may result in non-termination of the typechecker.
`UnicodeSyntax` | Enable unicode syntax.
`UnliftedDatatypes` | Allow the definition of unlifted data types.
`UnliftedFFITypes` | Allow the types of foreign imports to contain certain unlifted types.
`UnliftedNewtypes` | Allow definition of unlifted newtypes.
`Unsafe` | Enable Safe Haskell Unsafe mode.
`ViewPatterns` | Allow view pattern syntax.