Portability	portable
Maintainer	cabal-devel@haskell.org
Safe Haskell	Safe-Inferred

Distribution.PackageDescription

Contents

Package descriptions
Tests
Benchmarks
Build information
- Supplementary build information
package configuration
Source repositories

Description

This defines the data structure for the .cabal file format. There are several parts to this structure. It has top level info and then Library, Executable, TestSuite, and Benchmark sections each of which have associated BuildInfo data that's used to build the library, exe, test, or benchmark. To further complicate things there is both a PackageDescription and a GenericPackageDescription. This distinction relates to cabal configurations. When we initially read a .cabal file we get a GenericPackageDescription which has all the conditional sections. Before actually building a package we have to decide on each conditional. Once we've done that we get a PackageDescription. It was done this way initially to avoid breaking too much stuff when the feature was introduced. It could probably do with being rationalised at some point to make it simpler.

Synopsis

Package descriptions

data PackageDescription

This data type is the internal representation of the file pkg.cabal. It contains two kinds of information about the package: information which is needed for all packages, such as the package name and version, and information which is needed for the simple build system only, such as the compiler options and library name.

Constructors

PackageDescription

Fields

package :: PackageIdentifier
license :: License
licenseFiles :: [FilePath]
copyright :: String
maintainer :: String
author :: String
stability :: String
testedWith :: [(CompilerFlavor, VersionRange)]
homepage :: String
pkgUrl :: String
bugReports :: String
sourceRepos :: [SourceRepo]
synopsis :: String: A one-line summary of this package
description :: String: A more verbose description of this package
category :: String
customFieldsPD :: [(String, String)]: Custom fields starting with x-, stored in a simple assoc-list. | YOU PROBABLY DON'T WANT TO USE THIS FIELD. This field is special! Depending on how far along processing the PackageDescription we are, the contents of this field are either nonsense, or the collected dependencies of *all* the components in this package. buildDepends is initialized by finalizePackageDescription and flattenPackageDescription; prior to that, dependency info is stored in the CondTree built around a GenericPackageDescription. When this resolution is done, dependency info is written to the inner BuildInfo and this field. This is all horrible, and #2066 tracks progress to get rid of this field.
buildDepends :: [Dependency]
specVersionRaw :: Either Version VersionRange: The version of the Cabal spec that this package description uses. For historical reasons this is specified with a version range but only ranges of the form >= v make sense. We are in the process of transitioning to specifying just a single version, not a range.
buildType :: Maybe BuildType
library :: Maybe Library
executables :: [Executable]
testSuites :: [TestSuite]
benchmarks :: [Benchmark]
dataFiles :: [FilePath]
dataDir :: FilePath
extraSrcFiles :: [FilePath]
extraTmpFiles :: [FilePath]
extraDocFiles :: [FilePath]

Instances

Eq PackageDescription
Data PackageDescription
Read PackageDescription
Show PackageDescription
Typeable PackageDescription
Generic PackageDescription
Package PackageDescription

emptyPackageDescription :: PackageDescription

specVersion :: PackageDescription -> Version

The version of the Cabal spec that this package should be interpreted against.

Historically we used a version range but we are switching to using a single version. Currently we accept either. This function converts into a single version by ignoring upper bounds in the version range.

descCabalVersion :: PackageDescription -> VersionRange

Deprecated: Use specVersion instead

The range of versions of the Cabal tools that this package is intended to work with.

This function is deprecated and should not be used for new purposes, only to support old packages that rely on the old interpretation.

data BuildType

The type of build system used by this package.

Constructors

Simple	calls `Distribution.Simple.defaultMain`
Configure	calls `Distribution.Simple.defaultMainWithHooks defaultUserHooks`, which invokes `configure` to generate additional build information used by later phases.
Make	calls `Distribution.Make.defaultMain`
Custom	uses user-supplied `Setup.hs` or `Setup.lhs` (default)
UnknownBuildType String	a package that uses an unknown build type cannot actually be built. Doing it this way rather than just giving a parse error means we get better error messages and allows you to inspect the rest of the package description.

