Cabal-2.0.1.0: A framework for packaging Haskell software

Copyright | Isaac Jones 2003-2004
License | BSD3
Maintainer | libraries@haskell.org
Portability | portable
Safe Haskell | None
Language | Haskell2010

Language.Haskell.Extension

Description

Haskell language dialects and extensions

Synopsis

- data Language
  - = Haskell98
  - | Haskell2010
  - | UnknownLanguage String
- knownLanguages :: [Language]
- classifyLanguage :: String -> Language
- data Extension
  - = EnableExtension KnownExtension
  - | DisableExtension KnownExtension
  - | UnknownExtension String
- data KnownExtension
  - = OverlappingInstances
  - | UndecidableInstances
  - | IncoherentInstances
  - | DoRec
  - | RecursiveDo
  - | ParallelListComp
  - | MultiParamTypeClasses
  - | MonomorphismRestriction
  - | FunctionalDependencies
  - | Rank2Types
  - | RankNTypes
  - | PolymorphicComponents
  - | ExistentialQuantification
  - | ScopedTypeVariables
  - | PatternSignatures
  - | ImplicitParams
  - | FlexibleContexts
  - | FlexibleInstances
  - | EmptyDataDecls
  - | CPP
  - | KindSignatures
  - | BangPatterns
  - | TypeSynonymInstances
  - | TemplateHaskell
  - | ForeignFunctionInterface
  - | Arrows
  - | Generics
  - | ImplicitPrelude
  - | NamedFieldPuns
  - | PatternGuards
  - | GeneralizedNewtypeDeriving
  - | ExtensibleRecords
  - | RestrictedTypeSynonyms
  - | HereDocuments
  - | MagicHash
  - | TypeFamilies
  - | StandaloneDeriving
  - | UnicodeSyntax
  - | UnliftedFFITypes
  - | InterruptibleFFI
  - | CApiFFI
  - | LiberalTypeSynonyms
  - | TypeOperators
  - | RecordWildCards
  - | RecordPuns
  - | DisambiguateRecordFields
  - | TraditionalRecordSyntax
  - | OverloadedStrings
  - | GADTs
  - | GADTSyntax
  - | MonoPatBinds
  - | RelaxedPolyRec
  - | ExtendedDefaultRules
  - | UnboxedTuples
  - | DeriveDataTypeable
  - | DeriveGeneric
  - | DefaultSignatures
  - | InstanceSigs
  - | ConstrainedClassMethods
  - | PackageImports
  - | ImpredicativeTypes
  - | NewQualifiedOperators
  - | PostfixOperators
  - | QuasiQuotes
  - | TransformListComp
  - | MonadComprehensions
  - | ViewPatterns
  - | XmlSyntax
  - | RegularPatterns
  - | TupleSections
  - | GHCForeignImportPrim
  - | NPlusKPatterns
  - | DoAndIfThenElse
  - | MultiWayIf
  - | LambdaCase
  - | RebindableSyntax
  - | ExplicitForAll
  - | DatatypeContexts
  - | MonoLocalBinds
  - | DeriveFunctor
  - | DeriveTraversable
  - | DeriveFoldable
  - | NondecreasingIndentation
  - | SafeImports
  - | Safe
  - | Trustworthy
  - | Unsafe
  - | ConstraintKinds
  - | PolyKinds
  - | DataKinds
  - | ParallelArrays
  - | RoleAnnotations
  - | OverloadedLists
  - | EmptyCase
  - | AutoDeriveTypeable
  - | NegativeLiterals
  - | BinaryLiterals
  - | NumDecimals
  - | NullaryTypeClasses
  - | ExplicitNamespaces
  - | AllowAmbiguousTypes
  - | JavaScriptFFI
  - | PatternSynonyms
  - | PartialTypeSignatures
  - | NamedWildCards
  - | DeriveAnyClass
  - | DeriveLift
  - | StaticPointers
  - | StrictData
  - | Strict
  - | ApplicativeDo
  - | DuplicateRecordFields
  - | TypeApplications
  - | TypeInType
  - | UndecidableSuperClasses
  - | MonadFailDesugaring
  - | TemplateHaskellQuotes
  - | OverloadedLabels
  - | TypeFamilyDependencies
