commit a7840a9ce876680fab3302a5a3abf2624371cf0e · pyrox.dev/nixpkgs

+17 -1

doc/default.nix

···

       6
        
       

     

       7
        
         sources = sourceFilesBySuffices ./. [".xml"];

     

       8
        
       

     

       9
       -
         buildInputs = [ libxml2 libxslt ];

     

       10
        
       

     

       11
        
         xsltFlags = ''

     

       12
        
           --param section.autolabel 1

     
···

       19
        
         '';

     

       20
        
       

     

       21
        
         buildCommand = ''

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       22
        
           ln -s "$sources/"*.xml .

     

       23
        
       

     

       24
        
           echo ${nixpkgsVersion} > .version

···

       6
        
       

     

       7
        
         sources = sourceFilesBySuffices ./. [".xml"];

     

       8
        
       

     

       9
       +
         buildInputs = [ pandoc libxml2 libxslt ];

     

       10
        
       

     

       11
        
         xsltFlags = ''

     

       12
        
           --param section.autolabel 1

     
···

       19
        
         '';

     

       20
        
       

     

       21
        
         buildCommand = ''

     

       22
       +
           {

     

       23
       +
             echo "<chapter xmlns=\"http://docbook.org/ns/docbook\""

     

       24
       +
             echo "         xmlns:xlink=\"http://www.w3.org/1999/xlink\""

     

       25
       +
             echo "         xml:id=\"users-guide-to-the-haskell-infrastructure\">"

     

       26
       +
             echo ""

     

       27
       +
             echo "<title>User's Guide to the Haskell Infrastructure</title>"

     

       28
       +
             echo ""

     

       29
       +
             pandoc ${./haskell-users-guide.md} -w docbook | \

     

       30
       +
               sed -e 's|<ulink url=|<link xlink:href=|' \

     

       31
       +
                   -e 's|</ulink>|</link>|' \

     

       32
       +
                   -e 's|<sect. id=|<section xml:id=|' \

     

       33
       +
                   -e 's|</sect[0-9]>|</section>|'

     

       34
       +
             echo ""

     

       35
       +
             echo "</chapter>"

     

       36
       +
           } >haskell-users-guide.xml

     

       37
       +
       

     

       38
        
           ln -s "$sources/"*.xml .

     

       39
        
       

     

       40
        
           echo ${nixpkgsVersion} > .version

+698

doc/haskell-users-guide.md

