How do you manage package dependencies in a Haskell project?

Managing package dependencies in a Haskell project typically involves using a package management tool and defining your project’s dependencies in a specific configuration file. There are three primary tools for managing dependencies in Haskell: Cabal, Stack, and Nix.

Let’s go through each tool and see how they manage package dependencies in Haskell projects.

1. Cabal

Cabal (Common Architecture for Building Applications and Libraries) is a build tool and package manager for Haskell projects. The syntax in the Cabal configuration file (‘*.cabal‘) describes your project’s metadata and dependencies.

Here’s an example of a simple ‘*.cabal‘ file:

name:                myproject
version:             0.1.0.0
license:             MIT
author:              Your Name
maintainer:          your.email@example.com
build-type:          Simple
extra-source-files:  README.md
cabal-version:       >=1.10

library
  exposed-modules:     MyModule
  hs-source-dirs:      src
  build-depends:       base >= 4.7 && < 5,
                       text,
                       bytestring
  ghc-options:         -Wall
  default-language:    Haskell2010

Here, ‘build-depends: base >= 4.7 && < 5, text, bytestring‘ specifies the package dependencies with their version constraints.

To manage dependencies, you first need to install Cabal, which comes with the Haskell Platform, or you can just use ‘ghcup‘ to install it. Then:

1. Run ‘cabal update‘ to update your local package list.

2. Use ‘cabal build‘ to build the project, which downloads and installs dependencies if necessary.

3. Use ‘cabal test‘ to run the test suite, if applicable.

2. Stack

Stack is another popular package manager and build tool for Haskell projects. It handles package dependencies by using snapshots called "Stackage LTS" releases, which have a curated set of packages with consistent library versions.

You’ll need to create a ‘stack.yaml‘ file to configure your project for use with Stack:

resolver: lts-18.9
packages:
- .

extra-deps:
- some-package-0.1.2.3

In this example, the ‘resolver: lts-18.9‘ specifies the Stackage LTS snapshot to use, and ‘some-package-0.1.2.3‘ is an additional dependency not included in the LTS snapshot. You would still use a ‘*.cabal‘ file in your project to specify the actual dependencies.

Here’s a high-level outline of managing dependencies with Stack:

1. Install Stack using the official instructions.

2. Run ‘stack setup‘ to install the appropriate GHC version for your project.

3. Use ‘stack build‘ to build your project and download/install any necessary dependencies.

4. Use ‘stack test‘ to run your test suite if you have one.

3. Nix

Nix is a powerful and versatile package manager that can manage dependencies for any kind of software, not just Haskell projects. It relies on a set of derivations to describe your Haskell dependencies and manages them in an isolated environment. Nix allows you to have multiple versions of any package and non-conflicting dependencies.

To use Nix for a Haskell project, create a ‘default.nix‘ file to define your dependencies.

{ pkgs ? import <nixpkgs> {} }:
pkgs.haskellPackages.developPackage {
  root = pkgs.lib.cleanSource ./.;
  name = "myproject";
  isLibrary = true;
  isExecutable = true;
  withHoogle = true;
  buildTools = [pkgs.haskellPackages.cabal-install];
  buildDepends = [
    pkgs.haskellPackages.base
    pkgs.haskellPackages.text
    pkgs.haskellPackages.bytestring
  ];
}

In this example, ‘buildDepends‘ specifies the list of package dependencies for the Haskell project.

To manage dependencies with Nix:

1. Install Nix using the official instructions.

2. Run ‘nix-shell‘ in the project’s root directory. Nix will download, build, and enter an isolated environment with your dependencies and GHC available.

3. Use ‘cabal build‘ to build your project, and ‘cabal test‘ to run tests, if applicable.

4. Type ‘exit‘ to leave the Nix environment.

In summary, managing package dependencies in a Haskell project involves using a package management tool (Cabal, Stack, or Nix) and specifying dependencies in a configuration file (Cabal file, ‘stack.yaml‘, or ‘default.nix‘). The choice of which tool to use depends on your preferences and project requirements.