- knownExtensions :: [KnownExtension]
- deprecatedExtensions :: [(Extension, Maybe Extension)]
- classifyExtension :: String -> Extension

# Documentation

data Language #

This represents a Haskell language dialect.

Language `Extension`s are interpreted relative to one of these base languages.

Constructors

Haskell98 | The Haskell 98 language as defined by the Haskell 98 report. http://haskell.org/onlinereport/
Haskell2010 | The Haskell 2010 language as defined by the Haskell 2010 report. http://www.haskell.org/onlinereport/haskell2010
UnknownLanguage String | An unknown language, identified by its name.

Instances

Eq Language # |
Methods (==) :: Language -> Language -> Bool # (/=) :: Language -> Language -> Bool #
Data Language # |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Language -> c Language Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Language Source #

toConstr :: Language -> Constr Source #

dataTypeOf :: Language -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Language) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Language) Source #

gmapT :: (forall b. Data b => b -> b) -> Language -> Language Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Language -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Language -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Language -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Language -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Language -> m Language Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Language -> m Language Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Language -> m Language Source #

Read Language # |
Methods readsPrec :: Int -> ReadS Language Source # readList :: ReadS [Language] Source # readPrec :: ReadPrec Language Source # readListPrec :: ReadPrec [Language] Source #
Show Language # |
Methods showsPrec :: Int -> Language -> ShowS Source # show :: Language -> String Source # showList :: [Language] -> ShowS Source #
Generic Language # |
Associated Types type Rep Language :: * -> * Source # Methods from :: Language -> Rep Language x Source # to :: Rep Language x -> Language Source #
Binary Language # |
Methods put :: Language -> Put Source # get :: Get Language Source # putList :: [Language] -> Put Source #
Text Language # |
Methods disp :: Language -> Doc # parse :: ReadP r Language #
type Rep Language # |
type Rep Language = D1 * (MetaData "Language" "Language.Haskell.Extension" "Cabal-2.0.1.0" False) ((:+:) * (C1 * (MetaCons "Haskell98" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "Haskell2010" PrefixI False) (U1 *)) (C1 * (MetaCons "UnknownLanguage" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)))))

knownLanguages :: [Language] #

classifyLanguage :: String -> Language #

data Extension #

This represents language extensions beyond a base `Language` definition (such as `Haskell98`) that are supported by some implementations, usually in some special mode.

Where applicable, references are given to an implementation's official documentation.

Constructors

EnableExtension KnownExtension | Enable a known extension
DisableExtension KnownExtension | Disable a known extension
UnknownExtension String | An unknown extension, identified by the name of its `LANGUAGE` pragma.

Instances

Eq Extension # |
Methods (==) :: Extension -> Extension -> Bool # (/=) :: Extension -> Extension -> Bool #
Data Extension # |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Extension -> c Extension Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Extension Source #

toConstr :: Extension -> Constr Source #

dataTypeOf :: Extension -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Extension) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Extension) Source #

gmapT :: (forall b. Data b => b -> b) -> Extension -> Extension Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Extension -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Extension -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Extension -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Extension -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Extension -> m Extension Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Extension -> m Extension Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Extension -> m Extension Source #

Ord Extension # |
Methods compare :: Extension -> Extension -> Ordering # (<) :: Extension -> Extension -> Bool # (<=) :: Extension -> Extension -> Bool # (>) :: Extension -> Extension -> Bool # (>=) :: Extension -> Extension -> Bool # max :: Extension -> Extension -> Extension # min :: Extension -> Extension -> Extension #
Read Extension # |
Methods readsPrec :: Int -> ReadS Extension Source # readList :: ReadS [Extension] Source # readPrec :: ReadPrec Extension Source # readListPrec :: ReadPrec [Extension] Source #
Show Extension # |
Methods showsPrec :: Int -> Extension -> ShowS Source # show :: Extension -> String Source # showList :: [Extension] -> ShowS Source #
Generic Extension # |
Associated Types type Rep Extension :: * -> * Source # Methods from :: Extension -> Rep Extension x Source # to :: Rep Extension x -> Extension Source #
Binary Extension # |
Methods put :: Extension -> Put Source # get :: Get Extension Source # putList :: [Extension] -> Put Source #
Text Extension # |
Methods disp :: Extension -> Doc # parse :: ReadP r Extension #
type Rep Extension # |