Instances

Eq BuildType
Data BuildType
Read BuildType
Show BuildType
Typeable BuildType
Generic BuildType
Text BuildType

knownBuildTypes :: [BuildType]

Renaming

data ModuleRenaming

Constructors

ModuleRenaming Bool [(ModuleName, ModuleName)]

Instances

Eq ModuleRenaming
Data ModuleRenaming
Ord ModuleRenaming
Read ModuleRenaming
Show ModuleRenaming
Typeable ModuleRenaming
Generic ModuleRenaming
Monoid ModuleRenaming
Text ModuleRenaming

defaultRenaming :: ModuleRenaming

lookupRenaming :: Package pkg => pkg -> Map PackageName ModuleRenaming -> ModuleRenaming

Libraries

data Library

Constructors

Library
Fields exposedModules :: [ModuleName] reexportedModules :: [ModuleReexport] requiredSignatures :: [ModuleName] What sigs need implementations? exposedSignatures :: [ModuleName] What sigs are visible to users? libExposed :: Bool Is the lib to be exposed by default? libBuildInfo :: BuildInfo

Instances

Eq Library
Data Library
Read Library
Show Library
Typeable Library
Generic Library
Monoid Library

data ModuleReexport

Constructors

ModuleReexport
Fields moduleReexportOriginalPackage :: Maybe PackageName moduleReexportOriginalName :: ModuleName moduleReexportName :: ModuleName

Instances

Eq ModuleReexport
Data ModuleReexport
Read ModuleReexport
Show ModuleReexport
Typeable ModuleReexport
Generic ModuleReexport
Text ModuleReexport

emptyLibrary :: Library

withLib :: PackageDescription -> (Library -> IO ()) -> IO ()

If the package description has a library section, call the given function with the library build info as argument.

hasLibs :: PackageDescription -> Bool

does this package have any libraries?

libModules :: Library -> [ModuleName]

Get all the module names from the library (exposed and internal modules) which need to be compiled. (This does not include reexports, which do not need to be compiled.)

Executables

data Executable

Constructors

Executable
Fields exeName :: String modulePath :: FilePath buildInfo :: BuildInfo

Instances

Eq Executable
Data Executable
Read Executable
Show Executable
Typeable Executable
Generic Executable
Monoid Executable

emptyExecutable :: Executable

withExe :: PackageDescription -> (Executable -> IO ()) -> IO ()

Perform the action on each buildable Executable in the package description.

hasExes :: PackageDescription -> Bool

does this package have any executables?

exeModules :: Executable -> [ModuleName]

Get all the module names from an exe

Tests

data TestSuite

A "test-suite" stanza in a cabal file.

Constructors

TestSuite
Fields testName :: String testInterface :: TestSuiteInterface testBuildInfo :: BuildInfo testEnabled :: Bool

Instances

Eq TestSuite
Data TestSuite
Read TestSuite
Show TestSuite
Typeable TestSuite
Generic TestSuite
Monoid TestSuite

data TestSuiteInterface

The test suite interfaces that are currently defined. Each test suite must specify which interface it supports.

More interfaces may be defined in future, either new revisions or totally new interfaces.

Constructors

TestSuiteExeV10 Version FilePath	Test interface "exitcode-stdio-1.0". The test-suite takes the form of an executable. It returns a zero exit code for success, non-zero for failure. The stdout and stderr channels may be logged. It takes no command line parameters and nothing on stdin.
TestSuiteLibV09 Version ModuleName	Test interface "detailed-0.9". The test-suite takes the form of a library containing a designated module that exports "tests :: [Test]".
TestSuiteUnsupported TestType	A test suite that does not conform to one of the above interfaces for the given reason (e.g. unknown test type).

Instances

Eq TestSuiteInterface
Data TestSuiteInterface
Read TestSuiteInterface
Show TestSuiteInterface
Typeable TestSuiteInterface
Generic TestSuiteInterface
Monoid TestSuiteInterface

