Module documentation for 0.2.1.0
“Stable Hackage,” tools for creating a vetted set of packages from Hackage.
NOTE This repository is for package authors to get their code into Stackage. If you simply want to use Stackage as an end user, please follow the instructions on http://www.stackage.org/.
A note about the codebase: the goal is to minimize dependencies and have the maximum range of supported compiler versions. Therefore, we avoid anything “complicated.” For example, instead of using the text package, we use Strings everywhere.
Get your package included
In order to get your package included in the set of stable packages, you should
send a pull request against this repository. In the
there’s a section called
packages. In general, to add a set of
packages, you would add:
"My Name firstname.lastname@example.org @mygithubuser": - package1 - package2 - package3
You can follow the examples of the other sets of packages in that function. Once you’ve done this, you can send a pull request to get your package included.
NOTE: In order to ease the process of adding new packages, we no longer require new submissions to be tested on your own system before sending a pull request. If you believe your package works with the newest versions of all dependencies, you may send a pull request without testing first.
You should also read the maintainers agreement.
Build the package set
Generally, building the package set should be done only by the Jenkins machine or by the official maintainers, as the process does require quite a bit of setup on the local machine. That said, you’ll likely be able to get a stable build by running:
cabal update cabal install stackage stackage nightly
The following describes at a high level the series of steps for processing
- Get list of core packages
- Get build constraints from list of maintained packages
- Load up package index
- Calculate build plan using newest versions of packages
- Write out a YAML file with complete build plan
- Verify that the build plan can be compiled
- Perform the build
- Load up most recent build plan
- Convert build plan into constraints for next build
- Continue from step (3) above
We start off with constraints. Constraints state things like “package X has a
given version range,” who the maintainer is for a package, the description of
the system/compiler being used, etc.
BuildConstraints describes the build as
a whole, whereas
PackageConstraints describes the constraints on an
There are two primary ways of getting a
defaultBuildConstraints inspects the first GHC in the PATH environment variable to
determine GHC version, core packages, core tools, etc. It then uses the
Stackage.Config module to extract information on additional packages to be
installed. The secondary approach is in
Stackage2.UpdateBuildPlan, which will be
BuildConstraints does not specify a build completely. That is given by a
BuildPlan, which is similarly broken down into
In order to get a
BuildPlan, we need two pieces of information: the
BuildConstraints, and a package index. The package index (usually downloaded
from Hackage) is a collection of all of the cabal files available.
By applying a
BuildConstraints to a package index (via
get a proposed
BuildPlan. There is no guarantee that this
valid. To validate it, we use
BuildPlan is an instance of
FromJSON, and therefore can be serialized to a file for
When dealing with LTS Haskell, we want to be able to take a
update to a newer
BuildPlan that keeps all packages at the same major
updateBuildConstraints turns a
BuildPlan into a new
BuildConstraints with that restriction, and
newBuildPlan to that result. As mentioned previously: this is not a
validated result, and therefore
checkBuildPlan must be used.
BuildPlan can be acted on. This is done to check that all packages compile
together, run relevant test suites, test Haddock documentation is correct, and
produce as artifacts both a self-contained GHC binary package database and a
set of Haddock documentation. (Not yet implemented.)
BuildPlan may be converted into a bundle to be uploaded to Stackage Server.
(Not yet implemented.)
- Use TLS manager (to download from Github)
- Minor fixes
First version of Stackage which is made available as its own package. The codebase has been completely rewritten at this point, to be ready for generated both Stackage Nightly and LTS Haskell distributions.