type Rep Extension = D1 * (MetaData "Extension" "Language.Haskell.Extension" "Cabal-2.0.1.0" False) ((:+:) * (C1 * (MetaCons "EnableExtension" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * KnownExtension))) ((:+:) * (C1 * (MetaCons "DisableExtension" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * KnownExtension))) (C1 * (MetaCons "UnknownExtension" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)))))

data KnownExtension #

Constructors

OverlappingInstances

Allow overlapping class instances, provided there is a unique most specific instance for each use.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-overlap

UndecidableInstances

Ignore structural rules guaranteeing the termination of class instance resolution. Termination is guaranteed by a fixed-depth recursion stack, and compilation may fail if this depth is exceeded.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#undecidable-instances

IncoherentInstances

Implies `OverlappingInstances`. Allow the implementation to choose an instance even when it is possible that further instantiation of types will lead to a more specific instance being applicable.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-overlap

DoRec | (deprecated) Allow recursive bindings in `do` blocks, using the `rec` keyword. See also `RecursiveDo`.

RecursiveDo

Allow recursive bindings using `mdo`, a variant of `do`. `DoRec` provides a different, preferred syntax.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#recursive-do-notation

ParallelListComp

Provide syntax for writing list comprehensions which iterate over several lists together, like the `zipWith` family of functions.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#parallel-list-comprehensions

MultiParamTypeClasses

Allow multiple parameters in a type class.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#multi-param-type-classes

MonomorphismRestriction

Enable the dreaded monomorphism restriction.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/monomorphism.html

FunctionalDependencies

Allow a specification attached to a multi-parameter type class which indicates that some parameters are entirely determined by others. The implementation will check that this property holds for the declared instances, and will use this property to reduce ambiguity in instance resolution.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#functional-dependencies

Rank2Types

Like `RankNTypes` but does not allow a higher-rank type to itself appear on the left of a function arrow.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#universal-quantification

RankNTypes

Allow a universally-quantified type to occur on the left of a function arrow.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#universal-quantification

PolymorphicComponents

Allow data constructors to have polymorphic arguments. Unlike `RankNTypes`, does not allow this for ordinary functions.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#universal-quantification

ExistentialQuantification

Allow existentially-quantified data constructors.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#existential-quantification

ScopedTypeVariables

Cause a type variable in a signature, which has an explicit `forall` quantifier, to scope over the definition of the accompanying value declaration.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#scoped-type-variables

PatternSignatures | Deprecated, use `ScopedTypeVariables` instead.

ImplicitParams

Enable implicit function parameters with dynamic scope.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#implicit-parameters

FlexibleContexts

Relax some restrictions on the form of the context of a type signature.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#flexible-contexts

FlexibleInstances

Relax some restrictions on the form of the context of an instance declaration.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-rules

EmptyDataDecls

Allow data type declarations with no constructors.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#nullary-types

CPP

Run the C preprocessor on Haskell source code.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/options-phases.html#c-pre-processor

KindSignatures

Allow an explicit kind signature giving the kind of types over which a type variable ranges.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#kinding

BangPatterns

Enable a form of pattern which forces evaluation before an attempted match, and a form of strict `let`/`where` binding.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/bang-patterns.html

TypeSynonymInstances

Allow type synonyms in instance heads.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#flexible-instance-head

TemplateHaskell

Enable Template Haskell, a system for compile-time metaprogramming.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/template-haskell.html

ForeignFunctionInterface

Enable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.html

Arrows

Enable arrow notation.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/arrow-notation.html

Generics

(deprecated) Enable generic type classes, with default instances defined in terms of the algebraic structure of a type.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/generic-classes.html

ImplicitPrelude

Enable the implicit importing of the module Prelude. When disabled, when desugaring certain built-in syntax into ordinary identifiers, use whatever is in scope rather than the Prelude -- version.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#rebindable-syntax

NamedFieldPuns

Enable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike `RecordWildCards`.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#record-puns

PatternGuards

Enable a form of guard which matches a pattern and binds variables.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#pattern-guards

GeneralizedNewtypeDeriving

Allow a type declared with `newtype` to use `deriving` for any class with an instance for the underlying type.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#newtype-deriving

