HORIZON HASKELLDocslts/ghc-10.0.xaa25b892026-10-10Search names, modules, packages, or :: a typeCtrl K

GHC 10.0.0.20260917 · lts/ghc-10.0.x · aa25b89 · 2026-10-10

ModuleCabal-3.18.1.0Haskell2010

Distribution.Simple

This is the command line front end to the Simple build system. When given the parsed command-line args and package information, is able to perform basic commands like configure, build, install, register, etc.

This module exports the main functions that Setup.hs scripts use. It re-exports the UserHooks type, the standard entry points like defaultMain and defaultMainWithHooks and the predefined sets of UserHooks that custom Setup.hs scripts can extend to add their own behaviour.

This module isn't called "Simple" because it's simple. Far from it. It's called "Simple" because it does complicated things to simple software.

The original idea was that there could be different build systems that all presented the same compatible command line interfaces.

  • 24 types
  • 4 classes
  • 110 values
  • PackageCabal-3.18.1.0
  • Exports141
  • LanguageHaskell2010
  • LicenceBSD-3-Clause
  • SourceSimple.hs
valueunUnitId :: UnitId -> String
#

If you need backwards compatibility, consider using display instead, which is supported by all versions of Cabal.

classclass Package pkg => HasUnitId pkg where
#

Packages that have an installed unit ID

Methods

Instances3HasUnitId
  • HasUnitId PreExistingComponentDefined in Cabal-3.18.1.0 · Distribution.Backpack.PreExistingComponent
  • HasUnitId ReadyComponentDefined in Cabal-3.18.1.0 · Distribution.Backpack.ReadyComponent
  • HasUnitId InstalledPackageInfoDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.InstalledPackageInfo
classclass Package pkg where
#

Class of things that have a PackageIdentifier

Types in this class are all notions of a package. This allows us to have different types for the different phases that packages go though, from simple name/id, package description, configured or installed packages.

Not all kinds of packages can be uniquely identified by a PackageIdentifier. In particular, installed packages cannot, there may be many installed instances of the same source package.

Methods

Instances9Package, …
  • Package LinkedComponentDefined in Cabal-3.18.1.0 · Distribution.Backpack.LinkedComponent
  • Package ConfiguredPromisedComponentDefined in Cabal-3.18.1.0 · Distribution.Backpack.PreExistingComponent
  • Package PreExistingComponentDefined in Cabal-3.18.1.0 · Distribution.Backpack.PreExistingComponent
  • Package ReadyComponentDefined in Cabal-3.18.1.0 · Distribution.Backpack.ReadyComponent
  • Package GenericPackageDescriptionDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.GenericPackageDescription
  • Package InstalledPackageInfoDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.InstalledPackageInfo
  • Package PackageDescriptionDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.PackageDescription
  • Package PackageIdentifierDefined in Cabal-syntax-3.18.1.0 · Distribution.Package
  • Package (AnnotatedId id)Defined in Cabal-3.18.1.0 · Distribution.Types.AnnotatedId
classclass HasUnitId pkg => PackageInstalled pkg where
#

Class of installed packages.

The primary data type which is an instance of this package is InstalledPackageInfo, but when we are doing install plans in Cabal install we may have other, installed package-like things which contain more metadata. Installed packages have exact dependencies installedDepends.

Methods

Instances1PackageInstalled
newtypenewtype AbiHash
#

ABI Hashes

Use mkAbiHash and unAbiHash to convert from/to a String.

This type is opaque since Cabal-2.0

Instances11Eq, Read, Show, IsString, Generic, NFData, …
newtypenewtype ComponentId
#

A ComponentId uniquely identifies the transitive source code closure of a component (i.e. libraries, executables).

For non-Backpack components, this corresponds one to one with the UnitId, which serves as the basis for install paths, linker symbols, etc.

Use mkComponentId and unComponentId to convert from/to a String.

This type is opaque since Cabal-2.0

Instances13Eq, Data, Ord, Read, Show, IsString, …
datadata Dependency
#

Describes a dependency on a source package (API)

Invariant: package name does not appear as LSubLibName in set of library names.

Constructors

