2. Creating a package
Prev |  | Next

## 2. Creating a package

Suppose you have a directory hierarchy containing the source files that make up your package. You will need to add two more files to the root directory of the package:

``package`.cabal`

  a text file containing a package description (for details of the syntax of this file, see Section 2.1, “Package descriptions”), and

`Setup.hs` or `Setup.lhs`

  a single-module Haskell program to perform various setup tasks (with the interface described in Section 3, “Building and installing a package”). This module should import only modules that will be present in all Haskell implementations, including modules of the Cabal library. In most cases it will be trivial, calling on the Cabal library to do most of the work.

Once you have these, you can create a source bundle of this directory for distribution. Building of the package is discussed in Section 3, “Building and installing a package”.

Example 1. A package containing a simple library

The HUnit package contains a file `HUnit.cabal` containing:

    Name:           HUnit
    Version:        1.1
    License:        BSD3
    Author:         Dean Herington
    Homepage:       http://hunit.sourceforge.net/
    Category:       Testing
    Build-Depends:  base
    Synopsis:       Unit testing framework for Haskell
    Exposed-modules:
            Test.HUnit, Test.HUnit.Base, Test.HUnit.Lang,
            Test.HUnit.Terminal, Test.HUnit.Text
    Extensions:     CPP

and the following `Setup.hs`:

    import Distribution.Simple
    main = defaultMain

Example 2. A package containing executable programs

    Name:           TestPackage
    Version:        0.0
    License:        BSD3
    Author:         Angela Author
    Synopsis:       Small package with two programs
    Build-Depends:  HUnit

    Executable:     program1
    Main-Is:        Main.hs
    Hs-Source-Dirs: prog1

    Executable:     program2
    Main-Is:        Main.hs
    Hs-Source-Dirs: prog2
    Other-Modules:  Utils

with `Setup.hs` the same as above.

Example 3. A package containing a library and executable programs

    Name:            TestPackage
    Version:         0.0
    License:         BSD3
    Author:          Angela Author
    Synopsis:        Package with library and two programs
    Build-Depends:   HUnit
    Exposed-Modules: A, B, C

    Executable:      program1
    Main-Is:         Main.hs
    Hs-Source-Dirs:  prog1
    Other-Modules:   A, B

    Executable:      program2
    Main-Is:         Main.hs
    Hs-Source-Dirs:  prog2
    Other-Modules:   A, C, Utils

with `Setup.hs` the same as above. Note that any library modules required (directly or indirectly) by an executable must be listed again.

The trivial setup script used in these examples uses the simple build infrastructure provided by the Cabal library (see Distribution.Simple). The simplicity lies in its interface rather that its implementation. It automatically handles preprocessing with standard preprocessors, and builds packages for all the Haskell implementations (except nhc98, for now).

The simple build infrastructure can also handle packages where building is governed by system-dependent parameters, if you specify a little more (see Section 2.3, “System-dependent parameters”). A few packages require more elaborate solutions (see Section 2.4, “More complex packages”).

### 2.1. Package descriptions

The package description file should have a name ending in “`.cabal`”. There must be exactly one such file in the directory. The first part of the name is immaterial, but it is conventional to use the package name.

In the package description file, lines beginning with “`--`” are treated as comments and ignored.

This file should contain one or more stanzas separated by blank lines:

- The first stanza describes the package as a whole (see Section 2.1.1, “Package properties”), as well as an optional library (see Section 2.1.2, “Library”) and relevant build information (see Section 2.1.4, “Build information”).

- Each subsequent stanza (if any) describes an executable program (see Section 2.1.3, “Executables”) and relevant build information (see Section 2.1.4, “Build information”).

Each stanza consists of a number of field/value pairs, with a syntax like mail message headers.

- case is not significant in field names

- to continue a field value, indent the next line

- to get a blank line in a field value, use an indented “`.`”

The syntax of the value depends on the field. Field types include:

`token` , `filename` , `directory`

  Either a sequence of one or more non-space non-comma characters, or a quoted string in Haskell 98 lexical syntax. Unless otherwise stated, relative filenames and directories are interpreted from the package root directory.

`freeform` , `URL` , `address`

  An arbitrary, uninterpreted string.

`identifier`

  A letter followed by zero or more alphanumerics or underscores.

### Modules and preprocessors