ExtensibleRecords

Enable the "Trex" extensible records system.

- http://cvs.haskell.org/Hugs/pages/users_guide/hugs-only.html#TREX

RestrictedTypeSynonyms

Enable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes.

- http://cvs.haskell.org/Hugs/pages/users_guide/restricted-synonyms.html

HereDocuments

Enable an alternate syntax for string literals, with string templating.

- http://cvs.haskell.org/Hugs/pages/users_guide/here-documents.html

MagicHash

Allow the character `#` as a postfix modifier on identifiers. Also enables literal syntax for unboxed values.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#magic-hash

TypeFamilies

Allow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-families.html

StandaloneDeriving

Allow a standalone declaration which invokes the type class `deriving` mechanism.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#stand-alone-deriving

UnicodeSyntax

Allow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#unicode-syntax

UnliftedFFITypes

Allow the use of unboxed types as foreign types, e.g. in `foreign import` and `foreign export`.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.html#id681687

InterruptibleFFI

Enable interruptible FFI.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.html#ffi-interruptible

CApiFFI

Allow use of CAPI FFI calling convention (`foreign import capi`).

- http://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.html#ffi-capi

LiberalTypeSynonyms

Defer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#type-synonyms

TypeOperators | Allow the name of a type constructor, type class, or type variable to be an infix operator.

RecordWildCards

Enable syntax for implicitly binding local names corresponding to the field names of a record. A wildcard binds all unmentioned names, unlike `NamedFieldPuns`.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#record-wildcards

RecordPuns | Deprecated, use `NamedFieldPuns` instead.

DisambiguateRecordFields

Allow a record field name to be disambiguated by the type of the record it's in.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#disambiguate-fields

TraditionalRecordSyntax

Enable traditional record syntax (as supported by Haskell 98)

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#traditional-record-syntax

OverloadedStrings

Enable overloading of string literals using a type class, much like integer literals.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#overloaded-strings

GADTs

Enable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Implies `GADTSyntax`.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#gadt

GADTSyntax

Enable GADT syntax for declaring ordinary algebraic datatypes.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#gadt-style

MonoPatBinds

Make pattern bindings monomorphic.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/monomorphism.html#id630981

RelaxedPolyRec

Relax the requirements on mutually-recursive polymorphic functions.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#typing-binds

ExtendedDefaultRules

Allow default instantiation of polymorphic types in more situations.

- http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/ghci.html#type-defaulting-in-ghci

UnboxedTuples

Enable unboxed tuples.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/primitives.html#unboxed-tuples

DeriveDataTypeable

Enable `deriving` for classes `Typeable` and `Data`.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeable

DeriveGeneric

Enable `deriving` for `Generic` and `Generic1`.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeable

DefaultSignatures

Enable support for default signatures.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#class-default-signatures

InstanceSigs

Allow type signatures to be specified in instance declarations.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-sigs

ConstrainedClassMethods

Allow a class method's type to place additional constraints on a class type variable.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#class-method-types

PackageImports

Allow imports to be qualified by the package name the module is intended to be imported from, e.g.

    import "network" Network.Socket

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#package-imports

ImpredicativeTypes

(deprecated) Allow a type variable to be instantiated at a polymorphic type.

- http://www.haskell.org/ghc/docs/6.12.3/html/users_guide/other-type-extensions.html#impredicative-polymorphism

NewQualifiedOperators

(deprecated) Change the syntax for qualified infix operators.

- http://www.haskell.org/ghc/docs/6.12.3/html/users_guide/syntax-extns.html#new-qualified-operators

PostfixOperators

Relax the interpretation of left operator sections to allow unary postfix operators.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#postfix-operators

QuasiQuotes

Enable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/template-haskell.html#th-quasiquotation

TransformListComp

Enable generalized list comprehensions, supporting operations such as sorting and grouping.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#generalised-list-comprehensions

MonadComprehensions

Enable monad comprehensions, which generalise the list comprehension syntax to work for any monad.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#monad-comprehensions

ViewPatterns

Enable view patterns, which match a value by applying a function and matching on the result.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#view-patterns

