commit 3a6116c550cf36730bcb6ea0212436e7e3c927a7 · pyrox.dev/nixpkgs

+7 -7

doc/languages-frameworks/agda.section.md

···

       3
       3
        
       ## How to use Agda

     

       4
       4
        
       

     

       5
       5
        
       Agda can be installed from `agda`:

     

       6
       6
       -
       ```

     

       6
       6
       +
       ```ShellSession

     

       7
       7
        
       $ nix-env -iA agda

     

       8
       8
        
       ```

     

       9
       9
        
       

     
···

       15
       15
        
       

     

       16
       16
        
       For example, suppose we wanted a version of Agda which has access to the standard library. This can be obtained with the expressions:

     

       17
       17
        
       

     

       18
       18
       -
       ```

     

       18
       18
       +
       ```nix

     

       19
       19
        
       agda.withPackages [ agdaPackages.standard-library ]

     

       20
       20
        
       ```

     

       21
       21
        
       

     

       22
       22
        
       or

     

       23
       23
        
       

     

       24
       24
       -
       ```

     

       24
       24
       +
       ```nix

     

       25
       25
        
       agda.withPackages (p: [ p.standard-library ])

     

       26
       26
        
       ```

     

       27
       27
        
       

     
···

       32
       32
        
       Agda will not by default use these libraries. To tell Agda to use the library we have some options:

     

       33
       33
        
       

     

       34
       34
        
       * Call `agda` with the library flag:

     

       35
       35
       -
       ```

     

       35
       35
       +
       ```ShellSession

     

       36
       36
        
       $ agda -l standard-library -i . MyFile.agda

     

       37
       37
        
       ```

     

       38
       38
        
       * Write a `my-library.agda-lib` file for the project you are working on which may look like:

     