data TestType

The "test-type" field in the test suite stanza.

Constructors

TestTypeExe Version	"type: exitcode-stdio-x.y"
TestTypeLib Version	"type: detailed-x.y"
TestTypeUnknown String Version	Some unknown test type e.g. "type: foo"

Instances

Eq TestType
Data TestType
Read TestType
Show TestType
Typeable TestType
Generic TestType
Text TestType

testType :: TestSuite -> TestType

knownTestTypes :: [TestType]

emptyTestSuite :: TestSuite

hasTests :: PackageDescription -> Bool

Does this package have any test suites?

withTest :: PackageDescription -> (TestSuite -> IO ()) -> IO ()

Perform an action on each buildable TestSuite in a package.

testModules :: TestSuite -> [ModuleName]

Get all the module names from a test suite.

enabledTests :: PackageDescription -> [TestSuite]

Get all the enabled test suites from a package.

Benchmarks

data Benchmark

A "benchmark" stanza in a cabal file.

Constructors

Benchmark
Fields benchmarkName :: String benchmarkInterface :: BenchmarkInterface benchmarkBuildInfo :: BuildInfo benchmarkEnabled :: Bool

Instances

Eq Benchmark
Data Benchmark
Read Benchmark
Show Benchmark
Typeable Benchmark
Generic Benchmark
Monoid Benchmark

data BenchmarkInterface

The benchmark interfaces that are currently defined. Each benchmark must specify which interface it supports.

More interfaces may be defined in future, either new revisions or totally new interfaces.

Constructors

BenchmarkExeV10 Version FilePath	Benchmark interface "exitcode-stdio-1.0". The benchmark takes the form of an executable. It returns a zero exit code for success, non-zero for failure. The stdout and stderr channels may be logged. It takes no command line parameters and nothing on stdin.
BenchmarkUnsupported BenchmarkType	A benchmark that does not conform to one of the above interfaces for the given reason (e.g. unknown benchmark type).

Instances

Eq BenchmarkInterface
Data BenchmarkInterface
Read BenchmarkInterface
Show BenchmarkInterface
Typeable BenchmarkInterface
Generic BenchmarkInterface
Monoid BenchmarkInterface

data BenchmarkType

The "benchmark-type" field in the benchmark stanza.

Constructors

BenchmarkTypeExe Version	"type: exitcode-stdio-x.y"
BenchmarkTypeUnknown String Version	Some unknown benchmark type e.g. "type: foo"

Instances

Eq BenchmarkType
Data BenchmarkType
Read BenchmarkType
Show BenchmarkType
Typeable BenchmarkType
Generic BenchmarkType
Text BenchmarkType

benchmarkType :: Benchmark -> BenchmarkType

knownBenchmarkTypes :: [BenchmarkType]

emptyBenchmark :: Benchmark

hasBenchmarks :: PackageDescription -> Bool

Does this package have any benchmarks?

withBenchmark :: PackageDescription -> (Benchmark -> IO ()) -> IO ()

Perform an action on each buildable Benchmark in a package.

benchmarkModules :: Benchmark -> [ModuleName]

Get all the module names from a benchmark.

enabledBenchmarks :: PackageDescription -> [Benchmark]

Get all the enabled benchmarks from a package.

Build information

data BuildInfo

Constructors

BuildInfo

Fields