XmlSyntax | Allow concrete XML syntax to be used in expressions and patterns, as per the Haskell Server Pages extension language: http://www.haskell.org/haskellwiki/HSP. The ideas behind it are discussed in the paper "Haskell Server Pages through Dynamic Loading" by Niklas Broberg, from Haskell Workshop '05.
RegularPatterns | Allow regular pattern matching over lists, as discussed in the paper "Regular Expression Patterns" by Niklas Broberg, Andreas Farre and Josef Svenningsson, from ICFP '04.

TupleSections

Enable the use of tuple sections, e.g. `(, True)` desugars into `x -> (x, True)`.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#tuple-sections

GHCForeignImportPrim | Allow GHC primops, written in C--, to be imported into a Haskell file.

NPlusKPatterns

Support for patterns of the form `n + k`, where `k` is an integer literal.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#n-k-patterns

DoAndIfThenElse | Improve the layout rule when `if` expressions are used in a `do` block.

MultiWayIf

Enable support for multi-way `if`-expressions.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#multi-way-if

LambdaCase

Enable support lambda-`case` expressions.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#lambda-case

RebindableSyntax

Makes much of the Haskell sugar be desugared into calls to the function with a particular name that is in scope.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#rebindable-syntax

ExplicitForAll

Make `forall` a keyword in types, which can be used to give the generalisation explicitly.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#explicit-foralls

DatatypeContexts

Allow contexts to be put on datatypes, e.g. the `Eq a` in `data Eq a => Set a = NilSet | ConsSet a (Set a)`.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#datatype-contexts

MonoLocalBinds

Local (`let` and `where`) bindings are monomorphic.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#mono-local-binds

DeriveFunctor

Enable `deriving` for the `Functor` class.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeable

DeriveTraversable

Enable `deriving` for the `Traversable` class.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeable

DeriveFoldable

Enable `deriving` for the `Foldable` class.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeable

NondecreasingIndentation

Enable non-decreasing indentation for `do` blocks.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/bugs-and-infelicities.html#infelicities-syntax

SafeImports

Allow imports to be qualified with a safe keyword that requires the imported module be trusted as according to the Safe Haskell definition of trust.

    import safe Network.Socket

- http://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-imports

Safe

Compile a module in the Safe, Safe Haskell mode -- a restricted form of the Haskell language to ensure type safety.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-trust

Trustworthy

Compile a module in the Trustworthy, Safe Haskell mode -- no restrictions apply but the module is marked as trusted as long as the package the module resides in is trusted.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-trust

Unsafe

Compile a module in the Unsafe, Safe Haskell mode so that modules compiled using Safe, Safe Haskell mode can't import it.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-trust

ConstraintKinds

Allow type classimplicit parameterequality constraints to be used as types with the special kind constraint. Also generalise the `(ctxt => ty)` syntax so that any type of kind constraint can occur before the arrow.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/constraint-kind.html

PolyKinds

Enable kind polymorphism.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/kind-polymorphism.html

DataKinds

Enable datatype promotion.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/promotion.html

ParallelArrays

Enable parallel arrays syntax (`[:`, `:]`) for Data Parallel Haskell.

- http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell

RoleAnnotations

Enable explicit role annotations, like in (`type role Foo representational representational`).

- http://www.haskell.org/ghc/docs/latest/html/users_guide/roles.html

OverloadedLists

Enable overloading of list literals, arithmetic sequences and list patterns using the `IsList` type class.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#overloaded-lists

EmptyCase

Enable case expressions that have no alternatives. Also applies to lambda-case expressions if they are enabled.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#empty-case

AutoDeriveTypeable

Triggers the generation of derived `Typeable` instances for every datatype and type class declaration.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#auto-derive-typeable

NegativeLiterals

Desugars negative literals directly (without using negate).

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#negative-literals

BinaryLiterals

Allow the use of binary integer literal syntax (e.g. `0b11001001` to denote `201`).

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#binary-literals

NumDecimals

Allow the use of floating literal syntax for all instances of `Num`, including `Int` and `Integer`.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#num-decimals

NullaryTypeClasses

Enable support for type classes with no type parameter.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#nullary-type-classes

ExplicitNamespaces

Enable explicit namespaces in module import/export lists.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#explicit-namespaces

AllowAmbiguousTypes

Allow the user to write ambiguous types, and the type inference engine to infer them.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#ambiguity

