commit 3e4035695c9c969675de66ca1b63e13ef57e5bd8 · pyrox.dev/nixpkgs

+29 -17

doc/default.nix

···

       20
       20
        
           --param callout.graphics.extension '.gif'

     

       21
       21
        
         '';

     

       22
       22
        
       

     

       23
       23
       -
         buildCommand = ''

     

       24
       24
       -
           {

     

       25
       25
       -
             echo "<chapter xmlns=\"http://docbook.org/ns/docbook\""

     

       26
       26
       -
             echo "         xmlns:xlink=\"http://www.w3.org/1999/xlink\""

     

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

     

       28
       28
       -
             echo ""

     

       29
       29
       -
             echo "<title>User's Guide to the Haskell Infrastructure</title>"

     

       30
       30
       -
             echo ""

     

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

     

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

     

       33
       33
       -
                   -e 's|</ulink>|</link>|' \

     

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

     

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

     

       36
       36
       -
             echo ""

     

       37
       37
       -
             echo "</chapter>"

     

       38
       38
       -
           } >haskell-users-guide.xml

     

       39
       23
        
       

     

       24
       24
       +
         buildCommand = let toDocbook = { useChapters ? false, inputFile, outputFile }:

     

       25
       25
       +
           let

     

       26
       26
       +
             extraHeader = ''xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" '';

     

       27
       27
       +
           in ''

     

       28
       28
       +
             {

     

       29
       29
       +
               pandoc '${inputFile}' -w docbook ${optionalString useChapters "--chapters"} \

     

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

     

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

     

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

     

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

     

       34
       34
       +
                     -e '1s| id=| xml:id=|' \

     

       35
       35
       +
                     -e '1s|\(<[^ ]* \)|\1${extraHeader}|'

     

       36
       36
       +
             } > '${outputFile}'

     

       37
       37
       +
           '';

     

       38
       38
       +
         in

     

       39
       39
       +
       

     

       40
       40
       +
         ''

     

       40
       41
        
           ln -s '${sources}/'*.xml .

     

       41
       42
        
           mkdir ./languages-frameworks

     

       42
       43
        
           cp -s '${sources-langs}'/* ./languages-frameworks

     

       43
       43
       -
       

     

       44
       44
       +
         ''

     

       45
       45
       +
         + toDocbook {

     

       46
       46
       +
             inputFile = ./haskell-users-guide.md;

     

       47
       47
       +
             outputFile = "haskell-users-guide.xml";

     

       48
       48
       +
             useChapters = true;

     

       49
       49
       +
           }

     

       50
       50
       +
         + toDocbook {

     

       51
       51
       +
             inputFile = ./../pkgs/development/idris-modules/README.md;

     

       52
       52
       +
             outputFile = "languages-frameworks/idris.xml";

     

       53
       53
       +
           }

     

       54
       54
       +
         + ''

     

       55
       55
       +
           cat languages-frameworks/idris.xml

     

       44
       56
        
           echo ${nixpkgsVersion} > .version

     

       45
       57
        
       

     

       46
       58
        
           xmllint --noout --nonet --xinclude --noxincludenode \

+19 -17

doc/haskell-users-guide.md

···

       3
       3
        
       author: Peter Simons

     

       4
       4
        
       date: 2015-06-01

     

       5
       5
        
       ---

     

       6
       6
       +
       # User's Guide to the Haskell Infrastructure

     

       6
       7
        
       

     

       7
       7
       -
       # How to install Haskell packages

     

       8
       8
       +
       

     

       9
       9
       +
       ## How to install Haskell packages

     

       8
       10
        
       

     

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

     

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

     
···

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

     

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

     

       113
       115
        
       

     

       114
       114
       -
       # How to create a development environment

     

       116
       116
       +
       ## How to create a development environment

     

       115
       117
        
       

     

       116
       116
       -
       ## How to install a compiler

     

       118
       118
       +
       ### How to install a compiler

     

       117
       119
        
       

     

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

     

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

     
···

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

     

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

     

       164
       166
        
       

     

       165
       165
       -
       ## How to install a compiler with libraries

     

       167
       167
       +
       ### How to install a compiler with libraries

     

       166
       168
        
       

     

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

     

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

     
···

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

     

       258
       260
        
           fi

     

       259
       261
        
       

     

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

     

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

     

       261
       263
        
       

     

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

     

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

     
···

       319
       321
        
       workarounds.

     

       320
       322
        
       

     

       321
       323
        
       

     

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

     

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

     

       323
       325
        
       

     

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

     

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

     
···

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

     

       370
       372
        
       it.

     

       371
       373
        
       

     

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

     

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

     

       373
       375
        
       

     

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

     

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

     

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

     

       377
       379
        
       `nix-env -i cabal2nix`.

     

       378
       380
        
       

     

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

     

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

     

       380
       382
        
       

     

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

     

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

     
···

       433
       435
        
       

     

       434
       436
        
           $ nix-build shell.nix

     

       435
       437
        
       

     

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

     

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

     

       437
       439
        
       

     

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

     

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

     
···

       468
       470
        
       

     

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

     

       470
       472
        
       

     

       471
       471
       -
       # Miscellaneous Topics

     

       473
       473
       +
       ## Miscellaneous Topics

     

       472
       474
        
       

     

       473
       473
       -
       ## How to build with profiling enabled

     

       475
       475
       +
       ### How to build with profiling enabled

     

       474
       476
        
       

     

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

     

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

     
···

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

     

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

     

       496
       498
        
       

     

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

     

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

     

       498
       500
        
       

     

       499
       501
        
       Nixpkgs provides the latest version of

     

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

     
···

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

     

       561
       563
        
       older version might be useful.

     

       562
       564
        
       

     

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

     

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

     

       564
       566
        
       

     

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

     

       566
       568
        
       

     
···

       586
       588
        
           rm /nix/var/nix/manifests/*

     

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

     

       588
       590
        
       

     

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

     

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

     

       590
       592
        
       

     

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

     

       592
       594
        
       compiler complains about a missing include file:

     
···

       603
       605
        
       

     

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

     

       605
       607
        
       

     

       606
       606
       -
       ## Using Stack together with Nix

     

       608
       608
       +
       ### Using Stack together with Nix

     

       607
       609
        
       

     

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

     

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

     
···

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

     

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

     

       668
       670
        
       

     

       669
       669
       -
       ## Creating statically linked binaries

     

       671
       671
       +
       ### Creating statically linked binaries

     

       670
       672
        
       

     

       671
       673
        
       There are two levels of static linking. The first option is to configure the

     

       672
       674
        
       build with the Cabal flag `--disable-executable-dynamic`. In Nix expressions,

     
···

       688
       690
        
       Cabal could link!

     

       689
       691
        
       

     

       690
       692
        
       

     

       691
       691
       -
       # Other resources

     

       693
       693
       +
       ## Other resources

     

       692
       694
        
       

     

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

     

       694
       696
        
         provides an introduction into Haskell NG aimed at beginners. The slides are

doc/languages-frameworks/index.xml

···

       20
       20
        
       <xi:include href="java.xml" />

     

       21
       21
        
       <xi:include href="lua.xml" />

     

       22
       22
        
       <xi:include href="coq.xml" />

     

       23
       23
       +
       <xi:include href="idris.xml" /> <!-- generated from ../../pkgs/development/idris-modules/README.md  -->

     

       23
       24
        
       <xi:include href="qt.xml" />

     

       24
       25
        
       

     

       25
       26