···

       1
       +
       ---

     

       2
       +
       title: User's Guide for Haskell in Nixpkgs

     

       3
       +
       author: Peter Simons

     

       4
       +
       date: 2015-06-01

     

       5
       +
       ---

     

       6
       +
       

     

       7
       +
       # How to install Haskell packages

     

       8
       +
       

     

       9
       +
       Nixpkgs distributes build instructions for all Haskell packages registered on

     

       10
       +
       [Hackage](http://hackage.haskell.org/), but strangely enough normal Nix package

     

       11
       +
       lookups don't seem to discover any of them, except for the default version of ghc, cabal-install, and stack:

     

       12
       +
       

     

       13
       +
           $ nix-env -i alex

     

       14
       +
           error: selector ‘alex’ matches no derivations

     

       15
       +
           $ nix-env -qa ghc

     

       16
       +
           ghc-7.10.2

     

       17
       +
       

     

       18
       +
       The Haskell package set is not registered in the top-level namespace because it

     

       19
       +
       is *huge*. If all Haskell packages were visible to these commands, then

     

       20
       +
       name-based search/install operations would be much slower than they are now. We

     

       21
       +
       avoided that by keeping all Haskell-related packages in a separate attribute

     

       22
       +
       set called `haskellPackages`, which the following command will list:

     

       23
       +
       

     

       24
       +
           $ nix-env -f "<nixpkgs>" -qaP -A haskellPackages

     

       25
       +
           haskellPackages.a50         a50-0.5

     

       26
       +
           haskellPackages.abacate     haskell-abacate-0.0.0.0

     

       27
       +
           haskellPackages.abcBridge   haskell-abcBridge-0.12

     

       28
       +
           haskellPackages.afv         afv-0.1.1

     

       29
       +
           haskellPackages.alex        alex-3.1.4

     

       30
       +
           haskellPackages.Allure      Allure-0.4.101.1

     

       31
       +
           haskellPackages.alms        alms-0.6.7

     

       32
       +
           [... some 8000 entries omitted  ...]

     

       33
       +
       

     

       34
       +
       To install any of those packages into your profile, refer to them by their

     

       35
       +
       attribute path (first column):

     

       36
       +
       

     

       37
       +
           $ nix-env -f "<nixpkgs>" -iA haskellPackages.Allure ...

     

       38
       +
       

     

       39
       +
       The attribute path of any Haskell packages corresponds to the name of that

     

       40
       +
       particular package on Hackage: the package `cabal-install` has the attribute

     

       41
       +
       `haskellPackages.cabal-install`, and so on. (Actually, this convention causes

     

       42
       +
       trouble with packages like `3dmodels` and `4Blocks`, because these names are

     

       43
       +
       invalid identifiers in the Nix language. The issue of how to deal with these

     

       44
       +
       rare corner cases is currently unresolved.)

     

       45
       +
       

     

       46
       +
       Haskell packages who's Nix name (second column) begins with a `haskell-` prefix

     

       47
       +
       are packages that provide a library whereas packages without that prefix

     

       48
       +
       provide just executables. Libraries may provide executables too, though: the

     

       49
       +
       package `haskell-pandoc`, for example, installs both a library and an

     

       50
       +
       application. You can install and use Haskell executables just like any other

     

       51
       +
       program in Nixpkgs, but using Haskell libraries for development is a bit

     

       52
       +
       trickier and we'll address that subject in great detail in section [How to

     

       53
       +
       create a development environment].

     

       54
       +
       

     

       55
       +
       Attribute paths are deterministic inside of Nixpkgs, but the path necessary to

     

       56
       +
       reach Nixpkgs varies from system to system. We dodged that problem by giving

     

       57
       +
       `nix-env` an explicit `-f "<nixpkgs>"` parameter, but if you call `nix-env`

     

       58
       +
       without that flag, then chances are the invocation fails:

     

       59
       +
       

     

       60
       +
           $ nix-env -iA haskellPackages.cabal-install

     

       61
       +
           error: attribute ‘haskellPackages’ in selection path

     

       62
       +
                  ‘haskellPackages.cabal-install’ not found

     

       63
       +
       

     

       64
       +
       On NixOS, for example, Nixpkgs does *not* exist in the top-level namespace by

     

       65
       +
       default. To figure out the proper attribute path, it's easiest to query for the

     

       66
       +
       path of a well-known Nixpkgs package, i.e.:

     

       67
       +
       

     

       68
       +
           $ nix-env -qaP coreutils

     

       69
       +
           nixos.coreutils  coreutils-8.23

     

       70
       +
       

     

       71
       +
       If your system responds like that (most NixOS installations will), then the

     

       72
       +
       attribute path to `haskellPackages` is `nixos.haskellPackages`. Thus, if you

     

       73
       +
       want to use `nix-env` without giving an explicit `-f` flag, then that's the way

     

       74
       +
       to do it:

     

       75
       +
       

     

       76
       +
           $ nix-env -qaP -A nixos.haskellPackages

     

       77
       +
           $ nix-env -iA nixos.haskellPackages.cabal-install

     

       78
       +
       

     

       79
       +
       Our current default compiler is GHC 7.10.x and the `haskellPackages` set

     

       80
       +
       contains packages built with that particular version. Nixpkgs contains the

     

       81
       +
       latest major release of every GHC since 6.10.4, however, and there is a whole

     

       82
       +
       family of package sets available that defines Hackage packages built with each

     

       83
       +
       of those compilers, too:

     

       84
       +
       

     

       85
       +
           $ nix-env -f "<nixpkgs>" -qaP -A haskell.packages.ghc6123

     

       86
       +
           $ nix-env -f "<nixpkgs>" -qaP -A haskell.packages.ghc763

     

       87
       +
       

     

       88
       +
       The name `haskellPackages` is really just a synonym for

     

       89
       +
       `haskell.packages.ghc7102`, because we prefer that package set internally and

     

       90
       +
       recommend it to our users as their default choice, but ultimately you are free

     

       91
       +
       to compile your Haskell packages with any GHC version you please. The following

     

       92
       +
       command displays the complete list of available compilers:

     

       93
       +
       

     

       94
       +
           $ nix-env -f "<nixpkgs>" -qaP -A haskell.compiler

     

       95
       +
           haskell.compiler.ghc6104        ghc-6.10.4

     

       96
       +
           haskell.compiler.ghc6123        ghc-6.12.3

     

       97
       +
           haskell.compiler.ghc704         ghc-7.0.4

     

       98
       +
           haskell.compiler.ghc722         ghc-7.2.2

     

       99
       +
           haskell.compiler.ghc742         ghc-7.4.2

     

       100
       +
           haskell.compiler.ghc763         ghc-7.6.3

     

       101
       +
           haskell.compiler.ghc784         ghc-7.8.4

     

       102
       +
           haskell.compiler.ghc7102        ghc-7.10.2

     

       103
       +
           haskell.compiler.ghcHEAD        ghc-7.11.20150402

     

       104
       +
           haskell.compiler.ghcNokinds     ghc-nokinds-7.11.20150704

     

       105
       +
           haskell.compiler.ghcjs          ghcjs-0.1.0

     

       106
       +
           haskell.compiler.jhc            jhc-0.8.2

     

       107
       +
           haskell.compiler.uhc            uhc-1.1.9.0

     

       108
       +
       

     

       109
       +
       We have no package sets for `jhc` or `uhc` yet, unfortunately, but for every

     

       110
       +
       version of GHC listed above, there exists a package set based on that compiler.

     

       111
       +
       Also, the attributes `haskell.compiler.ghcXYC` and

     

       112
       +
       `haskell.packages.ghcXYC.ghc` are synonymous for the sake of convenience.

     

       113
       +
       

     

       114
       +
       # How to create a development environment

     

       115
       +
       

     

       116
       +
       ## How to install a compiler

     

       117
       +
       

     

       118
       +
       A simple development environment consists of a Haskell compiler and the tool

     

       119
       +
       `cabal-install`, and we saw in section [How to install Haskell packages] how

     

       120
       +
       you can install those programs into your user profile:

     

       121
       +
       

     

       122
       +
           $ nix-env -f "<nixpkgs>" -iA haskellPackages.ghc haskellPackages.cabal-install

     

       123
       +
       

     

       124
       +
       Instead of the default package set `haskellPackages`, you can also use the more

     

       125
       +
       precise name `haskell.compiler.ghc7102`, which has the advantage that it refers

     

       126
       +
       to the same GHC version regardless of what Nixpkgs considers "default" at any

     

       127
       +
       given time.

     

       128
       +
       

     

       129
       +
       Once you've made those tools available in `$PATH`, it's possible to build

     

       130
       +
       Hackage packages the same way people without access to Nix do it all the time:

     

       131
       +
       

     

       132
       +
           $ cabal get lens-4.11 && cd lens-4.11

     

       133
       +
           $ cabal install -j --dependencies-only

     

       134
       +
           $ cabal configure

     

       135
       +
           $ cabal build

     

       136
       +
       

     

       137
       +
       If you enjoy working with Cabal sandboxes, then that's entirely possible too:

     

       138
       +
       just execute the command

     

       139
       +
       

     

       140
       +
           $ cabal sandbox init

     

       141
       +
       

     

       142
       +
       before installing the required dependencies.

     

       143
       +
       

     

       144
       +
       The `nix-shell` utility makes it easy to switch to a different compiler

     

       145
       +
       version; just enter the Nix shell environment with the command

     

       146
       +
       

     

       147
       +
           $ nix-shell -p haskell.compiler.ghc784

     

       148
       +
       

     

       149
       +
       to bring GHC 7.8.4 into `$PATH`. Re-running `cabal configure` switches your

     

       150
       +
       build to use that compiler instead. If you're working on a project that doesn't

     

       151
       +
       depend on any additional system libraries outside of GHC, then it's sufficient

     

       152
       +
       even to run the `cabal configure` command inside of the shell:

     

       153
       +
       

     

       154
       +
           $ nix-shell -p haskell.compiler.ghc784 --command "cabal configure"

     

       155
       +
       

     

       156
       +
       Afterwards, all other commands like `cabal build` work just fine in any shell

     

       157
       +
       environment, because the configure phase recorded the absolute paths to all

     

       158
       +
       required tools like GHC in its build configuration inside of the `dist/`

     

       159
       +
       directory. Please note, however, that `nix-collect-garbage` can break such an

     

       160
       +
       environment because the Nix store paths created by `nix-shell` aren't "alive"

     

       161
       +
       anymore once `nix-shell` has terminated. If you find that your Haskell builds

     

       162
       +
       no longer work after garbage collection, then you'll have to re-run `cabal

     

       163
       +
       configure` inside of a new `nix-shell` environment.

     

       164
       +
       

     

       165
       +
       ## How to install a compiler with libraries

     

       166
       +
       

     

       167
       +
       GHC expects to find all installed libraries inside of its own `lib` directory.

     

       168
       +
       This approach works fine on traditional Unix systems, but it doesn't work for

     

       169
       +
       Nix, because GHC's store path is immutable once it's built. We cannot install

     

       170
       +
       additional libraries into that location. As a consequence, our copies of GHC

     

       171
       +
       don't know any packages except their own core libraries, like `base`,

     

       172
       +
       `containers`, `Cabal`, etc.

     

       173
       +
       

     

       174
       +
       We can register additional libraries to GHC, however, using a special build

     

       175
       +
       function called `ghcWithPackages`. That function expects one argument: a

     

       176
       +
       function that maps from an attribute set of Haskell packages to a list of

     

       177
       +
       packages, which determines the libraries known to that particular version of

     

       178
       +
       GHC. For example, the Nix expression `ghcWithPackages (pkgs: [pkgs.mtl])`

     

       179
       +
       generates a copy of GHC that has the `mtl` library registered in addition to

     

       180
       +
       its normal core packages:

     

       181
       +
       

     

       182
       +
           $ nix-shell -p "haskellPackages.ghcWithPackages (pkgs: [pkgs.mtl])"

     

       183
       +
       

     

       184
       +
           [nix-shell:~]$ ghc-pkg list mtl

     

       185
       +
           /nix/store/zy79...-ghc-7.10.2/lib/ghc-7.10.2/package.conf.d:

     

       186
       +
               mtl-2.2.1

     

       187
       +
       

     

       188
       +
       This function allows users to define their own development environment by means

     

       189
       +
       of an override. After adding the following snippet to `~/.nixpkgs/config.nix`,

     

       190
       +
       

     

       191
       +
           {

     

       192
       +
             packageOverrides = super: let self = super.pkgs; in

     

       193
       +
             {

     

       194
       +
               myHaskellEnv = self.haskell.packages.ghc7102.ghcWithPackages

     

       195
       +
                                (haskellPackages: with haskellPackages; [

     

       196
       +
                                  # libraries

     

       197
       +
                                  arrows async cgi criterion

     

       198
       +
                                  # tools

     

       199
       +
                                  cabal-install haskintex

     

       200
       +
                                ]);

     

       201
       +
             };

     

       202
       +
           }

     

       203
       +
       

     

       204
       +
       it's possible to install that compiler with `nix-env -f "<nixpkgs>" -iA

     

       205
       +
       myHaskellEnv`. If you'd like to switch that development environment to a

     

       206
       +
       different version of GHC, just replace the `ghc7102` bit in the previous

     

       207
       +
       definition with the appropriate name. Of course, it's also possible to define

     

       208
       +
       any number of these development environments! (You can't install two of them

     

       209
       +
       into the same profile at the same time, though, because that would result in

     

       210
       +
       file conflicts.)

     

       211
       +
       

     

       212
       +
       The generated `ghc` program is a wrapper script that re-directs the real

     

       213
       +
       GHC executable to use a new `lib` directory --- one that we specifically

     

       214
       +
       constructed to contain all those packages the user requested:

     

       215
       +
       

     

       216
       +
           $ cat $(type -p ghc)

     

       217
       +
           #! /nix/store/xlxj...-bash-4.3-p33/bin/bash -e

     

       218
       +
           export NIX_GHC=/nix/store/19sm...-ghc-7.10.2/bin/ghc

     

       219
       +
           export NIX_GHCPKG=/nix/store/19sm...-ghc-7.10.2/bin/ghc-pkg

     

       220
       +
           export NIX_GHC_DOCDIR=/nix/store/19sm...-ghc-7.10.2/share/doc/ghc/html

     

       221
       +
           export NIX_GHC_LIBDIR=/nix/store/19sm...-ghc-7.10.2/lib/ghc-7.10.2

     

       222
       +
           exec /nix/store/j50p...-ghc-7.10.2/bin/ghc "-B$NIX_GHC_LIBDIR" "$@"

     

       223
       +
       

     

       224
       +
       The variables `$NIX_GHC`, `$NIX_GHCPKG`, etc. point to the *new* store path

     

       225
       +
       `ghcWithPackages` constructed specifically for this environment. The last line

     

       226
       +
       of the wrapper script then executes the real `ghc`, but passes the path to the

     

       227
       +
       new `lib` directory using GHC's `-B` flag.

     

       228
       +
       

     

       229
       +
       The purpose of those environment variables is to work around an impurity in the

     

       230
       +
       popular [ghc-paths](http://hackage.haskell.org/package/ghc-paths) library. That

     

       231
       +
       library promises to give its users access to GHC's installation paths. Only,

     

       232
       +
       the library can't possible know that path when it's compiled, because the path

     

       233
       +
       GHC considers its own is determined only much later, when the user configures

     

       234
       +
       it through `ghcWithPackages`. So we [patched

     

       235
       +
       ghc-paths](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/ghc-paths-nix.patch)

     

       236
       +
       to return the paths found in those environment variables at run-time rather

     

       237
       +
       than trying to guess them at compile-time.

     

       238
       +
       

     

       239
       +
       To make sure that mechanism works properly all the time, we recommend that you

     

       240
       +
       set those variables to meaningful values in your shell environment, too, i.e.

     

       241
       +
       by adding the following code to your `~/.bashrc`:

     

       242
       +
       

     

       243
       +
           if type >/dev/null 2>&1 -p ghc; then

     

       244
       +
             eval "$(egrep ^export "$(type -p ghc)")"

     

       245
       +
           fi

     

       246
       +
       

     

       247
       +
       If you are certain that you'll use only one GHC environment which is located in

     

       248
       +
       your user profile, then you can use the following code, too, which has the

     

       249
       +
       advantage that it doesn't contain any paths from the Nix store, i.e. those

     

       250
       +
       settings always remain valid even if a `nix-env -u` operation updates the GHC

     

       251
       +
       environment in your profile:

     

       252
       +
       

     

       253
       +
           if [ -e ~/.nix-profile/bin/ghc ]; then

     

       254
       +
             export NIX_GHC="$HOME/.nix-profile/bin/ghc"

     

       255
       +
             export NIX_GHCPKG="$HOME/.nix-profile/bin/ghc-pkg"

     

       256
       +
             export NIX_GHC_DOCDIR="$HOME/.nix-profile/share/doc/ghc/html"

     

       257
       +
             export NIX_GHC_LIBDIR="$HOME/.nix-profile/lib/ghc-$($NIX_GHC --numeric-version)"

     

       258
       +
           fi

     

       259
       +
       

     

       260
       +
       ## How to install a compiler with libraries, hoogle and documentation indexes

     

       261
       +
       

     

       262
       +
       If you plan to use your environment for interactive programming, not just

     

       263
       +
       compiling random Haskell code, you might want to replace `ghcWithPackages` in

     

       264
       +
       all the listings above with `ghcWithHoogle`.

     

       265
       +
       

     

       266
       +
       This environment generator not only produces an environment with GHC and all

     

       267
       +
       the specified libraries, but also generates a `hoogle` and `haddock` indexes

     

       268
       +
       for all the packages, and provides a wrapper script around `hoogle` binary that

     

       269
       +
       uses all those things. A precise name for this thing would be

     

       270
       +
       "`ghcWithPackagesAndHoogleAndDocumentationIndexes`", which is, regrettably, too

     

       271
       +
       long and scary.

     

       272
       +
       

     

       273
       +
       For example, installing the following environment

     

       274
       +
       

     

       275
       +
           {

     

       276
       +
             packageOverrides = super: let self = super.pkgs; in

     

       277
       +
             {

     

       278
       +
               myHaskellEnv = self.haskellPackages.ghcWithHoogle

     

       279
       +
                                (haskellPackages: with haskellPackages; [

     

       280
       +
                                  # libraries

     

       281
       +
                                  arrows async cgi criterion

     

       282
       +
                                  # tools

     

       283
       +
                                  cabal-install haskintex

     

       284
       +
                                ]);

     

       285
       +
             };

     

       286
       +
           }

     

       287
       +
       

     

       288
       +
       allows one to browse module documentation index [not too dissimilar to

     

       289
       +
       this](https://downloads.haskell.org/~ghc/latest/docs/html/libraries/index.html)

     

       290
       +
       for all the specified packages and their dependencies by directing a browser of

     

       291
       +
       choice to `~/.nix-profiles/share/doc/hoogle/index.html` (or

     

       292
       +
       `/run/current-system/sw/share/doc/hoogle/index.html` in case you put it in

     

       293
       +
       `environment.systemPackages` in NixOS).

     

       294
       +
       

     

       295
       +
       After you've marveled enough at that try adding the following to your

     

       296
       +
       `~/.ghc/ghci.conf`

     

       297
       +
       

     

       298
       +
           :def hoogle \s -> return $ ":! hoogle search -cl --count=15 \"" ++ s ++ "\""

     

       299
       +
           :def doc \s -> return $ ":! hoogle search -cl --info \"" ++ s ++ "\""

     

       300
       +
       

     

       301
       +
       and test it by typing into `ghci`:

     

       302
       +
       

     

       303
       +
           :hoogle a -> a

     

       304
       +
           :doc a -> a

     

       305
       +
       

     

       306
       +
       Be sure to note the links to `haddock` files in the output. With any modern and

     

       307
       +
       properly configured terminal emulator you can just click those links to

     

       308
       +
       navigate there.

     

       309
       +
       

     

       310
       +
       Finally, you can run

     

       311
       +
       

     

       312
       +
           hoogle server -p 8080

     

       313
       +
       

     

       314
       +
       and navigate to http://localhost:8080/ for your own local

     

       315
       +
       [Hoogle](https://www.haskell.org/hoogle/). Note, however, that Firefox and

     

       316
       +
       possibly other browsers disallow navigation from `http:` to `file:` URIs for

     

       317
       +
       security reasons, which might be quite an inconvenience. See [this

     

       318
       +
       page](http://kb.mozillazine.org/Links_to_local_pages_do_not_work) for

     

       319
       +
       workarounds.

     

       320
       +
       

     

       321
       +
       

     

       322
       +
       ## How to create ad hoc environments for `nix-shell`

     

       323
       +
       

     

       324
       +
       The easiest way to create an ad hoc development environment is to run

     

       325
       +
       `nix-shell` with the appropriate GHC environment given on the command-line:

     

       326
       +
       

     

       327
       +
           nix-shell -p "haskellPackages.ghcWithPackages (pkgs: with pkgs; [mtl pandoc])"

     

       328
       +
       

     

       329
       +
       For more sophisticated use-cases, however, it's more convenient to save the

     

       330
       +
       desired configuration in a file called `shell.nix` that looks like this:

     

       331
       +
       

     

       332
       +
           { nixpkgs ? import <nixpkgs> {}, compiler ? "ghc7102" }:

     

       333
       +
           let

     

       334
       +
             inherit (nixpkgs) pkgs;

     

       335
       +
             ghc = pkgs.haskell.packages.${compiler}.ghcWithPackages (ps: with ps; [

     

       336
       +
                     monad-par mtl

     

       337
       +
                   ]);

     

       338
       +
           in

     

       339
       +
           pkgs.stdenv.mkDerivation {

     

       340
       +
             name = "my-haskell-env-0";

     

       341
       +
             buildInputs = [ ghc ];

     

       342
       +
             shellHook = "eval $(egrep ^export ${ghc}/bin/ghc)";

     

       343
       +
           }

     

       344
       +
       

     

       345
       +
       Now run `nix-shell` --- or even `nix-shell --pure` --- to enter a shell

     

       346
       +
       environment that has the appropriate compiler in `$PATH`. If you use `--pure`,

     

       347
       +
       then add all other packages that your development environment needs into the

     

       348
       +
       `buildInputs` attribute. If you'd like to switch to a different compiler

     

       349
       +
       version, then pass an appropriate `compiler` argument to the expression, i.e.

     

       350
       +
       `nix-shell --argstr compiler ghc784`.

     

       351
       +
       

     

       352
       +
       If you need such an environment because you'd like to compile a Hackage package

     

       353
       +
       outside of Nix --- i.e. because you're hacking on the latest version from Git

     

       354
       +
       ---, then the package set provides suitable nix-shell environments for you

     

       355
       +
       already! Every Haskell package has an `env` attribute that provides a shell

     

       356
       +
       environment suitable for compiling that particular package. If you'd like to

     

       357
       +
       hack the `lens` library, for example, then you just have to check out the

     

       358
       +
       source code and enter the appropriate environment:

     

       359
       +
       

     

       360
       +
             $ cabal get lens-4.11 && cd lens-4.11

     

       361
       +
             Downloading lens-4.11...

     

       362
       +
             Unpacking to lens-4.11/

     

       363
       +
       

     

       364
       +
             $ nix-shell "<nixpkgs>" -A haskellPackages.lens.env

     

       365
       +
             [nix-shell:/tmp/lens-4.11]$

     

       366
       +
       

     

       367
       +
       At point, you can run `cabal configure`, `cabal build`, and all the other

     

       368
       +
       development commands. Note that you need `cabal-install` installed in your

     

       369
       +
       `$PATH` already to use it here --- the `nix-shell` environment does not provide

     

       370
       +
       it.

     

       371
       +
       

     

       372
       +
       # How to create Nix builds for your own private Haskell packages

     

       373
       +
       

     

       374
       +
       If your own Haskell packages have build instructions for Cabal, then you can

     

       375
       +
       convert those automatically into build instructions for Nix using the

     

       376
       +
       `cabal2nix` utility, which you can install into your profile by running

     

       377
       +
       `nix-env -i cabal2nix`.

     

       378
       +
       

     

       379
       +
       ## How to build a stand-alone project

     

       380
       +
       

     

       381
       +
       For example, let's assume that you're working on a private project called

     

       382
       +
       `foo`. To generate a Nix build expression for it, change into the project's

     

       383
       +
       top-level directory and run the command:

     

       384
       +
       

     

       385
       +
           $ cabal2nix . >foo.nix

     

       386
       +
       

     

       387
       +
       Then write the following snippet into a file called `default.nix`:

     

       388
       +
       

     

       389
       +
           { nixpkgs ? import <nixpkgs> {}, compiler ? "ghc7102" }:

     

       390
       +
           nixpkgs.pkgs.haskell.packages.${compiler}.callPackage ./foo.nix { }

     

       391
       +
       

     

       392
       +
       Finally, store the following code in a file called `shell.nix`:

     

       393
       +
       

     

       394
       +
           { nixpkgs ? import <nixpkgs> {}, compiler ? "ghc7102" }:

     

       395
       +
           (import ./default.nix { inherit nixpkgs compiler; }).env

     

       396
       +
       

     

       397
       +
       At this point, you can run `nix-build` to have Nix compile your project and

     

       398
       +
       install it into a Nix store path. The local directory will contain a symlink

     

       399
       +
       called `result` after `nix-build` returns that points into that location. Of

     

       400
       +
       course, passing the flag `--argstr compiler ghc763` allows switching the build

     

       401
       +
       to any version of GHC currently supported.

     

       402
       +
       

     

       403
       +
       Furthermore, you can call `nix-shell` to enter an interactive development

     

       404
       +
       environment in which you can use `cabal configure` and `cabal build` to develop

     

       405
       +
       your code. That environment will automatically contain a proper GHC derivation

     

       406
       +
       with all the required libraries registered as well as all the system-level

     

       407
       +
       libraries your package might need.

     

       408
       +
       

     

       409
       +
       If your package does not depend on any system-level libraries, then it's

     

       410
       +
       sufficient to run

     

       411
       +
       

     

       412
       +
           $ nix-shell --command "cabal configure"

     

       413
       +
       

     

       414
       +
       once to set up your build. `cabal-install` determines the absolute paths to all

     

       415
       +
       resources required for the build and writes them into a config file in the

     

       416
       +
       `dist/` directory. Once that's done, you can run `cabal build` and any other

     

       417
       +
       command for that project even outside of the `nix-shell` environment. This

     

       418
       +
       feature is particularly nice for those of us who like to edit their code with

     

       419
       +
       an IDE, like Emacs' `haskell-mode`, because it's not necessary to start Emacs

     

       420
       +
       inside of nix-shell just to make it find out the necessary settings for

     

       421
       +
       building the project; `cabal-install` has already done that for us.

     

       422
       +
       

     

       423
       +
       If you want to do some quick-and-dirty hacking and don't want to bother setting

     

       424
       +
       up a `default.nix` and `shell.nix` file manually, then you can use the

     

       425
       +
       `--shell` flag offered by `cabal2nix` to have it generate a stand-alone

     

       426
       +
       `nix-shell` environment for you. With that feature, running

     

       427
       +
       

     

       428
       +
           $ cabal2nix --shell . >shell.nix

     

       429
       +
           $ nix-shell --command "cabal configure"

     

       430
       +
       

     

       431
       +
       is usually enough to set up a build environment for any given Haskell package.

     

       432
       +
       You can even use that generated file to run `nix-build`, too:

     

       433
       +
       

     

       434
       +
           $ nix-build shell.nix

     

       435
       +
       

     

       436
       +
       ## How to build projects that depend on each other

     

       437
       +
       

     

       438
       +
       If you have multiple private Haskell packages that depend on each other, then

     

       439
       +
       you'll have to register those packages in the Nixpkgs set to make them visible

     

       440
       +
       for the dependency resolution performed by `callPackage`. First of all, change

     

       441
       +
       into each of your projects top-level directories and generate a `default.nix`

     

       442
       +
       file with `cabal2nix`:

     

       443
       +
       

     

       444
       +
           $ cd ~/src/foo && cabal2nix . >default.nix

     

       445
       +
           $ cd ~/src/bar && cabal2nix . >default.nix

     

       446
       +
       

     

       447
       +
       Then edit your `~/.nixpkgs/config.nix` file to register those builds in the

     

       448
       +
       default Haskell package set:

     

       449
       +
       

     

       450
       +
             {

     

       451
       +
               packageOverrides = super: let self = super.pkgs; in

     

       452
       +
               {

     

       453
       +
                 haskellPackages = super.haskellPackages.override {

     

       454
       +
                   overrides = self: super: {

     

       455
       +
                     foo = self.callPackage ../src/foo {};

     

       456
       +
                     bar = self.callPackage ../src/bar {};

     

       457
       +
                   };

     

       458
       +
                 };

     

       459
       +
               };

     

       460
       +
             }

     

       461
       +
       

     

       462
       +
       Once that's accomplished, `nix-env -f "<nixpkgs>" -qA haskellPackages` will

     

       463
       +
       show your packages like any other package from Hackage, and you can build them

     

       464
       +
       

     

       465
       +
           $ nix-build "<nixpkgs>" -A haskellPackages.foo

     

       466
       +
       

     

       467
       +
       or enter an interactive shell environment suitable for building them:

     

       468
       +
       

     

       469
       +
           $ nix-shell "<nixpkgs>" -A haskellPackages.bar.env

     

       470
       +
       

     

       471
       +
       # Miscellaneous Topics

     

       472
       +
       

     

       473
       +
       ## How to build with profiling enabled

     

       474
       +
       

     

       475
       +
       Every Haskell package set takes a function called `overrides` that you can use

     

       476
       +
       to manipulate the package as much as you please. One useful application of this

     

       477
       +
       feature is to replace the default `mkDerivation` function with one that enables

     

       478
       +
       library profiling for all packages. To accomplish that, add configure the

     

       479
       +
       following snippet in your `~/.nixpkgs/config.nix` file:

     

       480
       +
       

     

       481
       +
           {

     

       482
       +
             packageOverrides = super: let self = super.pkgs; in

     

       483
       +
             {

     

       484
       +
               profiledHaskellPackages = self.haskellPackages.override {

     

       485
       +
                 overrides = self: super: {

     

       486
       +
                   mkDerivation = args: super.mkDerivation (args // {

     

       487
       +
                     enableLibraryProfiling = true;

     

       488
       +
                   });

     

       489
       +
                 };

     

       490
       +
               };

     

       491
       +
             };

     

       492
       +
           }

     

       493
       +
       

     

       494
       +
       Then, replace instances of `haskellPackages` in the `cabal2nix`-generated

     

       495
       +
       `default.nix` or `shell.nix` files with `profiledHaskellPackages`.

     

       496
       +
       

     

       497
       +
       ## How to override package versions in a compiler-specific package set

     

       498
       +
       

     

       499
       +
       Nixpkgs provides the latest version of

     

       500
       +
       [`ghc-events`](http://hackage.haskell.org/package/ghc-events), which is 0.4.4.0

     

       501
       +
       at the time of this writing. This is fine for users of GHC 7.10.x, but GHC

     

       502
       +
       7.8.4 cannot compile that binary. Now, one way to solve that problem is to

     

       503
       +
       register an older version of `ghc-events` in the 7.8.x-specific package set.

     

       504
       +
       The first step is to generate Nix build instructions with `cabal2nix`:

     

       505
       +
       

     

       506
       +
           $ cabal2nix cabal://ghc-events-0.4.3.0 >~/.nixpkgs/ghc-events-0.4.3.0.nix

     

       507
       +
       

     

       508
       +
       Then add the override in `~/.nixpkgs/config.nix`:

     

       509
       +
       

     

       510
       +
           {

     

       511
       +
             packageOverrides = super: let self = super.pkgs; in

     

       512
       +
             {

     

       513
       +
               haskell = super.haskell // {

     

       514
       +
                 packages = super.haskell.packages // {

     

       515
       +
                   ghc784 = super.haskell.packages.ghc784.override {

     

       516
       +
                     overrides = self: super: {

     

       517
       +
                       ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {};

     

       518
       +
                     };

     

       519
       +
                   };

     

       520
       +
                 };

     

       521
       +
               };

     

       522
       +
             };

     

       523
       +
           }

     

       524
       +
       

     

       525
       +
       This code is a little crazy, no doubt, but it's necessary because the intuitive

     

       526
       +
       version

     

       527
       +
       

     

       528
       +
           haskell.packages.ghc784 = super.haskell.packages.ghc784.override {

     

       529
       +
             overrides = self: super: {

     

       530
       +
               ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {};

     

       531
       +
             };

     

       532
       +
           };

     

       533
       +
       

     

       534
       +
       doesn't do what we want it to: that code replaces the `haskell` package set in

     

       535
       +
       Nixpkgs with one that contains only one entry,`packages`, which contains only

     

       536
       +
       one entry `ghc784`. This override loses the `haskell.compiler` set, and it

     

       537
       +
       loses the `haskell.packages.ghcXYZ` sets for all compilers but GHC 7.8.4. To

     

       538
       +
       avoid that problem, we have to perform the convoluted little dance from above,

     

       539
       +
       iterating over each step in hierarchy.

     

       540
       +
       

     

       541
       +
       Once it's accomplished, however, we can install a variant of `ghc-events`

     

       542
       +
       that's compiled with GHC 7.8.4:

     

       543
       +
       

     

       544
       +
           nix-env -f "<nixpkgs>" -iA haskell.packages.ghc784.ghc-events

     

       545
       +
       

     

       546
       +
       Unfortunately, it turns out that this build fails again while executing the

     

       547
       +
       test suite! Apparently, the release archive on Hackage is missing some data

     

       548
       +
       files that the test suite requires, so we cannot run it. We accomplish that by

     

       549
       +
       re-generating the Nix expression with the `--no-check` flag:

     

       550
       +
       

     

       551
       +
           $ cabal2nix --no-check cabal://ghc-events-0.4.3.0 >~/.nixpkgs/ghc-events-0.4.3.0.nix

     

       552
       +
       

     

       553
       +
       Now the builds succeeds.

     

       554
       +
       

     

       555
       +
       Of course, in the concrete example of `ghc-events` this whole exercise is not

     

       556
       +
       an ideal solution, because `ghc-events` can analyze the output emitted by any

     

       557
       +
       version of GHC later than 6.12 regardless of the compiler version that was used

     

       558
       +
       to build the `ghc-events' executable, so strictly speaking there's no reason to

     

       559
       +
       prefer one built with GHC 7.8.x in the first place. However, for users who

     

       560
       +
       cannot use GHC 7.10.x at all for some reason, the approach of downgrading to an

     

       561
       +
       older version might be useful.

     

       562
       +
       

     

       563
       +
       ## How to recover from GHC's infamous non-deterministic library ID bug

     

       564
       +
       

     

       565
       +
       GHC and distributed build farms don't get along well:

     

       566
       +
       

     

       567
       +
           https://ghc.haskell.org/trac/ghc/ticket/4012

     

       568
       +
       

     

       569
       +
       When you see an error like this one

     

       570
       +
       

     

       571
       +
           package foo-0.7.1.0 is broken due to missing package

     

       572
       +
           text-1.2.0.4-98506efb1b9ada233bb5c2b2db516d91

     

       573
       +
       

     

       574
       +
       then you have to download and re-install `foo` and all its dependents from

     

       575
       +
       scratch:

     

       576
       +
       

     

       577
       +
           # nix-store -q --referrers /nix/store/*-haskell-text-1.2.0.4 \

     

       578
       +
             | xargs -L 1 nix-store --repair-path --option binary-caches http://hydra.nixos.org

     

       579
       +
       

     

       580
       +
       If you're using additional Hydra servers other than `hydra.nixos.org`, then it

     

       581
       +
       might be necessary to purge the local caches that store data from those

     

       582
       +
       machines to disable these binary channels for the duration of the previous

     

       583
       +
       command, i.e. by running:

     

       584
       +
       

     

       585
       +
           rm /nix/var/nix/binary-cache-v3.sqlite

     

       586
       +
           rm /nix/var/nix/manifests/*

     

       587
       +
           rm /nix/var/nix/channel-cache/*

     

       588
       +
       

     

       589
       +
       ## Builds on Darwin fail with `math.h` not found

     

       590
       +
       

     

       591
       +
       Users of GHC on Darwin have occasionally reported that builds fail, because the

     

       592
       +
       compiler complains about a missing include file:

     

       593
       +
       

     

       594
       +
           fatal error: 'math.h' file not found

     

       595
       +
       

     

       596
       +
       The issue has been discussed at length in [ticket

     

       597
       +
       6390](https://github.com/NixOS/nixpkgs/issues/6390), and so far no good

     

       598
       +
       solution has been proposed. As a work-around, users who run into this problem

     

       599
       +
       can configure the environment variables

     

       600
       +
       

     

       601
       +
           export NIX_CFLAGS_COMPILE="-idirafter /usr/include"

     

       602
       +
           export NIX_CFLAGS_LINK="-L/usr/lib"

     

       603
       +
       

     

       604
       +
       in their `~/.bashrc` file to avoid the compiler error.

     

       605
       +
       

     

       606
       +
       ## Using Stack together with Nix

     

       607
       +
       

     

       608
       +
           --  While building package zlib-0.5.4.2 using:

     

       609
       +
             runhaskell -package=Cabal-1.22.4.0 -clear-package-db [... lots of flags ...]

     

       610
       +
           Process exited with code: ExitFailure 1

     

       611
       +
           Logs have been written to: /home/foo/src/stack-ide/.stack-work/logs/zlib-0.5.4.2.log

     

       612
       +
       

     

       613
       +
           Configuring zlib-0.5.4.2...

     

       614
       +
           Setup.hs: Missing dependency on a foreign library:

     

       615
       +
           * Missing (or bad) header file: zlib.h

     

       616
       +
           This problem can usually be solved by installing the system package that

     

       617
       +
           provides this library (you may need the "-dev" version). If the library is

     

       618
       +
           already installed but in a non-standard location then you can use the flags

     

       619
       +
           --extra-include-dirs= and --extra-lib-dirs= to specify where it is.

     

       620
       +
           If the header file does exist, it may contain errors that are caught by the C

     

       621
       +
           compiler at the preprocessing stage. In this case you can re-run configure

     

       622
       +
           with the verbosity flag -v3 to see the error messages.

     

       623
       +
       

     

       624
       +
       When you run the build inside of the nix-shell environment, the system

     

       625
       +
       is configured to find libz.so without any special flags -- the compiler

     

       626
       +
       and linker "just know" how to find it. Consequently, Cabal won't record

     

       627
       +
       any search paths for libz.so in the package description, which means

     

       628
       +
       that the package works fine inside of nix-shell, but once you leave the

     

       629
       +
       shell the shared object can no longer be found. That issue is by no

     

       630
       +
       means specific to Stack: you'll have that problem with any other

     

       631
       +
       Haskell package that's built inside of nix-shell but run outside of that

     

       632
       +
       environment.

     

       633
       +
       

     

       634
       +
       I suppose we could try to remedy the issue by wrapping `stack` or

     

       635
       +
       `cabal` with a script that tries to find those kind of implicit search

     

       636
       +
       paths and makes them explicit on the "cabal configure" command line. I

     

       637
       +
       don't think anyone is working on that subject yet, though, because the

     

       638
       +
       problem doesn't seem so bad in practice.

     

       639
       +
       

     

       640
       +
       You can remedy that issue in several ways. First of all, run

     

       641
       +
       

     

       642
       +
           $ nix-build --no-out-link "<nixpkgs>" -A zlib

     

       643
       +
           /nix/store/alsvwzkiw4b7ip38l4nlfjijdvg3fvzn-zlib-1.2.8

     

       644
       +
       

     

       645
       +
       to find out the store path of the system's zlib library. Now, you can

     

       646
       +
       

     

       647
       +
       1) add that path (plus a "/lib" suffix) to your $LD_LIBRARY_PATH

     

       648
       +
          environment variable to make sure your system linker finds libz.so

     

       649
       +
          automatically. It's no pretty solution, but it will work.

     

       650
       +
       

     

       651
       +
       2) As a variant of (1), you can also install any number of system

     

       652
       +
          libraries into your user's profile (or some other profile) and point

     

       653
       +
          $LD_LIBRARY_PATH to that profile instead, so that you don't have to

     

       654
       +
          list dozens of those store paths all over the place.

     

       655
       +
       

     

       656
       +
       3) The solution I prefer is to call stack with an appropriate

     

       657
       +
          --extra-lib-dirs flag like so:

     

       658
       +
       

     

       659
       +
           $ stack --extra-lib-dirs=/nix/store/alsvwzkiw4b7ip38l4nlfjijdvg3fvzn-zlib-1.2.8/lib build

     

       660
       +
       

     

       661
       +
          Typically, you'll need --extra-include-dirs as well. It's possible

     

       662
       +
          to add those flag to the project's "stack.yaml" or your user's

     

       663
       +
          global "~/.stack/global/stack.yaml" file so that you don't have to

     

       664
       +
          specify them manually every time.

     

       665
       +
       

     

       666
       +
          The same thing applies to `cabal configure`, of course, if you're

     

       667
       +
          building with `cabal-install` instead of Stack.

     

       668
       +
       

     

       669
       +
       

     

       670
       +
       # Other resources

     

       671
       +
       

     

       672
       +
       - The Youtube video [Nix Loves Haskell](https://www.youtube.com/watch?v=BsBhi_r-OeE)

     

       673
       +
         provides an introduction into Haskell NG aimed at beginners. The slides are

     

       674
       +
         available at http://cryp.to/nixos-meetup-3-slides.pdf and also -- in a form

     

       675
       +
         ready for cut & paste -- at

     

       676
       +
         https://github.com/NixOS/cabal2nix/blob/master/doc/nixos-meetup-3-slides.md.

     

       677
       +
       

     

       678
       +
       - Another Youtube video is [Escaping Cabal Hell with Nix](https://www.youtube.com/watch?v=mQd3s57n_2Y),

     

       679
       +
         which discusses the subject of Haskell development with Nix but also provides

     

       680
       +
         a basic introduction to Nix as well, i.e. it's suitable for viewers with

     

       681
       +
         almost no prior Nix experience.

     

       682
       +
       

     

       683
       +
       - Oliver Charles wrote a very nice [Tutorial how to develop Haskell packages with Nix](http://wiki.ocharles.org.uk/Nix).

     

       684
       +
       

     

       685
       +
       - The *Journey into the Haskell NG infrastructure* series of postings

     

       686
       +
         describe the new Haskell infrastructure in great detail:

     

       687
       +
       

     

       688
       +
           - [Part 1](http://lists.science.uu.nl/pipermail/nix-dev/2015-January/015591.html)

     

       689
       +
             explains the differences between the old and the new code and gives

     

       690
       +
             instructions how to migrate to the new setup.

     

       691
       +
       

     

       692
       +
           - [Part 2](http://lists.science.uu.nl/pipermail/nix-dev/2015-January/015608.html)

     

       693
       +
             looks in-depth at how to tweak and configure your setup by means of

     

       694
       +
             overrides.

     

       695
       +
       

     

       696
       +
           - [Part 3](http://lists.science.uu.nl/pipermail/nix-dev/2015-April/016912.html)

     

       697
       +
             describes the infrastructure that keeps the Haskell package set in Nixpkgs

     

       698
       +
             up-to-date.

-912

doc/haskell-users-guide.xml

···

       1
       -
       <chapter xmlns="http://docbook.org/ns/docbook"

     

       2
       -
                xmlns:xlink="http://www.w3.org/1999/xlink"

     

       3
       -
                xml:id="users-guide-to-the-haskell-infrastructure">

     

       4
       -
       

     

       5
       -
       <title>User's Guide to the Haskell Infrastructure</title>

     

       6
       -
       

     

       7
       -
       <section xml:id="how-to-install-haskell-packages">

     

       8
       -
         <title>How to install Haskell packages</title>

     

       9
       -
         <para>

     

       10
       -
           Nixpkgs distributes build instructions for all Haskell packages

     

       11
       -
           registered on

     

       12
       -
           <link xlink:href="http://hackage.haskell.org/">Hackage</link>, but

     

       13
       -
           strangely enough normal Nix package lookups don't seem to discover

     

       14
       -
           any of them, except for the default version of ghc, cabal-install, and stack:

     

       15
       -
         </para>

     

       16
       -
         <programlisting>

     

       17
       -
       $ nix-env -i alex

     

       18
       -
       error: selector ‘alex’ matches no derivations

     

       19
       -
       $ nix-env -qa ghc

     

       20
       -
       ghc-7.10.2

     

       21
       -
       </programlisting>

     

       22
       -
         <para>

     

       23
       -
           The Haskell package set is not registered in the top-level namespace

     

       24
       -
           because it is <emphasis>huge</emphasis>. If all Haskell packages

     

       25
       -
           were visible to these commands, then name-based search/install

     

       26
       -
           operations would be much slower than they are now. We avoided that

     

       27
       -
           by keeping all Haskell-related packages in a separate attribute set

     

       28
       -
           called <literal>haskellPackages</literal>, which the following

     

       29
       -
           command will list:

     

       30
       -
         </para>

     

       31
       -
         <programlisting>

     

       32
       -
       $ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskellPackages

     

       33
       -
       haskellPackages.a50         a50-0.5

     

       34
       -
       haskellPackages.abacate     haskell-abacate-0.0.0.0

     

       35
       -
       haskellPackages.abcBridge   haskell-abcBridge-0.12

     

       36
       -
       haskellPackages.afv         afv-0.1.1

     

       37
       -
       haskellPackages.alex        alex-3.1.4

     

       38
       -
       haskellPackages.Allure      Allure-0.4.101.1

     

       39
       -
       haskellPackages.alms        alms-0.6.7

     

       40
       -
       [... some 8000 entries omitted  ...]

     

       41
       -
       </programlisting>

     

       42
       -
         <para>

     

       43
       -
           To install any of those packages into your profile, refer to them by

     

       44
       -
           their attribute path (first column):

     

       45
       -
         </para>

     

       46
       -
         <programlisting>

     

       47
       -
       $ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskellPackages.Allure ...

     

       48
       -
       </programlisting>

     

       49
       -
         <para>

     

       50
       -
           The attribute path of any Haskell packages corresponds to the name

     

       51
       -
           of that particular package on Hackage: the package

     

       52
       -
           <literal>cabal-install</literal> has the attribute

     

       53
       -
           <literal>haskellPackages.cabal-install</literal>, and so on.

     

       54
       -
           (Actually, this convention causes trouble with packages like

     

       55
       -
           <literal>3dmodels</literal> and <literal>4Blocks</literal>, because

     

       56
       -
           these names are invalid identifiers in the Nix language. The issue

     

       57
       -
           of how to deal with these rare corner cases is currently

     

       58
       -
           unresolved.)

     

       59
       -
         </para>

     

       60
       -
         <para>

     

       61
       -
           Haskell packages who's Nix name (second column) begins with a

     

       62
       -
           <literal>haskell-</literal> prefix are packages that provide a

     

       63
       -
           library whereas packages without that prefix provide just

     

       64
       -
           executables. Libraries may provide executables too, though: the

     

       65
       -
           package <literal>haskell-pandoc</literal>, for example, installs

     

       66
       -
           both a library and an application. You can install and use Haskell

     

       67
       -
           executables just like any other program in Nixpkgs, but using

     

       68
       -
           Haskell libraries for development is a bit trickier and we'll

     

       69
       -
           address that subject in great detail in section

     

       70
       -
           <link linkend="how-to-create-a-development-environment">How to

     

       71
       -
           create a development environment</link>.

     

       72
       -
         </para>

     

       73
       -
         <para>

     

       74
       -
           Attribute paths are deterministic inside of Nixpkgs, but the path

     

       75
       -
           necessary to reach Nixpkgs varies from system to system. We dodged

     

       76
       -
           that problem by giving <literal>nix-env</literal> an explicit

     

       77
       -
           <literal>-f &quot;&lt;nixpkgs&gt;&quot;</literal> parameter, but if

     

       78
       -
           you call <literal>nix-env</literal> without that flag, then chances

     

       79
       -
           are the invocation fails:

     

       80
       -
         </para>

     

       81
       -
         <programlisting>

     

       82
       -
       $ nix-env -iA haskellPackages.cabal-install

     

       83
       -
       error: attribute ‘haskellPackages’ in selection path

     

       84
       -
              ‘haskellPackages.cabal-install’ not found

     

       85
       -
       </programlisting>

     

       86
       -
         <para>

     

       87
       -
           On NixOS, for example, Nixpkgs does <emphasis>not</emphasis> exist

     

       88
       -
           in the top-level namespace by default. To figure out the proper

     

       89
       -
           attribute path, it's easiest to query for the path of a well-known

     

       90
       -
           Nixpkgs package, i.e.:

     

       91
       -
         </para>

     

       92
       -
         <programlisting>

     

       93
       -
       $ nix-env -qaP coreutils

     

       94
       -
       nixos.coreutils  coreutils-8.23

     

       95
       -
       </programlisting>

     

       96
       -
         <para>

     

       97
       -
           If your system responds like that (most NixOS installations will),

     

       98
       -
           then the attribute path to <literal>haskellPackages</literal> is

     

       99
       -
           <literal>nixos.haskellPackages</literal>. Thus, if you want to

     

       100
       -
           use <literal>nix-env</literal> without giving an explicit

     

       101
       -
           <literal>-f</literal> flag, then that's the way to do it:

     

       102
       -
         </para>

     

       103
       -
         <programlisting>

     

       104
       -
       $ nix-env -qaP -A nixos.haskellPackages

     

       105
       -
       $ nix-env -iA nixos.haskellPackages.cabal-install

     

       106
       -
       </programlisting>

     

       107
       -
         <para>

     

       108
       -
           Our current default compiler is GHC 7.10.x and the

     

       109
       -
           <literal>haskellPackages</literal> set contains packages built with

     

       110
       -
           that particular version. Nixpkgs contains the latest major release

     

       111
       -
           of every GHC since 6.10.4, however, and there is a whole family of

     

       112
       -
           package sets available that defines Hackage packages built with each

     

       113
       -
           of those compilers, too:

     

       114
       -
         </para>

     

       115
       -
         <programlisting>

     

       116
       -
       $ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskell.packages.ghc6123

     

       117
       -
       $ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskell.packages.ghc763

     

       118
       -
       </programlisting>

     

       119
       -
         <para>

     

       120
       -
           The name <literal>haskellPackages</literal> is really just a synonym

     

       121
       -
           for <literal>haskell.packages.ghc7102</literal>, because we prefer

     

       122
       -
           that package set internally and recommend it to our users as their

     

       123
       -
           default choice, but ultimately you are free to compile your Haskell

     

       124
       -
           packages with any GHC version you please. The following command

     

       125
       -
           displays the complete list of available compilers:

     

       126
       -
         </para>

     

       127
       -
         <programlisting>

     

       128
       -
       $ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskell.compiler

     

       129
       -
       haskell.compiler.ghc6104        ghc-6.10.4

     

       130
       -
       haskell.compiler.ghc6123        ghc-6.12.3

     

       131
       -
       haskell.compiler.ghc704         ghc-7.0.4

     

       132
       -
       haskell.compiler.ghc722         ghc-7.2.2

     

       133
       -
       haskell.compiler.ghc742         ghc-7.4.2

     

       134
       -
       haskell.compiler.ghc763         ghc-7.6.3

     

       135
       -
       haskell.compiler.ghc784         ghc-7.8.4

     

       136
       -
       haskell.compiler.ghc7102        ghc-7.10.2

     

       137
       -
       haskell.compiler.ghcHEAD        ghc-7.11.20150402

     

       138
       -
       haskell.compiler.ghcNokinds     ghc-nokinds-7.11.20150704

     

       139
       -
       haskell.compiler.ghcjs          ghcjs-0.1.0

     

       140
       -
       haskell.compiler.jhc            jhc-0.8.2

     

       141
       -
       haskell.compiler.uhc            uhc-1.1.9.0

     

       142
       -
       </programlisting>

     

       143
       -
         <para>

     

       144
       -
           We have no package sets for <literal>jhc</literal> or

     

       145
       -
           <literal>uhc</literal> yet, unfortunately, but for every version of

     

       146
       -
           GHC listed above, there exists a package set based on that compiler.

     

       147
       -
           Also, the attributes <literal>haskell.compiler.ghcXYC</literal> and

     

       148
       -
           <literal>haskell.packages.ghcXYC.ghc</literal> are synonymous for

     

       149
       -
           the sake of convenience.

     

       150
       -
         </para>

     

       151
       -
       </section>

     

       152
       -
       <section xml:id="how-to-create-a-development-environment">

     

       153
       -
         <title>How to create a development environment</title>

     

       154
       -
         <section xml:id="how-to-install-a-compiler">

     

       155
       -
           <title>How to install a compiler</title>

     

       156
       -
           <para>

     

       157
       -
             A simple development environment consists of a Haskell compiler

     

       158
       -
             and the tool <literal>cabal-install</literal>, and we saw in

     

       159
       -
             section <link linkend="how-to-install-haskell-packages">How to

     

       160
       -
             install Haskell packages</link> how you can install those programs

     

       161
       -
             into your user profile:

     

       162
       -
           </para>

     

       163
       -
           <programlisting>

     

       164
       -
       $ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskellPackages.ghc haskellPackages.cabal-install

     

       165
       -
       </programlisting>

     

       166
       -
           <para>

     

       167
       -
             Instead of the default package set

     

       168
       -
             <literal>haskellPackages</literal>, you can also use the more

     

       169
       -
             precise name <literal>haskell.compiler.ghc7102</literal>, which

     

       170
       -
             has the advantage that it refers to the same GHC version

     

       171
       -
             regardless of what Nixpkgs considers &quot;default&quot; at any

     

       172
       -
             given time.

     

       173
       -
           </para>

     

       174
       -
           <para>

     

       175
       -
             Once you've made those tools available in

     

       176
       -
             <literal>$PATH</literal>, it's possible to build Hackage packages

     

       177
       -
             the same way people without access to Nix do it all the time:

     

       178
       -
           </para>

     

       179
       -
           <programlisting>

     

       180
       -
       $ cabal get lens-4.11 &amp;&amp; cd lens-4.11

     

       181
       -
       $ cabal install -j --dependencies-only

     

       182
       -
       $ cabal configure

     

       183
       -
       $ cabal build

     

       184
       -
       </programlisting>

     

       185
       -
           <para>

     

       186
       -
             If you enjoy working with Cabal sandboxes, then that's entirely

     

       187
       -
             possible too: just execute the command

     

       188
       -
           </para>

     

       189
       -
           <programlisting>

     

       190
       -
       $ cabal sandbox init

     

       191
       -
       </programlisting>

     

       192
       -
           <para>

     

       193
       -
             before installing the required dependencies.

     

       194
       -
           </para>

     

       195
       -
           <para>

     

       196
       -
             The <literal>nix-shell</literal> utility makes it easy to switch

     

       197
       -
             to a different compiler version; just enter the Nix shell

     

       198
       -
             environment with the command

     

       199
       -
           </para>

     

       200
       -
           <programlisting>

     

       201
       -
       $ nix-shell -p haskell.compiler.ghc784

     

       202
       -
       </programlisting>

     

       203
       -
           <para>

     

       204
       -
             to bring GHC 7.8.4 into <literal>$PATH</literal>. Re-running

     

       205
       -
             <literal>cabal configure</literal> switches your build to use that

     

       206
       -
             compiler instead. If you're working on a project that doesn't

     

       207
       -
             depend on any additional system libraries outside of GHC, then

     

       208
       -
             it's sufficient even to run the <literal>cabal configure</literal>

     

       209
       -
             command inside of the shell:

     

       210
       -
           </para>

     

       211
       -
           <programlisting>

     

       212
       -
       $ nix-shell -p haskell.compiler.ghc784 --command &quot;cabal configure&quot;

     

       213
       -
       </programlisting>

     

       214
       -
           <para>

     

       215
       -
             Afterwards, all other commands like <literal>cabal build</literal>

     

       216
       -
             work just fine in any shell environment, because the configure

     

       217
       -
             phase recorded the absolute paths to all required tools like GHC

     

       218
       -
             in its build configuration inside of the <literal>dist/</literal>

     

       219
       -
             directory. Please note, however, that

     

       220
       -
             <literal>nix-collect-garbage</literal> can break such an

     

       221
       -
             environment because the Nix store paths created by

     

       222
       -
             <literal>nix-shell</literal> aren't &quot;alive&quot; anymore once

     

       223
       -
             <literal>nix-shell</literal> has terminated. If you find that your

     

       224
       -
             Haskell builds no longer work after garbage collection, then

     

       225
       -
             you'll have to re-run <literal>cabal configure</literal> inside of

     

       226
       -
             a new <literal>nix-shell</literal> environment.

     

       227
       -
           </para>

     

       228
       -
         </section>

     

       229
       -
         <section xml:id="how-to-install-a-compiler-with-libraries">

     

       230
       -
           <title>How to install a compiler with libraries</title>

     

       231
       -
           <para>

     

       232
       -
             GHC expects to find all installed libraries inside of its own

     

       233
       -
             <literal>lib</literal> directory. This approach works fine on

     

       234
       -
             traditional Unix systems, but it doesn't work for Nix, because

     

       235
       -
             GHC's store path is immutable once it's built. We cannot install

     

       236
       -
             additional libraries into that location. As a consequence, our

     

       237
       -
             copies of GHC don't know any packages except their own core

     

       238
       -
             libraries, like <literal>base</literal>,

     

       239
       -
             <literal>containers</literal>, <literal>Cabal</literal>, etc.

     

       240
       -
           </para>

     

       241
       -
           <para>

     

       242
       -
             We can register additional libraries to GHC, however, using a

     

       243
       -
             special build function called <literal>ghcWithPackages</literal>.

     

       244
       -
             That function expects one argument: a function that maps from an

     

       245
       -
             attribute set of Haskell packages to a list of packages, which

     

       246
       -
             determines the libraries known to that particular version of GHC.

     

       247
       -
             For example, the Nix expression

     

       248
       -
             <literal>ghcWithPackages (pkgs: [pkgs.mtl])</literal> generates a

     

       249
       -
             copy of GHC that has the <literal>mtl</literal> library registered

     

       250
       -
             in addition to its normal core packages:

     

       251
       -
           </para>

     

       252
       -
           <programlisting>

     

       253
       -
       $ nix-shell -p &quot;haskellPackages.ghcWithPackages (pkgs: [pkgs.mtl])&quot;

     

       254
       -
       

     

       255
       -
       [nix-shell:~]$ ghc-pkg list mtl

     

       256
       -
       /nix/store/zy79...-ghc-7.10.2/lib/ghc-7.10.2/package.conf.d:

     

       257
       -
           mtl-2.2.1

     

       258
       -
       </programlisting>

     

       259
       -
           <para>

     

       260
       -
             This function allows users to define their own development

     

       261
       -
             environment by means of an override. After adding the following

     

       262
       -
             snippet to <literal>~/.nixpkgs/config.nix</literal>,

     

       263
       -
           </para>

     

       264
       -
           <programlisting>

     

       265
       -
       {

     

       266
       -
         packageOverrides = super: let self = super.pkgs; in

     

       267
       -
         {

     

       268
       -
           myHaskellEnv = self.haskell.packages.ghc7102.ghcWithPackages

     

       269
       -
                            (haskellPackages: with haskellPackages; [

     

       270
       -
                              # libraries

     

       271
       -
                              arrows async cgi criterion

     

       272
       -
                              # tools

     

       273
       -
                              cabal-install haskintex

     

       274
       -
                            ]);

     

       275
       -
         };

     

       276
       -
       }

     

       277
       -
       </programlisting>

     

       278
       -
           <para>

     

       279
       -
             it's possible to install that compiler with

     

       280
       -
             <literal>nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA myHaskellEnv</literal>.

     

       281
       -
             If you'd like to switch that development environment to a

     

       282
       -
             different version of GHC, just replace the

     

       283
       -
             <literal>ghc7102</literal> bit in the previous definition with the

     

       284
       -
             appropriate name. Of course, it's also possible to define any

     

       285
       -
             number of these development environments! (You can't install two

     

       286
       -
             of them into the same profile at the same time, though, because

     

       287
       -
             that would result in file conflicts.)

     

       288
       -
           </para>

     

       289
       -
           <para>

     

       290
       -
             The generated <literal>ghc</literal> program is a wrapper script

     

       291
       -
             that re-directs the real GHC executable to use a new

     

       292
       -
             <literal>lib</literal> directory --- one that we specifically

     

       293
       -
             constructed to contain all those packages the user requested:

     

       294
       -
           </para>

     

       295
       -
           <programlisting>

     

       296
       -
       $ cat $(type -p ghc)

     

       297
       -
       #! /nix/store/xlxj...-bash-4.3-p33/bin/bash -e

     

       298
       -
       export NIX_GHC=/nix/store/19sm...-ghc-7.10.2/bin/ghc

     

       299
       -
       export NIX_GHCPKG=/nix/store/19sm...-ghc-7.10.2/bin/ghc-pkg

     

       300
       -
       export NIX_GHC_DOCDIR=/nix/store/19sm...-ghc-7.10.2/share/doc/ghc/html

     

       301
       -
       export NIX_GHC_LIBDIR=/nix/store/19sm...-ghc-7.10.2/lib/ghc-7.10.2

     

       302
       -
       exec /nix/store/j50p...-ghc-7.10.2/bin/ghc &quot;-B$NIX_GHC_LIBDIR&quot; &quot;$@&quot;

     

       303
       -
       </programlisting>

     

       304
       -
           <para>

     

       305
       -
             The variables <literal>$NIX_GHC</literal>,

     

       306
       -
             <literal>$NIX_GHCPKG</literal>, etc. point to the

     

       307
       -
             <emphasis>new</emphasis> store path

     

       308
       -
             <literal>ghcWithPackages</literal> constructed specifically for

     

       309
       -
             this environment. The last line of the wrapper script then

     

       310
       -
             executes the real <literal>ghc</literal>, but passes the path to

     

       311
       -
             the new <literal>lib</literal> directory using GHC's

     

       312
       -
             <literal>-B</literal> flag.

     

       313
       -
           </para>

     

       314
       -
           <para>

     

       315
       -
             The purpose of those environment variables is to work around an

     

       316
       -
             impurity in the popular

     

       317
       -
             <link xlink:href="http://hackage.haskell.org/package/ghc-paths">ghc-paths</link>

     

       318
       -
             library. That library promises to give its users access to GHC's

     

       319
       -
             installation paths. Only, the library can't possible know that

     

       320
       -
             path when it's compiled, because the path GHC considers its own is

     

       321
       -
             determined only much later, when the user configures it through

     

       322
       -
             <literal>ghcWithPackages</literal>. So we

     

       323
       -
             <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/ghc-paths-nix.patch">patched

     

       324
       -
             ghc-paths</link> to return the paths found in those environment

     

       325
       -
             variables at run-time rather than trying to guess them at

     

       326
       -
             compile-time.

     

       327
       -
           </para>

     

       328
       -
           <para>

     

       329
       -
             To make sure that mechanism works properly all the time, we

     

       330
       -
             recommend that you set those variables to meaningful values in

     

       331
       -
             your shell environment, too, i.e. by adding the following code to

     

       332
       -
             your <literal>~/.bashrc</literal>:

     

       333
       -
           </para>

     

       334
       -
           <programlisting>

     

       335
       -
       if type &gt;/dev/null 2&gt;&amp;1 -p ghc; then

     

       336
       -
         eval &quot;$(egrep ^export &quot;$(type -p ghc)&quot;)&quot;

     

       337
       -
       fi

     

       338
       -
       </programlisting>

     

       339
       -
           <para>

     

       340
       -
             If you are certain that you'll use only one GHC environment which

     

       341
       -
             is located in your user profile, then you can use the following

     

       342
       -
             code, too, which has the advantage that it doesn't contain any

     

       343
       -
             paths from the Nix store, i.e. those settings always remain valid

     

       344
       -
             even if a <literal>nix-env -u</literal> operation updates the GHC

     

       345
       -
             environment in your profile:

     

       346
       -
           </para>

     

       347
       -
           <programlisting>

     

       348
       -
       if [ -e ~/.nix-profile/bin/ghc ]; then

     

       349
       -
         export NIX_GHC=&quot;$HOME/.nix-profile/bin/ghc&quot;

     

       350
       -
         export NIX_GHCPKG=&quot;$HOME/.nix-profile/bin/ghc-pkg&quot;

     

       351
       -
         export NIX_GHC_DOCDIR=&quot;$HOME/.nix-profile/share/doc/ghc/html&quot;

     

       352
       -
         export NIX_GHC_LIBDIR=&quot;$HOME/.nix-profile/lib/ghc-$($NIX_GHC --numeric-version)&quot;

     

       353
       -
       fi

     

       354
       -
       </programlisting>

     

       355
       -
         </section>

     

       356
       -
         <section xml:id="how-to-install-a-compiler-with-indexes">

     

       357
       -
           <title>How to install a compiler with libraries, hoogle and documentation indexes</title>

     

       358
       -
           <para>

     

       359
       -
             If you plan to use your environment for interactive programming,

     

       360
       -
             not just compiling random Haskell code, you might want to

     

       361
       -
             replace <literal>ghcWithPackages</literal> in all the listings

     

       362
       -
             above with <literal>ghcWithHoogle</literal>.

     

       363
       -
           </para>

     

       364
       -
           <para>

     

       365
       -
             This environment generator not only produces an environment with

     

       366
       -
             GHC and all the specified libraries, but also generates a

     

       367
       -
             <literal>hoogle</literal> and <literal>haddock</literal> indexes

     

       368
       -
             for all the packages, and provides a wrapper script around

     

       369
       -
             <literal>hoogle</literal> binary that uses all those things. A

     

       370
       -
             precise name for this thing would be

     

       371
       -
             "<literal>ghcWithPackagesAndHoogleAndDocumentationIndexes</literal>",

     

       372
       -
             which is, regrettably, too long and scary.

     

       373
       -
           </para>

     

       374
       -
           <para>

     

       375
       -
             For example, installing the following environment

     

       376
       -
           </para>

     

       377
       -
           <programlisting>

     

       378
       -
       {

     

       379
       -
         packageOverrides = super: let self = super.pkgs; in

     

       380
       -
         {

     

       381
       -
           myHaskellEnv = self.haskellPackages.ghcWithHoogle

     

       382
       -
                            (haskellPackages: with haskellPackages; [

     

       383
       -
                              # libraries

     

       384
       -
                              arrows async cgi criterion

     

       385
       -
                              # tools

     

       386
       -
                              cabal-install haskintex

     

       387
       -
                            ]);

     

       388
       -
         };

     

       389
       -
       }

     

       390
       -
       </programlisting>

     

       391
       -
           <para>

     

       392
       -
             allows one to browse module documentation index <link

     

       393
       -
             xlink:href="https://downloads.haskell.org/~ghc/latest/docs/html/libraries/index.html">not

     

       394
       -
             too dissimilar to this</link> for all the specified packages and

     

       395
       -
             their dependencies by directing a browser of choice to

     

       396
       -
             <literal>~/.nix-profiles/share/doc/hoogle/index.html</literal>

     

       397
       -
             (or

     

       398
       -
             <literal>/run/current-system/sw/share/doc/hoogle/index.html</literal>

     

       399
       -
             in case you put it in

     

       400
       -
             <literal>environment.systemPackages</literal> in NixOS).

     

       401
       -
           </para>

     

       402
       -
           <para>

     

       403
       -
             After you've marveled enough at that try adding the following to

     

       404
       -
             your <literal>~/.ghc/ghci.conf</literal>

     

       405
       -
           </para>

     

       406
       -
           <programlisting>

     

       407
       -
       :def hoogle \s -> return $ ":! hoogle search -cl --count=15 \"" ++ s ++ "\""

     

       408
       -
       :def doc \s -> return $ ":! hoogle search -cl --info \"" ++ s ++ "\""

     

       409
       -
       </programlisting>

     

       410
       -
           <para>

     

       411
       -
             and test it by typing into <literal>ghci</literal>:

     

       412
       -
           </para>

     

       413
       -
           <programlisting>

     

       414
       -
       :hoogle a -> a

     

       415
       -
       :doc a -> a

     

       416
       -
       </programlisting>

     

       417
       -
           <para>

     

       418
       -
             Be sure to note the links to <literal>haddock</literal> files in

     

       419
       -
             the output. With any modern and properly configured terminal

     

       420
       -
             emulator you can just click those links to navigate there.

     

       421
       -
           </para>

     

       422
       -
           <para>

     

       423
       -
             Finally, you can run

     

       424
       -
           </para>

     

       425
       -
           <programlisting>

     

       426
       -
       hoogle server -p 8080

     

       427
       -
       </programlisting>

     

       428
       -
           <para>

     

       429
       -
             and navigate to <link xlink:href="http://localhost:8080/"/> for

     

       430
       -
             your own local <link

     

       431
       -
             xlink:href="https://www.haskell.org/hoogle/">Hoogle</link>.

     

       432
       -
             Note, however, that Firefox and possibly other browsers disallow

     

       433
       -
             navigation from <literal>http:</literal> to

     

       434
       -
             <literal>file:</literal> URIs for security reasons, which might

     

       435
       -
             be quite an inconvenience. See <link

     

       436
       -
             xlink:href="http://kb.mozillazine.org/Links_to_local_pages_do_not_work">this

     

       437
       -
             page</link> for workarounds.

     

       438
       -
           </para>

     

       439
       -
         </section>

     

       440
       -
         <section xml:id="how-to-create-ad-hoc-environments-for-nix-shell">

     

       441
       -
           <title>How to create ad hoc environments for

     

       442
       -
           <literal>nix-shell</literal></title>

     

       443
       -
           <para>

     

       444
       -
             The easiest way to create an ad hoc development environment is to

     

       445
       -
             run <literal>nix-shell</literal> with the appropriate GHC

     

       446
       -
             environment given on the command-line:

     

       447
       -
           </para>

     

       448
       -
           <programlisting>

     

       449
       -
       nix-shell -p &quot;haskellPackages.ghcWithPackages (pkgs: with pkgs; [mtl pandoc])&quot;

     

       450
       -
       </programlisting>

     

       451
       -
           <para>

     

       452
       -
             For more sophisticated use-cases, however, it's more convenient to

     

       453
       -
             save the desired configuration in a file called

     

       454
       -
             <literal>shell.nix</literal> that looks like this:

     

       455
       -
           </para>

     

       456
       -
           <programlisting>

     

       457
       -
       { nixpkgs ? import &lt;nixpkgs&gt; {}, compiler ? &quot;ghc7102&quot; }:

     

       458
       -
       let

     

       459
       -
         inherit (nixpkgs) pkgs;

     

       460
       -
         ghc = pkgs.haskell.packages.${compiler}.ghcWithPackages (ps: with ps; [

     

       461
       -
                 monad-par mtl

     

       462
       -
               ]);

     

       463
       -
       in

     

       464
       -
       pkgs.stdenv.mkDerivation {

     

       465
       -
         name = &quot;my-haskell-env-0&quot;;

     

       466
       -
         buildInputs = [ ghc ];

     

       467
       -
         shellHook = &quot;eval $(egrep ^export ${ghc}/bin/ghc)&quot;;

     

       468
       -
       }

     

       469
       -
       </programlisting>

     

       470
       -
           <para>

     

       471
       -
             Now run <literal>nix-shell</literal> --- or even

     

       472
       -
             <literal>nix-shell --pure</literal> --- to enter a shell

     

       473
       -
             environment that has the appropriate compiler in

     

       474
       -
             <literal>$PATH</literal>. If you use <literal>--pure</literal>,

     

       475
       -
             then add all other packages that your development environment

     

       476
       -
             needs into the <literal>buildInputs</literal> attribute. If you'd

     

       477
       -
             like to switch to a different compiler version, then pass an

     

       478
       -
             appropriate <literal>compiler</literal> argument to the

     

       479
       -
             expression, i.e.

     

       480
       -
             <literal>nix-shell --argstr compiler ghc784</literal>.

     

       481
       -
           </para>

     

       482
       -
           <para>

     

       483
       -
             If you need such an environment because you'd like to compile a

     

       484
       -
             Hackage package outside of Nix --- i.e. because you're hacking on

     

       485
       -
             the latest version from Git ---, then the package set provides

     

       486
       -
             suitable nix-shell environments for you already! Every Haskell

     

       487
       -
             package has an <literal>env</literal> attribute that provides a

     

       488
       -
             shell environment suitable for compiling that particular package.

     

       489
       -
             If you'd like to hack the <literal>lens</literal> library, for

     

       490
       -
             example, then you just have to check out the source code and enter

     

       491
       -
             the appropriate environment:

     

       492
       -
           </para>

     

       493
       -
           <programlisting>

     

       494
       -
         $ cabal get lens-4.11 &amp;&amp; cd lens-4.11

     

       495
       -
         Downloading lens-4.11...

     

       496
       -
         Unpacking to lens-4.11/

     

       497
       -
       

     

       498
       -
         $ nix-shell &quot;&lt;nixpkgs&gt;&quot; -A haskellPackages.lens.env

     

       499
       -
         [nix-shell:/tmp/lens-4.11]$

     

       500
       -
       </programlisting>

     

       501
       -
           <para>

     

       502
       -
             At point, you can run <literal>cabal configure</literal>,

     

       503
       -
             <literal>cabal build</literal>, and all the other development

     

       504
       -
             commands. Note that you need <literal>cabal-install</literal>

     

       505
       -
             installed in your <literal>$PATH</literal> already to use it here

     

       506
       -
             --- the <literal>nix-shell</literal> environment does not provide

     

       507
       -
             it.

     

       508
       -
           </para>

     

       509
       -
         </section>

     

       510
       -
       </section>

     

       511
       -
       <section xml:id="how-to-create-nix-builds-for-your-own-private-haskell-packages">

     

       512
       -
         <title>How to create Nix builds for your own private Haskell

     

       513
       -
         packages</title>

     

       514
       -
         <para>

     

       515
       -
           If your own Haskell packages have build instructions for Cabal, then

     

       516
       -
           you can convert those automatically into build instructions for Nix

     

       517
       -
           using the <literal>cabal2nix</literal> utility, which you can

     

       518
       -
           install into your profile by running

     

       519
       -
           <literal>nix-env -i cabal2nix</literal>.

     

       520
       -
         </para>

     

       521
       -
         <section xml:id="how-to-build-a-stand-alone-project">

     

       522
       -
           <title>How to build a stand-alone project</title>

     

       523
       -
           <para>

     

       524
       -
             For example, let's assume that you're working on a private project

     

       525
       -
             called <literal>foo</literal>. To generate a Nix build expression

     

       526
       -
             for it, change into the project's top-level directory and run the

     

       527
       -
             command:

     

       528
       -
           </para>

     

       529
       -
           <programlisting>

     

       530
       -
       $ cabal2nix . &gt;foo.nix

     

       531
       -
       </programlisting>

     

       532
       -
           <para>

     

       533
       -
             Then write the following snippet into a file called

     

       534
       -
             <literal>default.nix</literal>:

     

       535
       -
           </para>

     

       536
       -
           <programlisting>

     

       537
       -
       { nixpkgs ? import &lt;nixpkgs&gt; {}, compiler ? &quot;ghc7102&quot; }:

     

       538
       -
       nixpkgs.pkgs.haskell.packages.${compiler}.callPackage ./foo.nix { }

     

       539
       -
       </programlisting>

     

       540
       -
           <para>

     

       541
       -
             Finally, store the following code in a file called

     

       542
       -
             <literal>shell.nix</literal>:

     

       543
       -
           </para>

     

       544
       -
           <programlisting>

     

       545
       -
       { nixpkgs ? import &lt;nixpkgs&gt; {}, compiler ? &quot;ghc7102&quot; }:

     

       546
       -
       (import ./default.nix { inherit nixpkgs compiler; }).env

     

       547
       -
       </programlisting>

     

       548
       -
           <para>

     

       549
       -
             At this point, you can run <literal>nix-build</literal> to have

     

       550
       -
             Nix compile your project and install it into a Nix store path. The

     

       551
       -
             local directory will contain a symlink called

     

       552
       -
             <literal>result</literal> after <literal>nix-build</literal>

     

       553
       -
             returns that points into that location. Of course, passing the

     

       554
       -
             flag <literal>--argstr compiler ghc763</literal> allows switching

     

       555
       -
             the build to any version of GHC currently supported.

     

       556
       -
           </para>

     

       557
       -
           <para>

     

       558
       -
             Furthermore, you can call <literal>nix-shell</literal> to enter an

     

       559
       -
             interactive development environment in which you can use

     

       560
       -
             <literal>cabal configure</literal> and

     

       561
       -
             <literal>cabal build</literal> to develop your code. That

     

       562
       -
             environment will automatically contain a proper GHC derivation

     

       563
       -
             with all the required libraries registered as well as all the

     

       564
       -
             system-level libraries your package might need.

     

       565
       -
           </para>

     

       566
       -
           <para>

     

       567
       -
             If your package does not depend on any system-level libraries,

     

       568
       -
             then it's sufficient to run

     

       569
       -
           </para>

     

       570
       -
           <programlisting>

     

       571
       -
       $ nix-shell --command &quot;cabal configure&quot;

     

       572
       -
       </programlisting>

     

       573
       -
           <para>

     

       574
       -
             once to set up your build. <literal>cabal-install</literal>

     

       575
       -
             determines the absolute paths to all resources required for the

     

       576
       -
             build and writes them into a config file in the

     

       577
       -
             <literal>dist/</literal> directory. Once that's done, you can run

     

       578
       -
             <literal>cabal build</literal> and any other command for that

     

       579
       -
             project even outside of the <literal>nix-shell</literal>

     

       580
       -
             environment. This feature is particularly nice for those of us who

     

       581
       -
             like to edit their code with an IDE, like Emacs'

     

       582
       -
             <literal>haskell-mode</literal>, because it's not necessary to

     

       583
       -
             start Emacs inside of nix-shell just to make it find out the

     

       584
       -
             necessary settings for building the project;

     

       585
       -
             <literal>cabal-install</literal> has already done that for us.

     

       586
       -
           </para>

     

       587
       -
           <para>

     

       588
       -
             If you want to do some quick-and-dirty hacking and don't want to

     

       589
       -
             bother setting up a <literal>default.nix</literal> and

     

       590
       -
             <literal>shell.nix</literal> file manually, then you can use the

     

       591
       -
             <literal>--shell</literal> flag offered by

     

       592
       -
             <literal>cabal2nix</literal> to have it generate a stand-alone

     

       593
       -
             <literal>nix-shell</literal> environment for you. With that

     

       594
       -
             feature, running

     

       595
       -
           </para>

     

       596
       -
           <programlisting>

     

       597
       -
       $ cabal2nix --shell . &gt;shell.nix

     

       598
       -
       $ nix-shell --command &quot;cabal configure&quot;

     

       599
       -
       </programlisting>

     

       600
       -
           <para>

     

       601
       -
             is usually enough to set up a build environment for any given

     

       602
       -
             Haskell package. You can even use that generated file to run

     

       603
       -
             <literal>nix-build</literal>, too:

     

       604
       -
           </para>

     

       605
       -
           <programlisting>

     

       606
       -
       $ nix-build shell.nix

     

       607
       -
       </programlisting>

     

       608
       -
         </section>

     

       609
       -
         <section xml:id="how-to-build-projects-that-depend-on-each-other">

     

       610
       -
           <title>How to build projects that depend on each other</title>

     

       611
       -
           <para>

     

       612
       -
             If you have multiple private Haskell packages that depend on each

     

       613
       -
             other, then you'll have to register those packages in the Nixpkgs

     

       614
       -
             set to make them visible for the dependency resolution performed

     

       615
       -
             by <literal>callPackage</literal>. First of all, change into each

     

       616
       -
             of your projects top-level directories and generate a

     

       617
       -
             <literal>default.nix</literal> file with

     

       618
       -
             <literal>cabal2nix</literal>:

     

       619
       -
           </para>

     

       620
       -
           <programlisting>

     

       621
       -
       $ cd ~/src/foo &amp;&amp; cabal2nix . &gt;default.nix

     

       622
       -
       $ cd ~/src/bar &amp;&amp; cabal2nix . &gt;default.nix

     

       623
       -
       </programlisting>

     

       624
       -
           <para>

     

       625
       -
             Then edit your <literal>~/.nixpkgs/config.nix</literal> file to

     

       626
       -
             register those builds in the default Haskell package set:

     

       627
       -
           </para>

     

       628
       -
           <programlisting>

     

       629
       -
         {

     

       630
       -
           packageOverrides = super: let self = super.pkgs; in

     

       631
       -
           {

     

       632
       -
             haskellPackages = super.haskellPackages.override {

     

       633
       -
               overrides = self: super: {

     

       634
       -
                 foo = self.callPackage ../src/foo {};

     

       635
       -
                 bar = self.callPackage ../src/bar {};

     

       636
       -
               };

     

       637
       -
             };

     

       638
       -
           };

     

       639
       -
         }

     

       640
       -
       </programlisting>

     

       641
       -
           <para>

     

       642
       -
             Once that's accomplished,

     

       643
       -
             <literal>nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qA haskellPackages</literal>

     

       644
       -
             will show your packages like any other package from Hackage, and

     

       645
       -
             you can build them

     

       646
       -
           </para>

     

       647
       -
           <programlisting>

     

       648
       -
       $ nix-build &quot;&lt;nixpkgs&gt;&quot; -A haskellPackages.foo

     

       649
       -
       </programlisting>

     

       650
       -
           <para>

     

       651
       -
             or enter an interactive shell environment suitable for building

     

       652
       -
             them:

     

       653
       -
           </para>

     

       654
       -
           <programlisting>

     

       655
       -
       $ nix-shell &quot;&lt;nixpkgs&gt;&quot; -A haskellPackages.bar.env

     

       656
       -
       </programlisting>

     

       657
       -
         </section>

     

       658
       -
       </section>

     

       659
       -
       <section xml:id="miscellaneous-topics">

     

       660
       -
         <title>Miscellaneous Topics</title>

     

       661
       -
         <section xml:id="how-to-build-with-profiling-enabled">

     

       662
       -
           <title>How to build with profiling enabled</title>

     

       663
       -
           <para>

     

       664
       -
             Every Haskell package set takes a function called

     

       665
       -
             <literal>overrides</literal> that you can use to manipulate the

     

       666
       -
             package as much as you please. One useful application of this

     

       667
       -
             feature is to replace the default <literal>mkDerivation</literal>

     

       668
       -
             function with one that enables library profiling for all packages.

     

       669
       -
             To accomplish that, add configure the following snippet in your

     

       670
       -
             <literal>~/.nixpkgs/config.nix</literal> file:

     

       671
       -
           </para>

     

       672
       -
           <programlisting>

     

       673
       -
       {

     

       674
       -
         packageOverrides = super: let self = super.pkgs; in

     

       675
       -
         {

     

       676
       -
           profiledHaskellPackages = self.haskellPackages.override {

     

       677
       -
             overrides = self: super: {

     

       678
       -
               mkDerivation = args: super.mkDerivation (args // {

     

       679
       -
                 enableLibraryProfiling = true;

     

       680
       -
               });

     

       681
       -
             };

     

       682
       -
           };

     

       683
       -
         };

     

       684
       -
       }

     

       685
       -
       </programlisting>

     

       686
       -
           <para>

     

       687
       -
               Then, replace instances of <literal>haskellPackages</literal> in the

     

       688
       -
               <literal>cabal2nix</literal>-generated <literal>default.nix</literal>

     

       689
       -
               or <literal>shell.nix</literal> files with

     

       690
       -
               <literal>profiledHaskellPackages</literal>.

     

       691
       -
           </para>

     

       692
       -
         </section>

     

       693
       -
         <section xml:id="how-to-override-package-versions-in-a-compiler-specific-package-set">

     

       694
       -
           <title>How to override package versions in a compiler-specific

     

       695
       -
           package set</title>

     

       696
       -
           <para>

     

       697
       -
             Nixpkgs provides the latest version of

     

       698
       -
             <link xlink:href="http://hackage.haskell.org/package/ghc-events"><literal>ghc-events</literal></link>,

     

       699
       -
             which is 0.4.4.0 at the time of this writing. This is fine for

     

       700
       -
             users of GHC 7.10.x, but GHC 7.8.4 cannot compile that binary.

     

       701
       -
             Now, one way to solve that problem is to register an older version

     

       702
       -
             of <literal>ghc-events</literal> in the 7.8.x-specific package

     

       703
       -
             set. The first step is to generate Nix build instructions with

     

       704
       -
             <literal>cabal2nix</literal>:

     

       705
       -
           </para>

     

       706
       -
           <programlisting>

     

       707
       -
       $ cabal2nix cabal://ghc-events-0.4.3.0 &gt;~/.nixpkgs/ghc-events-0.4.3.0.nix

     

       708
       -
       </programlisting>

     

       709
       -
           <para>

     

       710
       -
             Then add the override in <literal>~/.nixpkgs/config.nix</literal>:

     

       711
       -
           </para>

     

       712
       -
           <programlisting>

     

       713
       -
       {

     

       714
       -
         packageOverrides = super: let self = super.pkgs; in

     

       715
       -
         {

     

       716
       -
           haskell = super.haskell // {

     

       717
       -
             packages = super.haskell.packages // {

     

       718
       -
               ghc784 = super.haskell.packages.ghc784.override {

     

       719
       -
                 overrides = self: super: {

     

       720
       -
                   ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {};

     

       721
       -
                 };

     

       722
       -
               };

     

       723
       -
             };

     

       724
       -
           };

     

       725
       -
         };

     

       726
       -
       }

     

       727
       -
       </programlisting>

     

       728
       -
           <para>

     

       729
       -
             This code is a little crazy, no doubt, but it's necessary because

     

       730
       -
             the intuitive version

     

       731
       -
           </para>

     

       732
       -
           <programlisting>

     

       733
       -
       haskell.packages.ghc784 = super.haskell.packages.ghc784.override {

     

       734
       -
         overrides = self: super: {

     

       735
       -
           ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {};

     

       736
       -
         };

     

       737
       -
       };

     

       738
       -
       </programlisting>

     

       739
       -
           <para>

     

       740
       -
             doesn't do what we want it to: that code replaces the

     

       741
       -
             <literal>haskell</literal> package set in Nixpkgs with one that

     

       742
       -
             contains only one entry,<literal>packages</literal>, which

     

       743
       -
             contains only one entry <literal>ghc784</literal>. This override

     

       744
       -
             loses the <literal>haskell.compiler</literal> set, and it loses

     

       745
       -
             the <literal>haskell.packages.ghcXYZ</literal> sets for all

     

       746
       -
             compilers but GHC 7.8.4. To avoid that problem, we have to perform

     

       747
       -
             the convoluted little dance from above, iterating over each step

     

       748
       -
             in hierarchy.

     

       749
       -
           </para>

     

       750
       -
           <para>

     

       751
       -
             Once it's accomplished, however, we can install a variant of

     

       752
       -
             <literal>ghc-events</literal> that's compiled with GHC 7.8.4:

     

       753
       -
           </para>

     

       754
       -
           <programlisting>

     

       755
       -
       nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskell.packages.ghc784.ghc-events

     

       756
       -
       </programlisting>

     

       757
       -
           <para>

     

       758
       -
             Unfortunately, it turns out that this build fails again while

     

       759
       -
             executing the test suite! Apparently, the release archive on

     

       760
       -
             Hackage is missing some data files that the test suite requires,

     

       761
       -
             so we cannot run it. We accomplish that by re-generating the Nix

     

       762
       -
             expression with the <literal>--no-check</literal> flag:

     

       763
       -
           </para>

     

       764
       -
           <programlisting>

     

       765
       -
       $ cabal2nix --no-check cabal://ghc-events-0.4.3.0 &gt;~/.nixpkgs/ghc-events-0.4.3.0.nix

     

       766
       -
       </programlisting>

     

       767
       -
           <para>

     

       768
       -
             Now the builds succeeds.

     

       769
       -
           </para>

     

       770
       -
           <para>

     

       771
       -
             Of course, in the concrete example of

     

       772
       -
             <literal>ghc-events</literal> this whole exercise is not an ideal

     

       773
       -
             solution, because <literal>ghc-events</literal> can analyze the

     

       774
       -
             output emitted by any version of GHC later than 6.12 regardless of

     

       775
       -
             the compiler version that was used to build the `ghc-events'

     

       776
       -
             executable, so strictly speaking there's no reason to prefer one

     

       777
       -
             built with GHC 7.8.x in the first place. However, for users who

     

       778
       -
             cannot use GHC 7.10.x at all for some reason, the approach of

     

       779
       -
             downgrading to an older version might be useful.

     

       780
       -
           </para>

     

       781
       -
         </section>

     

       782
       -
         <section xml:id="how-to-recover-from-ghcs-infamous-non-deterministic-library-id-bug">

     

       783
       -
           <title>How to recover from GHC's infamous non-deterministic library

     

       784
       -
           ID bug</title>

     

       785
       -
           <para>

     

       786
       -
             GHC and distributed build farms don't get along well:

     

       787
       -
           </para>

     

       788
       -
           <programlisting>

     

       789
       -
       https://ghc.haskell.org/trac/ghc/ticket/4012

     

       790
       -
       </programlisting>

     

       791
       -
           <para>

     

       792
       -
             When you see an error like this one

     

       793
       -
           </para>

     

       794
       -
           <programlisting>

     

       795
       -
       package foo-0.7.1.0 is broken due to missing package

     

       796
       -
       text-1.2.0.4-98506efb1b9ada233bb5c2b2db516d91

     

       797
       -
       </programlisting>

     

       798
       -
           <para>

     

       799
       -
             then you have to download and re-install <literal>foo</literal>

     

       800
       -
             and all its dependents from scratch:

     

       801
       -
           </para>

     

       802
       -
           <programlisting>

     

       803
       -
       # nix-store -q --referrers /nix/store/*-haskell-text-1.2.0.4 \

     

       804
       -
         | xargs -L 1 nix-store --repair-path --option binary-caches http://hydra.nixos.org

     

       805
       -
       </programlisting>

     

       806
       -
           <para>

     

       807
       -
             If you're using additional Hydra servers other than

     

       808
       -
             <literal>hydra.nixos.org</literal>, then it might be necessary to

     

       809
       -
             purge the local caches that store data from those machines to

     

       810
       -
             disable these binary channels for the duration of the previous

     

       811
       -
             command, i.e. by running:

     

       812
       -
           </para>

     

       813
       -
           <programlisting>

     

       814
       -
       rm /nix/var/nix/binary-cache-v3.sqlite

     

       815
       -
       rm /nix/var/nix/manifests/*

     

       816
       -
       rm /nix/var/nix/channel-cache/*

     

       817
       -
       </programlisting>

     

       818
       -
         </section>

     

       819
       -
         <section xml:id="builds-on-darwin-fail-with-math.h-not-found">

     

       820
       -
           <title>Builds on Darwin fail with <literal>math.h</literal> not

     

       821
       -
           found</title>

     

       822
       -
           <para>

     

       823
       -
             Users of GHC on Darwin have occasionally reported that builds

     

       824
       -
             fail, because the compiler complains about a missing include file:

     

       825
       -
           </para>

     

       826
       -
           <programlisting>

     

       827
       -
       fatal error: 'math.h' file not found

     

       828
       -
       </programlisting>

     

       829
       -
           <para>

     

       830
       -
             The issue has been discussed at length in

     

       831
       -
             <link xlink:href="https://github.com/NixOS/nixpkgs/issues/6390">ticket

     

       832
       -
             6390</link>, and so far no good solution has been proposed. As a

     

       833
       -
             work-around, users who run into this problem can configure the

     

       834
       -
             environment variables

     

       835
       -
           </para>

     

       836
       -
           <programlisting>

     

       837
       -
       export NIX_CFLAGS_COMPILE=&quot;-idirafter /usr/include&quot;

     

       838
       -
       export NIX_CFLAGS_LINK=&quot;-L/usr/lib&quot;

     

       839
       -
       </programlisting>

     

       840
       -
           <para>

     

       841
       -
             in their <literal>~/.bashrc</literal> file to avoid the compiler

     

       842
       -
             error.

     

       843
       -
           </para>

     

       844
       -
         </section>

     

       845
       -
       </section>

     

       846
       -
       

     

       847
       -
       <section xml:id="other-resources">

     

       848
       -
         <title>Other resources</title>

     

       849
       -
         <itemizedlist>

     

       850
       -
           <listitem>

     

       851
       -
             <para>

     

       852
       -
               The Youtube video

     

       853
       -
               <link xlink:href="https://www.youtube.com/watch?v=BsBhi_r-OeE">Nix

     

       854
       -
               Loves Haskell</link> provides an introduction into Haskell NG

     

       855
       -
               aimed at beginners. The slides are available at

     

       856
       -
               http://cryp.to/nixos-meetup-3-slides.pdf and also -- in a form

     

       857
       -
               ready for cut &amp; paste -- at

     

       858
       -
               https://github.com/NixOS/cabal2nix/blob/master/doc/nixos-meetup-3-slides.md.

     

       859
       -
             </para>

     

       860
       -
           </listitem>

     

       861
       -
           <listitem>

     

       862
       -
             <para>

     

       863
       -
               Another Youtube video is

     

       864
       -
               <link xlink:href="https://www.youtube.com/watch?v=mQd3s57n_2Y">Escaping

     

       865
       -
               Cabal Hell with Nix</link>, which discusses the subject of

     

       866
       -
               Haskell development with Nix but also provides a basic

     

       867
       -
               introduction to Nix as well, i.e. it's suitable for viewers with

     

       868
       -
               almost no prior Nix experience.

     

       869
       -
             </para>

     

       870
       -
           </listitem>

     

       871
       -
           <listitem>

     

       872
       -
             <para>

     

       873
       -
               Oliver Charles wrote a very nice

     

       874
       -
               <link xlink:href="http://wiki.ocharles.org.uk/Nix">Tutorial how to

     

       875
       -
               develop Haskell packages with Nix</link>.

     

       876
       -
             </para>

     

       877
       -
           </listitem>

     

       878
       -
           <listitem>

     

       879
       -
             <para>

     

       880
       -
               The <emphasis>Journey into the Haskell NG

     

       881
       -
               infrastructure</emphasis> series of postings describe the new

     

       882
       -
               Haskell infrastructure in great detail:

     

       883
       -
             </para>

     

       884
       -
             <itemizedlist>

     

       885
       -
               <listitem>

     

       886
       -
                 <para>

     

       887
       -
                   <link xlink:href="http://lists.science.uu.nl/pipermail/nix-dev/2015-January/015591.html">Part

     

       888
       -
                   1</link> explains the differences between the old and the

     

       889
       -
                   new code and gives instructions how to migrate to the new

     

       890
       -
                   setup.

     

       891
       -
                 </para>

     

       892
       -
               </listitem>

     

       893
       -
               <listitem>

     

       894
       -
                 <para>

     

       895
       -
                   <link xlink:href="http://lists.science.uu.nl/pipermail/nix-dev/2015-January/015608.html">Part

     

       896
       -
                   2</link> looks in-depth at how to tweak and configure your

     

       897
       -
                   setup by means of overrides.

     

       898
       -
                 </para>

     

       899
       -
               </listitem>

     

       900
       -
               <listitem>

     

       901
       -
                 <para>

     

       902
       -
                   <link xlink:href="http://lists.science.uu.nl/pipermail/nix-dev/2015-April/016912.html">Part

     

       903
       -
                   3</link> describes the infrastructure that keeps the

     

       904
       -
                   Haskell package set in Nixpkgs up-to-date.

     

       905
       -
                 </para>

     

       906
       -
               </listitem>

     

       907
       -
             </itemizedlist>

     

       908
       -
           </listitem>

     

       909
       -
         </itemizedlist>

     

       910
       -
       </section>

     

       911
       -
       

     

       912
       -
       </chapter>