buildable :: Bool: component is buildable here
buildTools :: [Dependency]: tools needed to build this bit
cppOptions :: [String]: options for pre-processing Haskell code
ccOptions :: [String]: options for C compiler
ldOptions :: [String]: options for linker
pkgconfigDepends :: [Dependency]: pkg-config packages that are used
frameworks :: [String]: support frameworks for Mac OS X
cSources :: [FilePath]
jsSources :: [FilePath]
hsSourceDirs :: [FilePath]: where to look for the Haskell module hierarchy
otherModules :: [ModuleName]: non-exposed or non-main modules
defaultLanguage :: Maybe Language: language used when not explicitly specified
otherLanguages :: [Language]: other languages used within the package
defaultExtensions :: [Extension]: language extensions used by all modules
otherExtensions :: [Extension]: other language extensions used within the package
oldExtensions :: [Extension]: the old extensions field, treated same as defaultExtensions
extraLibs :: [String]: what libraries to link with when compiling a program that uses your package
extraGHCiLibs :: [String]: if present, overrides extraLibs when package is loaded with GHCi.
extraLibDirs :: [String]
includeDirs :: [FilePath]: directories to find .h files
includes :: [FilePath]: The .h files to be found in includeDirs
installIncludes :: [FilePath]: .h files to install with the package
options :: [(CompilerFlavor, [String])]
profOptions :: [(CompilerFlavor, [String])]
sharedOptions :: [(CompilerFlavor, [String])]
customFieldsBI :: [(String, String)]: Custom fields starting with x-, stored in a simple assoc-list.
targetBuildDepends :: [Dependency]: Dependencies specific to a library or executable target
targetBuildRenaming :: Map PackageName ModuleRenaming

Instances

Eq BuildInfo
Data BuildInfo
Read BuildInfo
Show BuildInfo
Typeable BuildInfo
Generic BuildInfo
Monoid BuildInfo

emptyBuildInfo :: BuildInfo

allBuildInfo :: PackageDescription -> [BuildInfo]