···

       49
       49
        
       Agda modules can be compiled with the `--compile` flag. A version of `ghc` with `ieee754` is made available to the Agda program via the `--with-compiler` flag.

     

       50
       50
        
       This can be overridden by a different version of `ghc` as follows:

     

       51
       51
        
       

     

       52
       52
       -
       ```

     

       52
       52
       +
       ```nix

     

       53
       53
        
       agda.withPackages {

     

       54
       54
        
         pkgs = [ ... ];

     

       55
       55
        
         ghc = haskell.compiler.ghcHEAD;

     
···

       80
       80
        
       ## Adding Agda packages to Nixpkgs

     

       81
       81
        
       

     

       82
       82
        
       To add an Agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other Agda libraries, so the top line of the `default.nix` can look like:

     

       83
       83
       -
       ```

     

       83
       83
       +
       ```nix

     

       84
       84
        
       { mkDerivation, standard-library, fetchFromGitHub }:

     

       85
       85
        
       ```

     

       86
       86
        
       and `mkDerivation` should be called instead of `agdaPackages.mkDerivation`. Here is an example skeleton derivation for iowa-stdlib:

     

       87
       87
        
       

     

       88
       88
       -
       ```

     

       88
       88
       +
       ```nix

     

       89
       89
        
       mkDerivation {

     

       90
       90
        
         version = "1.5.0";

     

       91
       91
        
         pname = "iowa-stdlib";

+3 -3

doc/languages-frameworks/dotnet.section.md

···

       4
       4
        
       

     

       5
       5
        
       For local development, it's recommended to use nix-shell to create a dotnet environment:

     

       6
       6
        
       

     

       7
       7
       -
       ```

     

       7
       7
       +
       ```nix

     

       8
       8
        
       # shell.nix

     

       9
       9
        
       with import <nixpkgs> {};

     

       10
       10
        
       

     
···

       20
       20
        
       

     

       21
       21
        
       It's very likely that more than one sdk will be needed on a given project. Dotnet provides several different frameworks (E.g dotnetcore, aspnetcore, etc.) as well as many versions for a given framework. Normally, dotnet is able to fetch a framework and install it relative to the executable. However, this would mean writing to the nix store in nixpkgs, which is read-only. To support the many-sdk use case, one can compose an environment using `dotnetCorePackages.combinePackages`:

     

       22
       22
        
       

     

       23
       23
       -
       ```

     

       23
       23
       +
       ```nix

     

       24
       24
        
       with import <nixpkgs> {};

     

       25
       25
        
       

     

       26
       26
        
       mkShell {

     
···

       37
       37
        
       

     

       38
       38
        
       This will produce a dotnet installation that has the dotnet 3.1, 3.0, and 2.1 sdk. The first sdk listed will have it's cli utility present in the resulting environment. Example info output:

     

       39
       39
        
       

     

       40
       40
       -
       ```

     

       40
       40
       +
       ```ShellSesssion

     

       41
       41
        
       $ dotnet --info

     

       42
       42
        
       .NET Core SDK (reflecting any global.json):

     

       43
       43
        
        Version:   3.1.101

+9 -9

doc/languages-frameworks/idris.section.md

···

       4
       4
        
       

     

       5
       5
        
       The easiest way to get a working idris version is to install the `idris` attribute:

     

       6
       6
        
       

     

       7
       7
       -
       ```

     

       7
       7
       +
       ```ShellSesssion

     

       8
       8
        
       $ # On NixOS

     

       9
       9
        
       $ nix-env -i nixos.idris

     

       10
       10
        
       $ # On non-NixOS

     
···

       21
       21
        
       

     

       22
       22
        
       And then:

     

       23
       23
        
       

     

       24
       24
       -
       ```

     

       24
       24
       +
       ```ShellSesssion

     

       25
       25
        
       $ # On NixOS

     

       26
       26
        
       $ nix-env -iA nixos.myIdris

     

       27
       27
        
       $ # On non-NixOS

     
···

       29
       29
        
       ```

     

       30
       30
        
       

     

       31
       31
        
       To see all available Idris packages:

     

       32
       32
       -
       ```

     

       32
       32
       +
       ```ShellSesssion

     

       33
       33
        
       $ # On NixOS

     

       34
       34
        
       $ nix-env -qaPA nixos.idrisPackages

     

       35
       35
        
       $ # On non-NixOS

     
···

       37
       37
        
       ```

     

       38
       38
        
       

     

       39
       39
        
       Similarly, entering a `nix-shell`:

     

       40
       40
       -
       ```

     

       40
       40
       +
       ```ShellSesssion

     

       41
       41
        
       $ nix-shell -p 'idrisPackages.with-packages (with idrisPackages; [ contrib pruviloj ])'

     

       42
       42
        
       ```

     

       43
       43
        
       

     
···

       45
       45
        
       

     

       46
       46
        
       To have access to these libraries in idris, call it with an argument `-p <library name>` for each library:

     

       47
       47
        
       

     

       48
       48
       -
       ```

     

       48
       48
       +
       ```ShellSesssion

     

       49
       49
        
       $ nix-shell -p 'idrisPackages.with-packages (with idrisPackages; [ contrib pruviloj ])'

     

       50
       50
        
       [nix-shell:~]$ idris -p contrib -p pruviloj

     

       51
       51
        
       ```

     

       52
       52
        
       

     

       53
       53
        
       A listing of all available packages the Idris binary has access to is available via `--listlibs`:

     

       54
       54
        
       

     

       55
       55
       -
       ```

     

       55
       55
       +
       ```ShellSesssion

     

       56
       56
        
       $ idris --listlibs

     

       57
       57
        
       00prelude-idx.ibc

     

       58
       58
        
       pruviloj

     
···

       105
       105
        
       

     

       106
       106
        
       Assuming this file is saved as `yaml.nix`, it's buildable using

     

       107
       107
        
       

     

       108
       108
       -
       ```

     

       108
       108
       +
       ```ShellSesssion

     

       109
       109
        
       $ nix-build -E '(import <nixpkgs> {}).idrisPackages.callPackage ./yaml.nix {}'

     

       110
       110
        
       ```

     

       111
       111
        
       

     
···

       121
       121
        
       

     

       122
       122
        
       in another file (say `default.nix`) to be able to build it with

     

       123
       123
        
       

     

       124
       124
       -
       ```

     

       124
       124
       +
       ```ShellSesssion

     

       125
       125
        
       $ nix-build -A yaml

     

       126
       126
        
       ```

     

       127
       127
        
       

     
···

       133
       133
        
       

     

       134
       134
        
       For example you could set

     

       135
       135
        
       

     

       136
       136
       -
       ```

     

       136
       136
       +
       ```nix

     

       137
       137
        
       build-idris-package {

     

       138
       138
        
         idrisBuildOptions = [ "--log" "1" "--verbose" ]

     

       139
       139

+4 -4

doc/languages-frameworks/python.section.md

···

       79
       79
        
       By default `nix-shell` will start a `bash` session with this interpreter in our

     

       80
       80
        
       `PATH`, so if we then run:

     

       81
       81
        
       

     

       82
       82
       -
       ```

     

       82
       82
       +
       ```Python console

     

       83
       83
        
       [nix-shell:~/src/nixpkgs]$ python3

     

       84
       84
        
       Python 3.8.1 (default, Dec 18 2019, 19:06:26)

     

       85
       85
        
       [GCC 9.2.0] on linux

     
···

       90
       90
        
       Note that no other modules are in scope, even if they were imperatively

     

       91
       91
        
       installed into our user environment as a dependency of a Python application:

     

       92
       92
        
       

     

       93
       93
       -
       ```

     

       93
       93
       +
       ```Python console

     

       94
       94
        
       >>> import requests

     

       95
       95
        
       Traceback (most recent call last):

     

       96
       96
        
         File "<stdin>", line 1, in <module>

     
···

       146
       146
        
       Executing this script requires a `python3` that has `numpy`. Using what we learned

     

       147
       147
        
       in the previous section, we could startup a shell and just run it like so:

     

       148
       148
        
       

     

       149
       149
       -
       ```

     

       150
       150
       -
       nix-shell -p 'python38.withPackages(ps: with ps; [ numpy ])' --run 'python3 foo.py'

     

       149
       149
       +
       ```ShellSesssion

     

       150
       150
       +
       $ nix-shell -p 'python38.withPackages(ps: with ps; [ numpy ])' --run 'python3 foo.py'

     

       151
       151
        
       The dot product of [1 2] and [3 4] is: 11

     

       152
       152
        
       ```

     

       153
       153

+3 -3

doc/languages-frameworks/qt.section.md

···

       103
       103
        
       ### Example adding a Qt library {#qt-library-all-packages-nix}

     

       104
       104
        
       

     

       105
       105
        
       The following represents the contents of `qt5-packages.nix`.

     

       106
       106
       -
       ```

     

       106
       106
       +
       ```nix

     

       107
       107
        
       {

     

       108
       108
        
         # ...

     

       109
       109
        
       

     
···

       133
       133
        
       ### Example adding a Qt application {#qt-application-all-packages-nix}

     

       134
       134
        
       

     

       135
       135
        
       The following represents the contents of `qt5-packages.nix`.

     

       136
       136
       -
       ```

     

       136
       136
       +
       ```nix

     

       137
       137
        
       {

     

       138
       138
        
         # ...

     

       139
       139
        
       

     
···

       144
       144
        
       ```

     

       145
       145
        
       

     

       146
       146
        
       The following represents the contents of `all-packages.nix`.

     

       147
       147
       -
       ```

     

       147
       147
       +
       ```nix

     

       148
       148
        
       {

     

       149
       149
        
         # ...

     

       150
       150

+27 -26

doc/languages-frameworks/rust.section.md

···

       2
       2
        
       

     

       3
       3
        
       To install the rust compiler and cargo put

     

       4
       4
        
       

     

       5
       5
       -
       ```

     

       6
       6
       -
       rustc

     

       7
       7
       -
       cargo

     

       5
       5
       +
       ```nix

     

       6
       6
       +
       environment.systemPackages = [

     

       7
       7
       +
         rustc

     

       8
       8
       +
         cargo

     

       9
       9
       +
       ];

     

       8
       10
        
       ```

     

       9
       11
        
       

     

       10
       10
       -
       into the `environment.systemPackages` or bring them into

     

       11
       11
       -
       scope with `nix-shell -p rustc cargo`.

     

       12
       12
       +
       into your `configuration.nix` or bring them into scope with `nix-shell -p rustc cargo`.

     

       12
       13
        
       

     

       13
       14
        
       For other versions such as daily builds (beta and nightly),

     

       14
       15
        
       use either `rustup` from nixpkgs (which will manage the rust installation in your home directory),

     
···

       18
       19
        
       

     

       19
       20
        
       Rust applications are packaged by using the `buildRustPackage` helper from `rustPlatform`:

     

       20
       21
        
       

     

       21
       21
       -
       ```

     

       22
       22
       +
       ```nix

     

       22
       23
        
       { lib, rustPlatform }:

     

       23
       24
        
       

     

       24
       25
        
       rustPlatform.buildRustPackage rec {

     
···

       49
       50
        
       such as the one in the example above. `cargoHash` should instead be

     

       50
       51
        
       used for [SRI](https://www.w3.org/TR/SRI/) hashes. For example:

     

       51
       52
        
       

     

       52
       52
       -
       ```

     

       53
       53
       +
       ```nix

     

       53
       54
        
         cargoHash = "sha256-l1vL2ZdtDRxSGvP0X/l3nMw8+6WF67KPutJEzUROjg8=";

     

       54
       55
        
       ```

     

       55
       56
        
       

     
···

       59
       60
        
       then be taken from the failed build. A fake hash can be used for

     

       60
       61
        
       `cargoSha256` as follows:

     

       61
       62
        
       

     

       62
       62
       -
       ```

     

       63
       63
       +
       ```nix

     

       63
       64
        
         cargoSha256 = lib.fakeSha256;

     

       64
       65
        
       ```

     

       65
       66
        
       

     

       66
       67
        
       For `cargoHash` you can use:

     

       67
       68
        
       

     

       68
       68
       -
       ```

     

       69
       69
       +
       ```nix

     

       69
       70
        
         cargoHash = lib.fakeHash;

     

       70
       71
        
       ```

     

       71
       72
        
       

     
···

       262
       263
        
       source code in a reproducible way. If it is missing or out-of-date one can use

     

       263
       264
        
       the `cargoPatches` attribute to update or add it.

     

       264
       265
        
       

     

       265
       265
       -
       ```

     

       266
       266
       +
       ```nix

     

       266
       267
        
       rustPlatform.buildRustPackage rec {

     

       267
       268
        
         (...)

     

       268
       269
        
         cargoPatches = [

     
···

       489
       490
        
       

     

       490
       491
        
       Now, the file produced by the call to `carnix`, called `hello.nix`, looks like:

     

       491
       492
        
       

     

       492
       492
       -
       ```

     

       493
       493
       +
       ```nix

     

       493
       494
        
       # Generated by carnix 0.6.5: carnix -o hello.nix --src ./. Cargo.lock --standalone

     

       494
       495
        
       { stdenv, buildRustCrate, fetchgit }:

     

       495
       496
        
       let kernel = stdenv.buildPlatform.parsed.kernel.name;

     
···

       518
       519
        
       `Cargo.lock`. Then, `carnix` needs to be run again, and produces the

     

       519
       520
        
       following nix file:

     

       520
       521
        
       

     

       521
       521
       -
       ```

     

       522
       522
       +
       ```nix

     

       522
       523
        
       # Generated by carnix 0.6.5: carnix -o hello.nix --src ./. Cargo.lock --standalone

     

       523
       524
        
       { stdenv, buildRustCrate, fetchgit }:

     

       524
       525
        
       let kernel = stdenv.buildPlatform.parsed.kernel.name;

     
···

       573
       574
        
       Starting from that file, one can add more overrides, to add features

     

       574
       575
        
       or build inputs by overriding the hello crate in a seperate file.

     

       575
       576
        
       

     

       576
       576
       -
       ```

     

       577
       577
       +
       ```nix

     

       577
       578
        
       with import <nixpkgs> {};

     

       578
       579
        
       ((import ./hello.nix).hello {}).override {

     

       579
       580
        
         crateOverrides = defaultCrateOverrides // {

     
···

       593
       594
        
       the override above can be read, as in the following example, which

     

       594
       595
        
       patches the derivation:

     

       595
       596
        
       

     

       596
       596
       -
       ```

     

       597
       597
       +
       ```nix

     

       597
       598
        
       with import <nixpkgs> {};

     

       598
       599
        
       ((import ./hello.nix).hello {}).override {

     

       599
       600
        
         crateOverrides = defaultCrateOverrides // {

     
···

       614
       615
        
       `libc` in the example above, where `libc` is a dependency of the main

     

       615
       616
        
       crate, we could do:

     

       616
       617
        
       

     

       617
       617
       -
       ```

     

       618
       618
       +
       ```nix

     

       618
       619
        
       with import <nixpkgs> {};

     

       619
       620
        
       ((import hello.nix).hello {}).override {

     

       620
       621
        
         crateOverrides = defaultCrateOverrides // {

     
···

       630
       631
        
       

     

       631
       632
        
       - The version of rustc used to compile the crate:

     

       632
       633
        
       

     

       633
       633
       -
         ```

     

       634
       634
       +
         ```nix

     

       634
       635
        
         (hello {}).override { rust = pkgs.rust; };

     

       635
       636
        
         ```

     

       636
       637
        
       

     

       637
       638
        
       - Whether to build in release mode or debug mode (release mode by

     

       638
       639
        
         default):

     

       639
       640
        
       

     

       640
       640
       -
         ```

     

       641
       641
       +
         ```nix

     

       641
       642
        
         (hello {}).override { release = false; };

     

       642
       643
        
         ```

     

       643
       644
        
       

     

       644
       645
        
       - Whether to print the commands sent to rustc when building

     

       645
       646
        
         (equivalent to `--verbose` in cargo:

     

       646
       647
        
       

     

       647
       647
       -
         ```

     

       648
       648
       +
         ```nix

     

       648
       649
        
         (hello {}).override { verbose = false; };

     

       649
       650
        
         ```

     

       650
       651
        
       

     

       651
       652
        
       - Extra arguments to be passed to `rustc`:

     

       652
       653
        
       

     

       653
       653
       -
         ```

     

       654
       654
       +
         ```nix

     

       654
       655
        
         (hello {}).override { extraRustcOpts = "-Z debuginfo=2"; };

     

       655
       656
        
         ```

     

       656
       657
        
       

     
···

       662
       663
        
         `postInstall`. As an example, here is how to create a new module

     

       663
       664
        
         before running the build script:

     

       664
       665
        
       

     

       665
       665
       -
         ```

     

       666
       666
       +
         ```nix

     

       666
       667
        
         (hello {}).override {

     

       667
       668
        
           preConfigure = ''

     

       668
       669
        
              echo "pub const PATH=\"${hi.out}\";" >> src/path.rs"

     
···

       676
       677
        
       compile `diesel_cli` only with the `postgres` feature, and no default

     

       677
       678
        
       features, we would write:

     

       678
       679
        
       

     

       679
       679
       -
       ```

     

       680
       680
       +
       ```nix

     

       680
       681
        
       (callPackage ./diesel.nix {}).diesel {

     

       681
       682
        
         default = false;

     

       682
       683
        
         postgres = true;

     
···

       699
       700
        
       

     

       700
       701
        
       A typical `shell.nix` might look like:

     

       701
       702
        
       

     

       702
       702
       -
       ```

     

       703
       703
       +
       ```nix

     

       703
       704
        
       with import <nixpkgs> {};

     

       704
       705
        
       

     

       705
       706
        
       stdenv.mkDerivation {

     
···

       721
       722
        
       ```

     

       722
       723
        
       

     

       723
       724
        
       You should now be able to run the following:

     

       724
       724
       -
       ```

     

       725
       725
       +
       ```ShellSesssion

     

       725
       726
        
       $ nix-shell --pure

     

       726
       727
        
       $ cargo build

     

       727
       728
        
       $ cargo test

     
···

       731
       732
        
       To control your rust version (i.e. use nightly) from within `shell.nix` (or

     

       732
       733
        
       other nix expressions) you can use the following `shell.nix`

     

       733
       734
        
       

     

       734
       734
       -
       ```

     

       735
       735
       +
       ```nix

     

       735
       736
        
       # Latest Nightly

     

       736
       737
        
       with import <nixpkgs> {};

     

       737
       738
        
       let src = fetchFromGitHub {

     
···

       759
       760
        
       ```

     

       760
       761
        
       

     

       761
       762
        
       Now run:

     

       762
       762
       -
       ```

     

       763
       763
       +
       ```ShellSession

     

       763
       764
        
       $ rustc --version

     

       764
       765
        
       rustc 1.26.0-nightly (188e693b3 2018-03-26)

     

       765
       766
        
       ```

     
···

       794
       795
        
       

     

       795
       796
        
       Add the following to your `configuration.nix`, `home-configuration.nix`, `shell.nix`, or similar:

     

       796
       797
        
       

     

       797
       797
       -
       ```

     

       798
       798
       +
       ```nix

     

       798
       799
        
       { pkgs ? import <nixpkgs> {

     

       799
       800
        
           overlays = [

     

       800
       801
        
             (import (builtins.fetchTarball https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz))

+4 -4

doc/languages-frameworks/vim.section.md

···

       156
       156
        
       

     

       157
       157
        
       First create a vim-scripts file having one plugin name per line. Example:

     

       158
       158
        
       

     

       159
       159
       -
       ```

     

       159
       159
       +
       ```vim

     

       160
       160
        
       "tlib"

     

       161
       161
        
       {'name': 'vim-addon-sql'}

     

       162
       162
        
       {'filetype_regex': '\%(vim)$', 'names': ['reload', 'vim-dev-plugin']}

     
···

       197
       197
        
       You should get a Vim buffer with the nix derivations (output1) and vam.pluginDictionaries (output2).

     

       198
       198
        
       You can add your Vim to your system's configuration file like this and start it by "vim-my":

     

       199
       199
        
       

     

       200
       200
       -
       ```

     

       200
       200
       +
       ```nix

     

       201
       201
        
       my-vim =

     

       202
       202
        
         let plugins = let inherit (vimUtils) buildVimPluginFrom2Nix; in {

     

       203
       203
        
           copy paste output1 here

     
···

       217
       217
        
       

     

       218
       218
        
       Sample output1:

     

       219
       219
        
       

     

       220
       220
       -
       ```

     

       220
       220
       +
       ```nix

     

       221
       221
        
       "reload" = buildVimPluginFrom2Nix { # created by nix#NixDerivation

     

       222
       222
        
         name = "reload";

     

       223
       223
        
         src = fetchgit {

     
···

       248
       248
        
       

     

       249
       249
        
       Some plugins require overrides in order to function properly. Overrides are placed in [overrides.nix](/pkgs/misc/vim-plugins/overrides.nix). Overrides are most often required when a plugin requires some dependencies, or extra steps are required during the build process. For example `deoplete-fish` requires both `deoplete-nvim` and `vim-fish`, and so the following override was added:

     

       250
       250
        
       

     

       251
       251
       -
       ```

     

       251
       251
       +
       ```nix

     

       252
       252
        
       deoplete-fish = super.deoplete-fish.overrideAttrs(old: {

     

       253
       253
        
         dependencies = with super; [ deoplete-nvim vim-fish ];

     

       254
       254
        
       });