Haskell module names listed in the `exposed-modules` and `other-modules` fields may correspond to Haskell source files, i.e. with names ending in “`.hs`” or “`.lhs`”, or to inputs for various Haskell preprocessors. The simple build infrastructure understands the extensions “`.gc`” (haddock), “`.chs`” (c2hs), “`.hsc`” (hsc2hs), “`.y`” and “`.ly`” (happy), “`.x`” (alex) and “`.cpphs`” (cpphs). When building, Cabal will automatically run the appropriate preprocessor and compile the Haskell module it produces.

Some fields take lists of values, which are optionally separated by commas, except for the `build-depends` field, where the commas are mandatory.

Some fields are marked as required. All others are optional, and unless otherwise specified have empty default values.

#### 2.1.1. Package properties

These fields may occur in the first stanza, and describe the package as a whole:

`name:` `package-name` (required)

  The unique name of the package (see Section 1, “Packages”), without the version number.

`version:` `numbers` (required)

  The package version number, usually consisting of a sequence of natural numbers separated by dots.

`cabal-version:` `>, <=, etc. & numbers`

  The version of Cabal required for this package. Use ONLY if this package requires a particular version of Cabal, since unfortunitely, early versions of Cabal do not recognize this field. List the field early in your .cabal file so that it will appear as a syntax error before any others.

`license:` `identifier` (default: `AllRightsReserved`)

  The type of license under which this package is distributed. License names are the constants of the `License` type.

`license-file:` `filename`

  The name of a file containing the precise license for this package.

`copyright:` `freeform`

  The content of a copyright notice, typically the name of the holder of the copyright on the package and the year(s) from which copyright is claimed.

`author:` `freeform`

  The original author of the package.

`maintainer:` `address`

  The current maintainer or maintainers of the package. This is an e-mail address to which users should send bug reports, feature requests and patches.

`stability:` `freeform`

  The stability level of the package, e.g. `alpha`, `experimental`, `provisional`, `stable`.

`homepage:` `URL`

  The package homepage.

`package-url:` `URL`

  The location of a source bundle for the package. The distribution should be a Cabal package.

`synopsis:` `freeform`

  A very short description of the package, for use in a table of packages. This is your headline, so keep it short (one line) but as informative as possible. Save space by not including the package name or saying it's written in Haskell.

`description:` `freeform`

  Description of the package. This may be several paragraphs, and should be aimed at a Haskell programmer who has never heard of your package before.

`category:` `freeform`

  A classification category for future use by the package catalogue Hackage. These categories have not yet been specified, but the upper levels of the module hierarchy make a good start.

`tested-with:` `compiler list`

  A list of compilers and versions against which the package has been tested (or at least built).

`build-depends:` `package list`

  A list of packages, possibly annotated with versions, needed to build this one, e.g. `foo > 1.2, bar`. If no version constraint is specified, any version is assumed to be acceptable.

`data-files:` `filename list`

  A list of files to be installed for run-time use by the package. This is useful for packages that use a large amount of static data, such as tables of values or code templates. For details on how to find these files at run-time, see Section 2.2, “Accessing data files from package code”.

`extra-source-files:` `filename list`

  A list of additional files to be included in source distributions built with setup sdist (see Section 3.10, “setup sdist”).

`extra-tmp-files:` `filename list`

  A list of additional files or directories to be removed by setup clean (see Section 3.8, “setup clean”). These would typically be additional files created by additional hooks, such as the scheme described in Section 2.3, “System-dependent parameters”.

#### 2.1.2. Library

If the package contains a library, the first stanza should also contain the following field:

`exposed-modules:` `identifier list` (required if this package contains a library)

  A list of modules added by this package.

The first stanza may also contain build information fields (see Section 2.1.4, “Build information”) relating to the library.

#### 2.1.3. Executables

Subsequent stanzas (if present) describe executable programs contained in the package, using the following fields, as well as build information fields (see Section 2.1.4, “Build information”).

`executable:` `freeform` (required)

  The name of the executable program.

`main-is:` `filename` (required)

  The name of the source file containing the `Main` module, relative to one of the directories listed in `hs-source-dirs`.

These stanzas may also contain build information fields (see Section 2.1.4, “Build information”) relating to the executable.

#### 2.1.4. Build information

The following fields may be optionally present in any stanza, and give information for the building of the corresponding library or executable. See also Section 2.3, “System-dependent parameters” for a way to supply system-dependent values for these fields.