JavaScriptFFI | Enable `foreign import javascript`.

PatternSynonyms

Allow giving names to and abstracting over patterns.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#pattern-synonyms

PartialTypeSignatures

Allow anonymous placeholders (underscore) inside type signatures. The type inference engine will generate a message describing the type inferred at the hole's location.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#partial-type-signatures

NamedWildCards

Allow named placeholders written with a leading underscore inside type signatures. Wildcards with the same name unify to the same type.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#named-wildcards

DeriveAnyClass

Enable `deriving` for any class.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#derive-any-class

DeriveLift

Enable `deriving` for the `Lift` class.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-lift

StaticPointers

Enable support for 'static pointers' (and the `static` keyword) to refer to globally stable names, even across different programs.

- http://www.haskell.org/ghc/docs/latest/html/users_guide/static-pointers.html

StrictData | Switches data type declarations to be strict by default (as if they had a bang using `BangPatterns`), and allow opt-in field laziness using `~`.
Strict | Switches all pattern bindings to be strict by default (as if they had a bang using `BangPatterns`), ordinary patterns are recovered using `~`. Implies `StrictData`.
ApplicativeDo | Allows `do`-notation for types that are ``Applicative`` as well as ``Monad``. When enabled, desugaring `do` notation tries to use `(*)` and ``fmap`` and ``join`` as far as possible.
DuplicateRecordFields | Allow records to use duplicated field labels for accessors.
TypeApplications | Enable explicit type applications with the syntax `id @Int`.
TypeInType | Dissolve the distinction between types and kinds, allowing the compiler to reason about kind equality and therefore enabling GADTs to be promoted to the type-level.
UndecidableSuperClasses | Allow recursive (and therefore undecideable) super-class relationships.
MonadFailDesugaring | A temporary extension to help library authors check if their code will compile with the new planned desugaring of fail.
TemplateHaskellQuotes | A subset of `TemplateHaskell` including only quasi-quoting.
OverloadedLabels | Allows use of the `#label` syntax.
TypeFamilyDependencies | Allow functional dependency annotations on type families to declare them as injective.

Instances

Bounded KnownExtension # |
Methods minBound :: KnownExtension Source # maxBound :: KnownExtension Source #
Enum KnownExtension # |

Methods

succ :: KnownExtension -> KnownExtension Source #

pred :: KnownExtension -> KnownExtension Source #

toEnum :: Int -> KnownExtension Source #

fromEnum :: KnownExtension -> Int Source #

enumFrom :: KnownExtension -> [KnownExtension] Source #

enumFromThen :: KnownExtension -> KnownExtension -> [KnownExtension] Source #

enumFromTo :: KnownExtension -> KnownExtension -> [KnownExtension] Source #

enumFromThenTo :: KnownExtension -> KnownExtension -> KnownExtension -> [KnownExtension] Source #

Eq KnownExtension # |
Methods (==) :: KnownExtension -> KnownExtension -> Bool # (/=) :: KnownExtension -> KnownExtension -> Bool #
Data KnownExtension # |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> KnownExtension -> c KnownExtension Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c KnownExtension Source #

toConstr :: KnownExtension -> Constr Source #

dataTypeOf :: KnownExtension -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c KnownExtension) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KnownExtension) Source #

gmapT :: (forall b. Data b => b -> b) -> KnownExtension -> KnownExtension Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> KnownExtension -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> KnownExtension -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> KnownExtension -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> KnownExtension -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> KnownExtension -> m KnownExtension Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> KnownExtension -> m KnownExtension Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> KnownExtension -> m KnownExtension Source #