The BuildInfo for the library (if there is one and it's buildable), and all buildable executables, test suites and benchmarks. Useful for gathering dependencies.

allLanguages :: BuildInfo -> [Language]

The Languages used by this component

allExtensions :: BuildInfo -> [Extension]

The Extensions that are used somewhere by this component

usedExtensions :: BuildInfo -> [Extension]

The Extensions that are used by all modules in this component

hcOptions :: CompilerFlavor -> BuildInfo -> [String]

Select options for a particular Haskell compiler.

hcProfOptions :: CompilerFlavor -> BuildInfo -> [String]

hcSharedOptions :: CompilerFlavor -> BuildInfo -> [String]

Supplementary build information

type HookedBuildInfo = (Maybe BuildInfo, [(String, BuildInfo)])

emptyHookedBuildInfo :: HookedBuildInfo

updatePackageDescription :: HookedBuildInfo -> PackageDescription -> PackageDescription

package configuration

data GenericPackageDescription

Constructors

GenericPackageDescription
Fields packageDescription :: PackageDescription genPackageFlags :: [Flag] condLibrary :: Maybe (CondTree ConfVar [Dependency] Library) condExecutables :: [(String, CondTree ConfVar [Dependency] Executable)] condTestSuites :: [(String, CondTree ConfVar [Dependency] TestSuite)] condBenchmarks :: [(String, CondTree ConfVar [Dependency] Benchmark)]

Instances

Eq GenericPackageDescription
Data GenericPackageDescription
Show GenericPackageDescription
Typeable GenericPackageDescription
Package GenericPackageDescription

data Flag

A flag can represent a feature to be included, or a way of linking a target against its dependencies, or in fact whatever you can think of.

Constructors

MkFlag
Fields flagName :: FlagName flagDescription :: String flagDefault :: Bool flagManual :: Bool

Instances

Eq Flag
Data Flag
Show Flag
Typeable Flag

newtype FlagName

A FlagName is the name of a user-defined configuration flag

Constructors

FlagName String

Instances

Eq FlagName
Data FlagName
Ord FlagName
Read FlagName
Show FlagName
Typeable FlagName
Generic FlagName

type FlagAssignment = [(FlagName, Bool)]

A FlagAssignment is a total or partial mapping of FlagNames to Bool flag values. It represents the flags chosen by the user or discovered during configuration. For example --flags=foo --flags=-bar becomes [(foo, True), (bar, False)]

data CondTree v c a

Constructors

CondNode
Fields condTreeData :: a condTreeConstraints :: c condTreeComponents :: [(Condition v, CondTree v c a, Maybe (CondTree v c a))]

Instances

Typeable3 CondTree
(Eq v, Eq c, Eq a) => Eq (CondTree v c a)
(Data v, Data c, Data a) => Data (CondTree v c a)
(Show v, Show c, Show a) => Show (CondTree v c a)

data ConfVar

A ConfVar represents the variable type used.

Constructors

OS OS
Arch Arch
Flag FlagName
Impl CompilerFlavor VersionRange

Instances

Eq ConfVar
Data ConfVar
Show ConfVar
Typeable ConfVar

data Condition c

A boolean expression parameterized over the variable type used.

Constructors

Var c
Lit Bool
CNot (Condition c)
COr (Condition c) (Condition c)
CAnd (Condition c) (Condition c)

Instances

Typeable1 Condition
Eq c => Eq (Condition c)
Data c => Data (Condition c)
Show c => Show (Condition c)

Source repositories

data SourceRepo

Information about the source revision control system for a package.

When specifying a repo it is useful to know the meaning or intention of the information as doing so enables automation. There are two obvious common purposes: one is to find the repo for the latest development version, the other is to find the repo for this specific release. The ReopKind specifies which one we mean (or another custom one).

A package can specify one or the other kind or both. Most will specify just a head repo but some may want to specify a repo to reconstruct the sources for this package release.

The required information is the RepoType which tells us if it's using Darcs, Git for example. The repoLocation and other details are interpreted according to the repo type.

Constructors

SourceRepo

Fields

repoKind :: RepoKind: The kind of repo. This field is required.
repoType :: Maybe RepoType: The type of the source repository system for this repo, eg Darcs or Git. This field is required.
repoLocation :: Maybe String: The location of the repository. For most RepoTypes this is a URL. This field is required.
repoModule :: Maybe String: CVS can put multiple "modules" on one server and requires a module name in addition to the location to identify a particular repo. Logically this is part of the location but unfortunately has to be specified separately. This field is required for the CVS RepoType and should not be given otherwise.
repoBranch :: Maybe String: The name or identifier of the branch, if any. Many source control systems have the notion of multiple branches in a repo that exist in the same location. For example Git and CVS use this while systems like Darcs use different locations for different branches. This field is optional but should be used if necessary to identify the sources, especially for the RepoThis repo kind.
repoTag :: Maybe String: The tag identify a particular state of the repository. This should be given for the RepoThis repo kind and not for RepoHead kind.
repoSubdir :: Maybe FilePath: Some repositories contain multiple projects in different subdirectories This field specifies the subdirectory where this packages sources can be found, eg the subdirectory containing the .cabal file. It is interpreted relative to the root of the repository. This field is optional. If not given the default is "." ie no subdirectory.

Instances

Eq SourceRepo
Data SourceRepo
Read SourceRepo
Show SourceRepo
Typeable SourceRepo
Generic SourceRepo

data RepoKind

What this repo info is for, what it represents.

Constructors

RepoHead	The repository for the "head" or development version of the project. This repo is where we should track the latest development activity or the usual repo people should get to contribute patches.
RepoThis	The repository containing the sources for this exact package version or release. For this kind of repo a tag should be given to give enough information to re-create the exact sources.
RepoKindUnknown String

Instances

Eq RepoKind
Data RepoKind
Ord RepoKind
Read RepoKind
Show RepoKind
Typeable RepoKind
Generic RepoKind
Text RepoKind

data RepoType

An enumeration of common source control systems. The fields used in the SourceRepo depend on the type of repo. The tools and methods used to obtain and track the repo depend on the repo type.

Constructors

Darcs
Git
SVN
CVS
Mercurial
GnuArch
Bazaar
Monotone
OtherRepoType String

Instances

Eq RepoType
Data RepoType
Ord RepoType
Read RepoType
Show RepoType
Typeable RepoType
Generic RepoType
Text RepoType

knownRepoTypes :: [RepoType]