`buildable:` `Boolean` (default: `True`)

  Is the component buildable? Like some of the other fields below, this field is more useful with the slightly more elaborate form of the simple build infrastructure described in Section 2.3, “System-dependent parameters”.

`other-modules:` `identifier list`

  A list of modules used by the component but not exposed to users. For a library component, these would be hidden modules of the library. For an executable, these would be auxiliary modules to be linked with the file named in the `main-is` field.

`hs-source-dirs:` `directory list` (default: “`.`”)

  Root directories for the module hierarchy.

  For backwards compatibility, the old variant `hs-source-dir` is also recognized.

`extensions:` `identifier list`

  A list of Haskell extensions used by every module. Extension names are the constructors of the `Extension` type. These determine corresponding compiler options. In particular, `CPP` specifies that Haskell source files are to be preprocessed with a C preprocessor.

  Extensions used only by one module may be specified by placing a `LANGUAGE` pragma in the source file affected, e.g.:

      {-# LANGUAGE CPP, MultiParamTypeClasses #-}

  ### Note

  GHC doesn't support the `LANGUAGE` pragma yet.

`ghc-options:` `token list`

  Additional options for GHC. You can often achieve the same effect using the `extensions` field, which is preferred.

  Options required only by one module may be specified by placing an `OPTIONS_GHC` pragma in the source file affected.

`ghc-prof-options:` `token list`

  Additional options for GHC when the package is built with profiling enabled.

`hugs-options:` `token list`

  Additional options for Hugs. You can often achieve the same effect using the `extensions` field, which is preferred.

  Options required only by one module may be specified by placing an `OPTIONS_HUGS` pragma in the source file affected.

`nhc-options:` `token list`

  Additional options for nhc98. You can often achieve the same effect using the `extensions` field, which is preferred.

  Options required only by one module may be specified by placing an `OPTIONS_NHC` pragma in the source file affected.

`includes:` `filename list`

  A list of header files from standard include directories or those listed in `include-dirs`, to be included in any compilations via C. These files typically contain function prototypes for foreign imports used by the package.

`include-dirs:` `directory list`

  A list of directories to search for header files, both when using a C preprocessor and when compiling via C.

`c-sources:` `filename list`

  A list of C source files to be compiled and linked with the Haskell files.

  If you use this field, you should also name the C files in `CFILES` pragmas in the Haskell source files that use them, e.g.:

      {-# CFILES dir/file1.c dir/file2.c #-}

  These are ignored by the compilers, but needed by Hugs.

`extra-libraries:` `token list`

  A list of extra libraries to link with.

`extra-lib-dirs:` `directory list`

  A list of directories to search for libraries.

`cc-options:` `token list`

  Command-line arguments to be passed to the C compiler. Since the arguments are compiler-dependent, this field is more useful with the setup described in Section 2.3, “System-dependent parameters”.

`ld-options:` `token list`

  Command-line arguments to be passed to the linker. Since the arguments are compiler-dependent, this field is more useful with the setup described in Section 2.3, “System-dependent parameters”.

`frameworks:` `token list`

  On Darwin/MacOS X, a list of frameworks to link to. See Apple's developer documentation for more details on frameworks. This entry is ignored on all other platforms.

### 2.2. Accessing data files from package code

The placement on the target system of files listed in the `data-files` field varies between systems, and in some cases one can even move packages around after installation (see Section 3.1.2.2, “Prefix-independence”). To enable packages to find these files in a portable way, Cabal generates a module called `Paths_``pkgname` (with any hyphens in `pkgname` replaced by underscores) during building, so that it may be imported by modules of the package. This module defines a function

    getDataFileName :: FilePath -> IO FilePath

If the argument is a filename listed in the `data-files` field, the result is the name of the corresponding file on the system on which the program is running.

### 2.3. System-dependent parameters

For some packages, especially those interfacing with C libraries, implementation details and the build procedure depend on the build environment. The simple build infrastructure can handle many such situations using a slightly longer `Setup.hs`:

    import Distribution.Simple
    main = defaultMainWithHooks defaultUserHooks

This program differs from `defaultMain` in two ways:

1. If the package root directory contains a file called `configure`, the configure step will run that. This `configure` program may be a script produced by the autoconf system, or may be hand-written. This program typically discovers information about the system and records it for later steps, e.g. by generating system-dependent header files for inclusion in C source files and preprocessed Haskell source files. (Clearly this won't work for Windows without MSYS or Cygwin: other ideas are needed.)

2. If the package root directory contains a file called `package``.buildinfo` after the configuration step, subsequent steps will read it to obtain additional settings for build information fields (see Section 2.1.4, “Build information”), to be merged with the ones given in the `.cabal` file. In particular, this file may be generated by the `configure` script mentioned above, allowing these settings to vary depending on the build environment.

   The build information file should have the following structure:

       buildinfo

       executable: name
       buildinfo

       executable: name
       buildinfo

       ...

   where each `buildinfo` consists of settings of fields listed in Section 2.1.4, “Build information”. The first one (if present) relates to the library, while each of the others relate to the named executable. (The names must match the package description, but you don't have to have entries for all of them.)

Neither of these files is required. If they are absent, this setup script is equivalent to `defaultMain`.

Example 4. Using autoconf

(This example is for people familiar with the autoconf tools.)

In the X11 package, the file `configure.ac` contains:

    AC_INIT([Haskell X11 package], [1.1], [libraries@haskell.org], [X11])

    # Safety check: Ensure that we are in the correct source directory.
    AC_CONFIG_SRCDIR([X11.cabal])

    # Header file to place defines in
    AC_CONFIG_HEADERS([include/HsX11Config.h])

    # Check for X11 include paths and libraries
    AC_PATH_XTRA
    AC_TRY_CPP([#include <X11/Xlib.h>],,[no_x=yes])

    # Build the package if we found X11 stuff
    if test "$no_x" = yes
    then BUILD_PACKAGE_BOOL=False
    else BUILD_PACKAGE_BOOL=True
    fi
    AC_SUBST([BUILD_PACKAGE_BOOL])

    AC_CONFIG_FILES([X11.buildinfo])
    AC_OUTPUT

Then the setup script will run the `configure` script, which checks for the presence of the X11 libraries and substitutes for variables in the file `X11.buildinfo.in`:

    buildable: @BUILD_PACKAGE_BOOL@
    cc-options: @X_CFLAGS@
    ld-options: @X_LIBS@

This generates a file `X11.buildinfo` supplying the parameters needed by later stages:

    buildable: True
    cc-options:  -I/usr/X11R6/include
    ld-options:  -L/usr/X11R6/lib

The `configure` script also generates a header file `include/HsX11Config.h` containing C preprocessor defines recording the results of various tests. This file may be included by C source files and preprocessed Haskell source files in the package.

### Note

Packages using these features will also need to list additional files such as `configure`, templates for `.buildinfo` files, files named only in `.buildinfo` files, header files and so on in the `extra-source-files` field, to ensure that they are included in source distributions. They should also list files and directories generated by configure in the `extra-tmp-files` field to ensure that they are removed by setup clean.

### 2.4. More complex packages

For packages that don't fit the simple schemes described above, you have a few options:

- You can customize the simple build infrastructure using hooks. These allow you to perform additional actions before and after each command is run, and also to specify additional preprocessors. See `UserHooks` in Distribution.Simple for the details, but note that this interface is experimental, and likely to change in future releases.

- You could delegate all the work to make, though this is unlikely to be very portable. Cabal supports this with a trivial setup library Distribution.Make, which simply parses the command line arguments and invokes make. Here `Setup.hs` looks like

      import Distribution.Make
      main = defaultMain

  The root directory of the package should contain a `configure` script, and, after that has run, a `Makefile` with a default target that builds the package, plus targets `install`, `register`, `unregister`, `clean`, `dist` and `docs`. Some options to commands are passed through as follows:

  - The `--with-hc`, `--with-hc-pkg`, `--prefix`, `--bindir`, `--libdir`, `--datadir` and `--libexecdir` options to the `configure` command are passed on to the `configure` script.

  - the `--destdir` option to the `copy` command becomes a setting of a `destdir` variable on the invocation of `make copy`. The supplied `Makefile` should provide a `copy` target, which will probably look like this:

        copy :
                $(MAKE) install prefix=$(destdir)/$(prefix) \
                                bindir=$(destdir)/$(bindir) \
                                libdir=$(destdir)/$(libdir) \
                                datadir=$(destdir)/$(datadir) \
                                libexecdir=$(destdir)/$(libexecdir)

- You can write your own setup script conforming to the interface of Section 3, “Building and installing a package”, possibly using the Cabal library for part of the work. One option is to copy the source of `Distribution.Simple`, and alter it for your needs. Good luck.

Prev |  | Next
Common Architecture for Building Applications and Libraries | Home | 3. Building and installing a package