Ord KnownExtension # |
Methods compare :: KnownExtension -> KnownExtension -> Ordering # (<) :: KnownExtension -> KnownExtension -> Bool # (<=) :: KnownExtension -> KnownExtension -> Bool # (>) :: KnownExtension -> KnownExtension -> Bool # (>=) :: KnownExtension -> KnownExtension -> Bool # max :: KnownExtension -> KnownExtension -> KnownExtension # min :: KnownExtension -> KnownExtension -> KnownExtension #
Read KnownExtension # |
Methods readsPrec :: Int -> ReadS KnownExtension Source # readList :: ReadS [KnownExtension] Source # readPrec :: ReadPrec KnownExtension Source # readListPrec :: ReadPrec [KnownExtension] Source #
Show KnownExtension # |
Methods showsPrec :: Int -> KnownExtension -> ShowS Source # show :: KnownExtension -> String Source # showList :: [KnownExtension] -> ShowS Source #
Generic KnownExtension # |
Associated Types type Rep KnownExtension :: * -> * Source # Methods from :: KnownExtension -> Rep KnownExtension x Source # to :: Rep KnownExtension x -> KnownExtension Source #
Binary KnownExtension # |
Methods put :: KnownExtension -> Put Source # get :: Get KnownExtension Source # putList :: [KnownExtension] -> Put Source #
Text KnownExtension # |
Methods disp :: KnownExtension -> Doc # parse :: ReadP r KnownExtension #
type Rep KnownExtension # |