Instances12Eq, Data, Ord, Read, Show, Generic, …
  • Eq DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
  • Data DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
  • Ord DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
  • Read DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
  • Show DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
  • Generic DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
  • NFData DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
  • Binary DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
  • Parsec DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
    Example1 expression
    simpleParsec "mylib:sub" :: Maybe DependencyJust (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LSubLibName (UnqualComponentName "sub") :| [])))
    Example1 expression
    simpleParsec "mylib:{sub1,sub2}" :: Maybe DependencyJust (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LSubLibName (UnqualComponentName "sub1") :| [LSubLibName (UnqualComponentName "sub2")])))
    Example1 expression
    simpleParsec "mylib:{ sub1 , sub2 }" :: Maybe DependencyJust (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LSubLibName (UnqualComponentName "sub1") :| [LSubLibName (UnqualComponentName "sub2")])))
    Example1 expression
    simpleParsec "mylib:{ sub1 , sub2 } ^>= 42" :: Maybe DependencyJust (Dependency (PackageName "mylib") (MajorBoundVersion (mkVersion [42])) (fromNonEmpty (LSubLibName (UnqualComponentName "sub1") :| [LSubLibName (UnqualComponentName "sub2")])))
    Example1 expression
    simpleParsec "mylib:{ } ^>= 42" :: Maybe DependencyNothing
    Example1 expression
    traverse_ print (map simpleParsec ["mylib:mylib", "mylib:{mylib}", "mylib:{mylib,sublib}" ] :: [Maybe Dependency])Just (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LMainLibName :| [])))Just (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LMainLibName :| [])))Just (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LMainLibName :| [LSubLibName (UnqualComponentName "sublib")])))

    Spaces around colon are not allowed:

    Example1 expression
    map simpleParsec ["mylib: sub", "mylib :sub", "mylib: {sub1,sub2}", "mylib :{sub1,sub2}"] :: [Maybe Dependency][Nothing,Nothing,Nothing,Nothing]

    Sublibrary syntax is accepted since cabal-version: 3.0

    Example1 expression
    map (`simpleParsec'` "mylib:sub") [CabalSpecV2_4, CabalSpecV3_0] :: [Maybe Dependency][Nothing,Just (Dependency (PackageName "mylib") (OrLaterVersion (mkVersion [0])) (fromNonEmpty (LSubLibName (UnqualComponentName "sub") :| [])))]
  • Pretty DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
    Example1 expression
    prettyShow $ Dependency (mkPackageName "pkg") anyVersion mainLibSet"pkg"
    Example1 expression
    prettyShow $ Dependency (mkPackageName "pkg") anyVersion $ NES.insert (LSubLibName $ mkUnqualComponentName "sublib") mainLibSet"pkg:{pkg,sublib}"
    Example1 expression
    prettyShow $ Dependency (mkPackageName "pkg") anyVersion $ NES.singleton (LSubLibName $ mkUnqualComponentName "sublib")"pkg:sublib"
    Example1 expression
    prettyShow $ Dependency (mkPackageName "pkg") anyVersion $ NES.insert (LSubLibName $ mkUnqualComponentName "sublib-b") $ NES.singleton (LSubLibName $ mkUnqualComponentName "sublib-a")"pkg:{sublib-a,sublib-b}"
  • Structured DependencyDefined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
  • type Rep Dependency = D1 ('MetaData "Dependency" "Distribution.Types.Dependency" "Cabal-syntax-3.18.1.0-a008" 'False) (C1 ('MetaCons "Dependency" 'PrefixI 'False) (S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PackageName) :*: (S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 VersionRange) :*: S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmptySet LibraryName)))))Defined in Cabal-syntax-3.18.1.0 · Distribution.Types.Dependency
datadata Module
#

A module identity uniquely identifies a Haskell module by qualifying a ModuleName with the UnitId which defined it. This type distinguishes between two packages which provide a module with the same name, or a module from the same package compiled with different dependencies. There are a few cases where Cabal needs to know about module identities, e.g., when writing out reexported modules in the InstalledPackageInfo.

Constructors

Instances12Eq, Data, Ord, Read, Show, Generic, …
datadata PackageIdentifier
#

The name and version of a package.

Constructors

Instances13Eq, Data, Ord, Read, Show, Generic, …
newtypenewtype PackageName
#

A package name.

Use mkPackageName and unPackageName to convert from/to a String.

This type is opaque since Cabal-2.0

Instances13Eq, Data, Ord, Read, Show, IsString, …
newtypenewtype PkgconfigName
#

A pkg-config library name

This is parsed as any valid argument to the pkg-config utility.

Instances13Eq, Data, Ord, Read, Show, IsString, …
newtypenewtype DefUnitId
#

A UnitId for a definite package. The DefUnitId invariant says that a UnitId identified this way is definite; i.e., it has no unfilled holes.

Instances12Eq, Data, Ord, Read, Show, Generic, …
newtypenewtype UnitId
#

A unit identifier identifies a (possibly instantiated) package/component that can be installed the installed package database. There are several types of components that can be installed:

  • A traditional library with no holes, so that unitIdHash is Nothing. In the absence of Backpack, UnitId is the same as a ComponentId.

  • An indefinite, Backpack library with holes. In this case, unitIdHash is still Nothing, but in the install, there are only interfaces, no compiled objects.

  • An instantiated Backpack library with all the holes filled in. unitIdHash is a Just a hash of the instantiating mapping.

A unit is a component plus the additional information on how the holes are filled in. Thus there is a one to many relationship: for a particular component there are many different ways of filling in the holes, and each different combination is a unit (and has a separate UnitId).

UnitId is distinct from OpenUnitId, in that it is always installed, whereas OpenUnitId are intermediate unit identities that arise during mixin linking, and don't necessarily correspond to any actually installed unit. Since the mapping is not actually recorded in a UnitId, you can't actually substitute over them (but you can substitute over OpenUnitId). See also Distribution.Backpack.FullUnitId for a mechanism for expanding an instantiated UnitId to retrieve its mapping.

Backwards compatibility note: if you need to get the string representation of a UnitId to pass, e.g., as a -package-id flag, use the display function, which will work on all versions of Cabal.

Instances13Eq, Data, Ord, Read, Show, IsString, …
valuemkVersion :: [Int] -> Version
#

Construct Version from list of version number components.

For instance, mkVersion [3,2,1] constructs a Version representing the version 3.2.1.

All version components must be non-negative. mkVersion [] currently represents the special null version; see also nullVersion.

valueasVersionIntervals :: VersionRange -> [VersionInterval]
#

View a VersionRange as a union of intervals.

This provides a canonical view of the semantics of a VersionRange as opposed to the syntax of the expression used to define it. For the syntactic view use foldVersionRange.

Each interval is non-empty. The sequence is in increasing order and no intervals overlap or touch. Therefore only the first and last can be unbounded. The sequence can be empty if the range is empty (e.g. a range expression like < 1 && > 2).

Other checks are trivial to implement using this view. For example:

isNoVersion vr | [] <- asVersionIntervals vr = True
               | otherwise                   = False
isSpecificVersion vr
   | [(LowerBound v  InclusiveBound
      ,UpperBound v' InclusiveBound)] <- asVersionIntervals vr
   , v == v'   = Just v
   | otherwise = Nothing
valuefoldVersionRange
  1. :: a

    "-any" version

  2. -> (Version -> a)
    "== v"
  3. -> (Version -> a)
    "> v"
  4. -> (Version -> a)
    "< v"
  5. -> (a -> a -> a)

    "_ || _" union

  6. -> (a -> a -> a)

    "_ && _" intersection

  7. -> VersionRange
  8. -> a
#

Fold over the basic syntactic structure of a VersionRange.

This provides a syntactic view of the expression defining the version range. The syntactic sugar ">= v", "<= v" and "== v.*" is presented in terms of the other basic syntax.

For a semantic view use asVersionIntervals.

valuehasGTLowerBound :: VersionRange -> Bool
#

Is the lower bound version range greater than (GT, >)?

Example1 expression
forM ["< 1", ">= 0 && < 1", ">= 0 || < 1", "> 0 && < 1", "> 0 || < 1", "^>= 4.20.0.0"] (fmap hasGTLowerBound . simpleParsec)Just [False,False,False,True,True,False]
valuehasLEUpperBound :: VersionRange -> Bool
#

Is the upper bound version range (less than or equal (LE, <=)?

Example1 expression
forM ["< 1", "<= 1", ">= 0 && < 1", ">= 0 || < 1", ">= 0 && <= 1", ">= 0 || <= 1", "^>= 4.20.0.0"] (fmap hasLEUpperBound . simpleParsec)Just [False,True,False,False,True,True,False]
valuehasLowerBound :: VersionRange -> Bool
#

Does the version range have an explicit lower bound?

Note: this function only considers the user-specified lower bounds, but not the implicit >=0 lower bound.

Example1 expression
forM ["< 1", ">= 0 && < 1", ">= 0 || < 1", "^>= 4.20.0.0"] (fmap hasLowerBound . simpleParsec)Just [False,True,False,True]
valuehasTrailingZeroUpperBound :: VersionRange -> Bool
#

Does the upper bound version range have a trailing zero?

Example1 expression
forM ["< 1", "< 1.1", "< 1.0", "< 1.1.0", "^>= 4.20.0.0"] (fmap hasTrailingZeroUpperBound . simpleParsec)Just [False,False,True,True,False]
valuehasUpperBound :: VersionRange -> Bool
#

Does the version range have an upper bound?

Example1 expression
forM ["< 1", ">= 0 && < 1", ">= 0 || < 1", "^>= 4.20.0.0"] (fmap hasUpperBound . simpleParsec)Just [True,True,False,True]
valueisAnyVersion :: VersionRange -> Bool
#

Does this VersionRange place any restriction on the Version or is it in fact equivalent to AnyVersion.

Note this is a semantic check, not simply a syntactic check. So for example the following is True (for all v).

isAnyVersion (EarlierVersion v `UnionVersionRanges` orLaterVersion v)
valueanyVersion :: VersionRange
#

The version range -any. That is, a version range containing all versions.

withinRange v anyVersion = True
valuemajorBoundVersion :: Version -> VersionRange
#

The version range ^>= v.

For example, for version 1.2.3.4, the version range ^>= 1.2.3.4 is the same as >= 1.2.3.4 && < 1.3.

Note that ^>= 1 is equivalent to >= 1 && < 1.1.

valuemajorUpperBound :: Version -> Version
#

Compute next greater major version to be used as upper bound.

Example: 0.4.1 produces the version 0.5 which then can be used to construct a range >= 0.4.1 && < 0.5

valuenoVersion :: VersionRange
#

The empty version range -none, that is a version range containing no versions.

This can be constructed using any unsatisfiable version range expression, for example < 0.

withinRange v noVersion = False
valuewildcardUpperBound :: Version -> Version
#

Increment the last version number.

Example: For 1.2 this returns 1.3 so that it can be used as upper bound when resolving == 1.2.*. For 0.4.1 it returns 0.4.2.

valuewithinVersion :: Version -> VersionRange
#

The version range == v.*.

For example, for version 1.2, the version range == 1.2.* is the same as >= 1.2 && < 1.3.

withinRange v' (withinVersion v) = v' >= v && v' < upper v
  where
    upper (Version lower t) = Version (init lower ++ [last lower + 1]) t
valueisNoVersion :: VersionRange -> Bool
#

This is the converse of isAnyVersion. It check if the version range is empty, if there is no possible version that satisfies the version range.

For example this is True (for all v):

isNoVersion (EarlierVersion v `IntersectVersionRanges` LaterVersion v)
valuesimplifyVersionRange :: VersionRange -> VersionRange
#

Simplify a VersionRange expression. For non-empty version ranges this produces a canonical form. Empty or inconsistent version ranges are left as-is because that provides more information.

If you need a canonical form use fromVersionIntervals . toVersionIntervals

It satisfies the following properties:

withinRange v (simplifyVersionRange r) = withinRange v r
    withinRange v r = withinRange v r'
==> simplifyVersionRange r = simplifyVersionRange r'
 || isNoVersion r
 || isNoVersion r'
valuetransformCaret :: VersionRange -> VersionRange
#

Rewrite ^>= x.y.z into >= x.y.z && < x.(y+1) with explicit lower bound and upper bound. It has the same effect as:

\v -> transformCaretLower v `intersectVersionRanges` transformCaretUpper v
Example1 expression
mapVR transformCaret ["^>=1.2.3.4", "^>=1.2.3", "^>=1.2", "^>=1"][>=1.2.3.4 && <1.3,>=1.2.3 && <1.3,>=1.2 && <1.3,>=1 && <1.1]
valuetransformCaretLower :: VersionRange -> VersionRange
#

Rewrite ^>= x.y.z into explicit upper bound <x.(y+1), removing the lower bound.

Example1 expression
mapVR transformCaretLower ["^>=0.0.0.0", "^>=0.0.0", "^>=0.0", "^>=0"][<0.1,<0.1,<0.1,<0.1]
Example1 expression
mapVR transformCaretLower ["^>=1.1.1.1", "^>=1.1.1", "^>=1.1", "^>=1"][<1.2,<1.2,<1.2,<1.1]
valuetransformCaretUpper :: VersionRange -> VersionRange
#

Rewrite ^>= x.y.z into explicit lower bound >= x.y.z, removing the upper bound. This function doesn't transform the lower bound. It changes the operator from ^>= to >=.

Example1 expression
mapVR transformCaretUpper ["^>=1.2.3.4", "^>=1.2.3", "^>=1.2", "^>=1"][>=1.2.3.4,>=1.2.3,>=1.2,>=1]
datadata Version
#

A Version represents the version of a software entity.

Instances of Eq and Ord are provided, which gives exact equality and lexicographic ordering of the version number components (i.e. 2.1 > 2.0, 1.2.3 > 1.2.2, etc.).

This type is opaque and distinct from the Version type in Data.Version since Cabal-2.0. The difference extends to the Binary instance using a different (and more compact) encoding.

Instances12Eq, Data, Ord, Read, Show, Generic, …
newtypenewtype VersionIntervals
#

A complementary representation of a VersionRange. Instead of a boolean version predicate it uses an increasing sequence of non-overlapping, non-empty intervals.

The key point is that this representation gives a canonical representation for the semantics of VersionRanges. This makes it easier to check things like whether a version range is empty, covers all versions, or requires a certain minimum or maximum version. It also makes it easy to check equality or containment. It also makes it easier to identify 'simple' version predicates for translation into foreign packaging systems that do not support complex version range expressions.

Instances2Eq, Show
datadata VersionRange
#
Instances13Eq, Data, Ord, Read, Show, Generic, …
datadata VersionRangeF a
#

F-Algebra of VersionRange. See cataVersionRange.

Constructors

Instances9Functor, Foldable, Traversable, Eq, Data, Read, …
valuelicenseFromSPDX :: License -> License
#

Convert License to License,

This is lossy conversion. We try our best.

Example1 expression
licenseFromSPDX . licenseToSPDX $ BSD3BSD3
Example1 expression
licenseFromSPDX . licenseToSPDX $ GPL (Just (mkVersion [3]))GPL (Just (mkVersion [3]))
Example1 expression
licenseFromSPDX . licenseToSPDX $ PublicDomainUnknownLicense "LicenseRefPublicDomain"
Example1 expression
licenseFromSPDX $ SPDX.License $ SPDX.simpleLicenseExpression SPDX.EUPL_1_1UnknownLicense "EUPL-1.1"
Example1 expression
licenseFromSPDX . licenseToSPDX $ AllRightsReservedAllRightsReserved
Example1 expression
licenseFromSPDX <$> simpleParsec "BSD-3-Clause OR GPL-3.0-only"Just (UnknownLicense "BSD3ClauseORGPL30only")
datadata License
#

Indicates the license under which a package's source code is released. Versions of the licenses not listed here will be rejected by Hackage and cause cabal check to issue a warning.

Constructors

Instances14Eq, Data, Ord, Read, Show, Generic, …

module Distribution.Simple.Compiler

datadata 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

Instances12Eq, Data, Ord, Read, Show, Generic, …
datadata KnownExtension
#

Known Haskell language extensions, including deprecated and undocumented ones.

Check “Overview of all language extensions” in GHC User’s Guide for more information.

Constructors

  • OverlappingInstances

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

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

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

  • DoRec

    (deprecated) Deprecated in favour of RecursiveDo.

    Old description: Allow recursive bindings in do blocks, using the rec keyword. See also RecursiveDo.

  • RecursiveDo

    Allow recursive bindings in do blocks, using the rec keyword, or mdo, a variant of do.

  • ParallelListComp

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

  • MultiParamTypeClasses

    Allow multiple parameters in a type class.

  • MonomorphismRestriction

    Enable the dreaded monomorphism restriction.

  • DeepSubsumption

    Enable deep subsumption, relaxing the simple subsumption rules, implicitly inserting eta-expansions when matching up function types with different quantification structures.

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

  • Rank2Types

    (deprecated) A synonym for RankNTypes.

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

  • RankNTypes

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

  • PolymorphicComponents

    (deprecated) A synonym for RankNTypes.

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

  • ExistentialQuantification

    Allow existentially-quantified data constructors.

  • ScopedTypeVariables

    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

    Enable implicit function parameters with dynamic scope.

  • FlexibleContexts

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

  • FlexibleInstances

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

  • EmptyDataDecls

    Allow data type declarations with no constructors.

  • CPP

    Run the C preprocessor on Haskell source code.

  • KindSignatures

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

  • BangPatterns

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

  • TypeSynonymInstances

    Allow type synonyms in instance heads.

  • TemplateHaskell

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

  • ForeignFunctionInterface

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

  • Arrows

    Enable arrow notation.

  • Generics

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

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

  • NamedFieldPuns

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

  • PatternGuards

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

  • GeneralizedNewtypeDeriving

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

  • GeneralisedNewtypeDeriving
  • ExtensibleRecords

    Enable the "Trex" extensible records system.

  • RestrictedTypeSynonyms

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

  • HereDocuments

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

  • MagicHash

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

  • TypeFamilies

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

  • StandaloneDeriving

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

  • UnicodeSyntax

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

  • UnliftedFFITypes

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

  • InterruptibleFFI

    Enable interruptible FFI.

  • CApiFFI

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

  • LiberalTypeSynonyms

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

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

  • RecordPuns

    Deprecated, use NamedFieldPuns instead.

  • DisambiguateRecordFields

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

  • TraditionalRecordSyntax

    Enable traditional record syntax (as supported by Haskell 98)

  • OverloadedStrings

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

  • GADTs

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

  • GADTSyntax

    Enable GADT syntax for declaring ordinary algebraic datatypes.

  • MonoPatBinds

    (deprecated) Has no effect.

    Old description: Make pattern bindings monomorphic.

  • RelaxedPolyRec

    Relax the requirements on mutually-recursive polymorphic functions.

  • ExtendedDefaultRules

    Allow default instantiation of polymorphic types in more situations.

  • NamedDefaults

    Allow default declarations to explicitly name the class and be exported.

  • UnboxedTuples

    Enable unboxed tuples.

  • DeriveDataTypeable

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

  • DeriveGeneric

    Enable deriving for Generic and Generic1.

  • DefaultSignatures

    Enable support for default signatures.

  • InstanceSigs

    Allow type signatures to be specified in instance declarations.

  • ConstrainedClassMethods

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

  • PackageImports

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

    import "network" Network.Socket
  • ImpredicativeTypes

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

  • NewQualifiedOperators

    (deprecated) Change the syntax for qualified infix operators.

  • PostfixOperators

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

  • QuasiQuotes

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

  • TransformListComp

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

  • MonadComprehensions

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

  • ViewPatterns

    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

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

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

  • DoAndIfThenElse

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

  • MultiWayIf

    Enable support for multi-way if-expressions.

  • LambdaCase

    Enable support lambda-case expressions.

  • 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 Traversable class.

  • DeriveFoldable

    Enable deriving for the Foldable class.

  • NondecreasingIndentation

    Enable non-decreasing indentation for do blocks.

  • 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
  • Safe

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

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

  • Unsafe

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

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

  • PolyKinds

    Enable kind polymorphism.

  • DataKinds

    Enable datatype promotion.

  • TypeData

    Enable type data declarations, defining constructors at the type level.

  • ParallelArrays

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

  • RoleAnnotations

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

  • OverloadedLists

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

  • EmptyCase

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

  • AutoDeriveTypeable

    (deprecated) Deprecated in favour of DeriveDataTypeable.

    Old description: Triggers the generation of derived Typeable instances for every datatype and type class declaration.

  • NegativeLiterals

    Desugars negative literals directly (without using negate).

  • BinaryLiterals

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

  • NumDecimals

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

  • NullaryTypeClasses

    Enable support for type classes with no type parameter.

  • ExplicitNamespaces

    Enable explicit namespaces in module import/export lists.

  • AllowAmbiguousTypes

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

  • JavaScriptFFI

    Enable foreign import javascript.

  • PatternSynonyms

    Allow giving names to and abstracting over patterns.

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

  • NamedWildCards

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

  • DeriveAnyClass

    Enable deriving for any class.

  • DeriveLift

    Enable deriving for the Lift class.

  • StaticPointers

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

  • 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 undecidable) 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 quoting.

  • OverloadedLabels

    Allows use of the #label syntax.

  • TypeFamilyDependencies

    Allow functional dependency annotations on type families to declare them as injective.

  • DerivingStrategies

    Allow multiple deriving clauses, each optionally qualified with a strategy.

  • DerivingVia

    Enable deriving instances via types of the same runtime representation. Implies DerivingStrategies.

  • UnboxedSums

    Enable the use of unboxed sum syntax.

  • HexFloatLiterals

    Allow use of hexadecimal literal notation for floating-point values.

  • BlockArguments

    Allow do blocks etc. in argument position.

  • NumericUnderscores

    Allow use of underscores in numeric literals.

  • QuantifiedConstraints

    Allow forall in constraints.

  • StarIsType

    Have * refer to Type.

  • EmptyDataDeriving

    Liberalises deriving to provide instances for empty data types.

  • CUSKs

    Enable detection of complete user-supplied kind signatures.

  • ImportQualifiedPost

    Allows the syntax import M qualified.

  • StandaloneKindSignatures

    Allow the use of standalone kind signatures.

  • UnliftedNewtypes

    Enable unlifted newtypes.

  • LexicalNegation

    Use whitespace to determine whether the minus sign stands for negation or subtraction.

  • QualifiedDo

    Enable qualified do-notation desugaring.

  • LinearTypes

    Enable linear types.

  • RequiredTypeArguments

    Allow the use of visible forall in types of terms.

  • FieldSelectors

    Enable the generation of selector functions corresponding to record fields.

  • OverloadedRecordDot

    Enable the use of record dot-accessor and updater syntax

  • OverloadedRecordUpdate

    Provides record . syntax in record updates, e.g. x {foo.bar = 1}.

  • UnliftedDatatypes

    Enable data types for which an unlifted or levity-polymorphic result kind is inferred.

  • ExtendedLiterals

    Enable syntax for primitive numeric literals, e.g. 3#Int8

  • AlternativeLayoutRule

    Undocumented parsing-related extensions introduced in GHC 7.0.

  • AlternativeLayoutRuleTransitional

    Undocumented parsing-related extensions introduced in GHC 7.0.

  • RelaxedLayout

    Undocumented parsing-related extensions introduced in GHC 7.2.

  • TypeAbstractions

    Allow the use of type abstraction syntax.

  • ListTuplePuns

    Allow the use of built-in syntax for list, tuple and sum type constructors rather than being exclusive to data constructors.

  • MultilineStrings

    Support multiline strings.

  • OrPatterns

    Allow use of or-pattern syntax, condensing multiple patterns into a single one.

  • ExplicitLevelImports

    Along with ImplicitStagePersistence, this gives fine-grained control over which modules are needed at each stage of execution.

  • ImplicitStagePersistence

    Allow identifiers to be used at different levels than where they’re defined, using path-based persistence.

  • QualifiedStrings

    Enable qualified string literals.

  • Modifiers

    Enable modifier syntax.

Instances13Bounded, Enum, Eq, Data, Ord, Read, …
datadata Language
#

This represents a Haskell language dialect.

Language Extensions are interpreted relative to one of these base languages.

Constructors

Instances12Eq, Data, Ord, Read, Show, Generic, …

Simple interface

4 declarations
valuedefaultMain :: IO ()
#

A simple implementation of main for a Cabal setup script. It reads the package description file using IO, and performs the action specified on the command line.

Customization

8 declarations
datadata UserHooks
#

Hooks allow authors to add specific functionality before and after a command is run, and also to specify additional preprocessors.

  • WARNING: The hooks interface is under rather constant flux as we try to understand users needs. Setup files that depend on this interface may break in future releases.

Constructors

Standard sets of hooks

valueautoconfUserHooks :: UserHooks
#

Basic autoconf UserHooks:

  • postConf runs ./configure, if present.

  • the pre-hooks, except for pre-conf, read additional build information from package.buildinfo, if present.

Thus configure can use local system information to generate package.buildinfo and possibly other files.

Simple actions (library interface)