Cabal-1.10.1.0: A framework for packaging Haskell software

Portabilityportable
Maintainerlibraries@haskell.org

Language.Haskell.Extension

Description

Haskell language dialects and extensions

Synopsis

Documentation

data Language Source

This represents a Haskell language dialect.

Language Extensions 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.

data Extension Source

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, e.g. "GHC § 7.2.1" for an extension documented in section 7.2.1 of the GHC User's Guide.

Constructors

OverlappingInstances
GHC § 7.6.3.4
Allow overlapping class instances, provided there is a unique most specific instance for each use.
UndecidableInstances
GHC § 7.6.3.3
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.
IncoherentInstances
GHC § 7.6.3.4
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.
DoRec
GHC § 7.3.8
Allows recursive bindings in do blocks, using the rec keyword.
RecursiveDo
GHC § 7.3.8.2
Deprecated in GHC. Allows recursive bindings using mdo, a variant of do. DoRec provides a different, preferred syntax.
ParallelListComp
GHC § 7.3.9
Provide syntax for writing list comprehensions which iterate over several lists together, like the zipWith family of functions.
MultiParamTypeClasses
GHC § 7.6.1.1
Allow multiple parameters in a type class.
NoMonomorphismRestriction
GHC § 7.17
Disable the dreaded monomorphism restriction.
FunctionalDependencies
GHC § 7.6.2
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.
Rank2Types
GHC § 7.8.5
Like RankNTypes but does not allow a higher-rank type to itself appear on the left of a function arrow.
RankNTypes
GHC § 7.8.5
Allow a universally-quantified type to occur on the left of a function arrow.
PolymorphicComponents
GHC § 7.8.5
Allow data constructors to have polymorphic arguments. Unlike RankNTypes, does not allow this for ordinary functions.
ExistentialQuantification
GHC § 7.4.4
Allow existentially-quantified data constructors.
ScopedTypeVariables
GHC § 7.8.7
Cause a type variable in a signature, which has an explicit forall quantifier, to scope over the definition of the accompanying value declaration.
PatternSignatures

Deprecated, use ScopedTypeVariables instead.

ImplicitParams
GHC § 7.8.3
Enable implicit function parameters with dynamic scope.
FlexibleContexts
GHC § 7.8.2
Relax some restrictions on the form of the context of a type signature.
FlexibleInstances
GHC § 7.6.3.2
Relax some restrictions on the form of the context of an instance declaration.
EmptyDataDecls
GHC § 7.4.1
Allow data type declarations with no constructors.
CPP
GHC § 4.10.3
Run the C preprocessor on Haskell source code.
KindSignatures
GHC § 7.8.4
Allow an explicit kind signature giving the kind of types over which a type variable ranges.
BangPatterns
GHC § 7.11
Enable a form of pattern which forces evaluation before an attempted match, and a form of strict let/where binding.
TypeSynonymInstances
GHC § 7.6.3.1
Allow type synonyms in instance heads.
TemplateHaskell
GHC § 7.9
Enable Template Haskell, a system for compile-time metaprogramming.
ForeignFunctionInterface
GHC § 8
Enable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions.
Arrows
GHC § 7.10
Enable arrow notation.
Generics
GHC § 7.16
Enable generic type classes, with default instances defined in terms of the algebraic structure of a type.
NoImplicitPrelude
GHC § 7.3.11
Disable the implicit importing of the module Prelude. When desugaring certain built-in syntax into ordinary identifiers, use whatever is in scope rather than the Prelude version.
NamedFieldPuns
GHC § 7.3.15
Enable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike RecordWildCards.
PatternGuards
GHC § 7.3.5
Enable a form of guard which matches a pattern and binds variables.
GeneralizedNewtypeDeriving
GHC § 7.5.4
Allow a type declared with newtype to use deriving for any class with an instance for the underlying type.
ExtensibleRecords
Hugs § 7.1
Enable the "Trex" extensible records system.
RestrictedTypeSynonyms
Hugs § 7.2
Enable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes.
HereDocuments
Hugs § 7.3
Enable an alternate syntax for string literals, with string templating.
MagicHash
GHC § 7.3.2
Allow the character # as a postfix modifier on identifiers. Also enables literal syntax for unboxed values.
TypeFamilies
GHC § 7.7
Allow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types.
StandaloneDeriving
GHC § 7.5.2
Allow a standalone declaration which invokes the type class deriving mechanism.
UnicodeSyntax
GHC § 7.3.1
Allow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation.
UnliftedFFITypes
GHC § 8.1.1
Allow the use of unboxed types as foreign types, e.g. in foreign import and foreign export.
LiberalTypeSynonyms
GHC § 7.4.3
Defer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used.
TypeOperators
GHC § 7.4.2
Allow the name of a type constructor, type class, or type variable to be an infix operator.
RecordWildCards
GHC § 7.3.16
Enable syntax for implicitly binding local names corresponding to the field names of a record. A wildcard binds all unmentioned names, unlike NamedFieldPuns.
RecordPuns

Deprecated, use NamedFieldPuns instead.

DisambiguateRecordFields
GHC § 7.3.14
Allow a record field name to be disambiguated by the type of the record it's in.
OverloadedStrings
GHC § 7.6.4
Enable overloading of string literals using a type class, much like integer literals.
GADTs
GHC § 7.4.6
Enable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Enables "GADT syntax" which can be used to declare GADTs as well as ordinary algebraic types.
NoMonoPatBinds
GHC § 7.17.2
Allow pattern bindings to be polymorphic.
RelaxedPolyRec
GHC § 7.8.8
Relax the requirements on mutually-recursive polymorphic functions.
ExtendedDefaultRules
GHC § 2.4.5
Allow default instantiation of polymorphic types in more situations.
UnboxedTuples
GHC § 7.2.2
Enable unboxed tuples.
DeriveDataTypeable
GHC § 7.5.3
Enable deriving for classes Data.Typeable.Typeable and Data.Generics.Data.
ConstrainedClassMethods
GHC § 7.6.1.3
Allow a class method's type to place additional constraints on a class type variable.
PackageImports
GHC § 7.3.18
Allow imports to be qualified by the package name the module is intended to be imported from, e.g.
 import "network" Network.Socket
ImpredicativeTypes
GHC § 7.8.6
Deprecated in GHC 6.12 and will be removed in GHC 7. Allow a type variable to be instantiated at a polymorphic type.
NewQualifiedOperators
GHC § 7.3.3
Change the syntax for qualified infix operators.
PostfixOperators
GHC § 7.3.12
Relax the interpretation of left operator sections to allow unary postfix operators.
QuasiQuotes
GHC § 7.9.5
Enable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns.
TransformListComp
GHC § 7.3.10
Enable generalized list comprehensions, supporting operations such as sorting and grouping.
ViewPatterns
GHC § 7.3.6
Enable view patterns, which match a value by applying a function and matching on the result.
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

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

GHCForeignImportPrim

Allows 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.

DoAndIfThenElse

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

RebindableSyntax

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

ExplicitForAll

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

DatatypeContexts

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

MonoLocalBinds

Local (let and where) bindings are monomorphic.

DeriveFunctor

Enable deriving for the Data.Functor.Functor class.

DeriveTraversable

Enable deriving for the Data.Traversable.Traversable class.

DeriveFoldable

Enable deriving for the Data.Foldable.Foldable class.

UnknownExtension String

An unknown extension, identified by the name of its LANGUAGE pragma.

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

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