type Rep KnownExtension = D1 * (MetaData "KnownExtension" "Language.Haskell.Extension" "Cabal-2.0.1.0" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "OverlappingInstances" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "UndecidableInstances" PrefixI False) (U1 *)) (C1 * (MetaCons "IncoherentInstances" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "DoRec" PrefixI False) (U1 *)) (C1 * (MetaCons "RecursiveDo" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "ParallelListComp" PrefixI False) (U1 *)) (C1 * (MetaCons "MultiParamTypeClasses" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * (C1 * (MetaCons "MonomorphismRestriction" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "FunctionalDependencies" PrefixI False) (U1 *)) (C1 * (MetaCons "Rank2Types" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "RankNTypes" PrefixI False) (U1 *)) (C1 * (MetaCons "PolymorphicComponents" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "ExistentialQuantification" PrefixI False) (U1 *)) (C1 * (MetaCons "ScopedTypeVariables" PrefixI False) (U1 *)))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "PatternSignatures" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "ImplicitParams" PrefixI False) (U1 *)) (C1 * (MetaCons "FlexibleContexts" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "FlexibleInstances" PrefixI False) (U1 *)) (C1 * (MetaCons "EmptyDataDecls" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "CPP" PrefixI False) (U1 *)) (C1 * (MetaCons "KindSignatures" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "BangPatterns" PrefixI False) (U1 *)) (C1 * (MetaCons "TypeSynonymInstances" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "TemplateHaskell" PrefixI False) (U1 *)) (C1 * (MetaCons "ForeignFunctionInterface" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "Arrows" PrefixI False) (U1 *)) (C1 * (MetaCons "Generics" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "ImplicitPrelude" PrefixI False) (U1 *)) (C1 * (MetaCons "NamedFieldPuns" PrefixI False) (U1 *))))))) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "PatternGuards" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "GeneralizedNewtypeDeriving" PrefixI False) (U1 *)) (C1 * (MetaCons "ExtensibleRecords" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "RestrictedTypeSynonyms" PrefixI False) (U1 *)) (C1 * (MetaCons "HereDocuments" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "MagicHash" PrefixI False) (U1 *)) (C1 * (MetaCons "TypeFamilies" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "StandaloneDeriving" PrefixI False) (U1 *)) (C1 * (MetaCons "UnicodeSyntax" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "UnliftedFFITypes" PrefixI False) (U1 *)) (C1 * (MetaCons "InterruptibleFFI" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "CApiFFI" PrefixI False) (U1 *)) (C1 * (MetaCons "LiberalTypeSynonyms" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "TypeOperators" PrefixI False) (U1 *)) (C1 * (MetaCons "RecordWildCards" PrefixI False) (U1 *)))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "RecordPuns" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "DisambiguateRecordFields" PrefixI False) (U1 *)) (C1 * (MetaCons "TraditionalRecordSyntax" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "OverloadedStrings" PrefixI False) (U1 *)) (C1 * (MetaCons "GADTs" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "GADTSyntax" PrefixI False) (U1 *)) (C1 * (MetaCons "MonoPatBinds" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "RelaxedPolyRec" PrefixI False) (U1 *)) (C1 * (MetaCons "ExtendedDefaultRules" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "UnboxedTuples" PrefixI False) (U1 *)) (C1 * (MetaCons "DeriveDataTypeable" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "DeriveGeneric" PrefixI False) (U1 *)) (C1 * (MetaCons "DefaultSignatures" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "InstanceSigs" PrefixI False) (U1 *)) (C1 * (MetaCons "ConstrainedClassMethods" PrefixI False) (U1 *)))))))) ((:+:) * ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "PackageImports" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "ImpredicativeTypes" PrefixI False) (U1 *)) (C1 * (MetaCons "NewQualifiedOperators" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "PostfixOperators" PrefixI False) (U1 *)) (C1 * (MetaCons "QuasiQuotes" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "TransformListComp" PrefixI False) (U1 *)) (C1 * (MetaCons "MonadComprehensions" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "ViewPatterns" PrefixI False) (U1 *)) (C1 * (MetaCons "XmlSyntax" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "RegularPatterns" PrefixI False) (U1 *)) (C1 * (MetaCons "TupleSections" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "GHCForeignImportPrim" PrefixI False) (U1 *)) (C1 * (MetaCons "NPlusKPatterns" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "DoAndIfThenElse" PrefixI False) (U1 *)) (C1 * (MetaCons "MultiWayIf" PrefixI False) (U1 *)))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "LambdaCase" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "RebindableSyntax" PrefixI False) (U1 *)) (C1 * (MetaCons "ExplicitForAll" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "DatatypeContexts" PrefixI False) (U1 *)) (C1 * (MetaCons "MonoLocalBinds" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "DeriveFunctor" PrefixI False) (U1 *)) (C1 * (MetaCons "DeriveTraversable" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "DeriveFoldable" PrefixI False) (U1 *)) (C1 * (MetaCons "NondecreasingIndentation" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "SafeImports" PrefixI False) (U1 *)) (C1 * (MetaCons "Safe" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "Trustworthy" PrefixI False) (U1 *)) (C1 * (MetaCons "Unsafe" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "ConstraintKinds" PrefixI False) (U1 *)) (C1 * (MetaCons "PolyKinds" PrefixI False) (U1 *))))))) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "DataKinds" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "ParallelArrays" PrefixI False) (U1 *)) (C1 * (MetaCons "RoleAnnotations" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "OverloadedLists" PrefixI False) (U1 *)) (C1 * (MetaCons "EmptyCase" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "AutoDeriveTypeable" PrefixI False) (U1 *)) (C1 * (MetaCons "NegativeLiterals" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "BinaryLiterals" PrefixI False) (U1 *)) (C1 * (MetaCons "NumDecimals" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "NullaryTypeClasses" PrefixI False) (U1 *)) (C1 * (MetaCons "ExplicitNamespaces" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "AllowAmbiguousTypes" PrefixI False) (U1 *)) (C1 * (MetaCons "JavaScriptFFI" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "PatternSynonyms" PrefixI False) (U1 *)) (C1 * (MetaCons "PartialTypeSignatures" PrefixI False) (U1 *)))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "NamedWildCards" PrefixI False) (U1 *)) ((:+:) * (C1 * (MetaCons "DeriveAnyClass" PrefixI False) (U1 *)) (C1 * (MetaCons "DeriveLift" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "StaticPointers" PrefixI False) (U1 *)) (C1 * (MetaCons "StrictData" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "Strict" PrefixI False) (U1 *)) (C1 * (MetaCons "ApplicativeDo" PrefixI False) (U1 *))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "DuplicateRecordFields" PrefixI False) (U1 *)) (C1 * (MetaCons "TypeApplications" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "TypeInType" PrefixI False) (U1 *)) (C1 * (MetaCons "UndecidableSuperClasses" PrefixI False) (U1 *)))) ((:+:) * ((:+:) * (C1 * (MetaCons "MonadFailDesugaring" PrefixI False) (U1 *)) (C1 * (MetaCons "TemplateHaskellQuotes" PrefixI False) (U1 *))) ((:+:) * (C1 * (MetaCons "OverloadedLabels" PrefixI False) (U1 *)) (C1 * (MetaCons "TypeFamilyDependencies" PrefixI False) (U1 *)))))))))

knownExtensions :: [KnownExtension] #

Deprecated: KnownExtension is an instance of Enum and Bounded, use those instead.

deprecatedExtensions :: [(Extension, Maybe Extension)] #

Extensions that have been deprecated, possibly paired with another extension that replaces it.

classifyExtension :: String -> Extension #