commit bcea0cf344ac5040a47a5bda4f4cec2ff3d164f6 · pyrox.dev/nixpkgs

+12 -3

doc/build-helpers/dev-shell-tools.chapter.md

···

       42
       42
        
       devShellTools.unstructuredDerivationInputEnv {

     

       43
       43
        
         drvAttrs = {

     

       44
       44
        
           name = "foo";

     

       45
       45
       -
           buildInputs = [ hello figlet ];

     

       45
       45
       +
           buildInputs = [

     

       46
       46
       +
             hello

     

       47
       47
       +
             figlet

     

       48
       48
       +
           ];

     

       46
       49
        
           builder = bash;

     

       47
       47
       -
           args = [ "-c" "${./builder.sh}" ];

     

       50
       50
       +
           args = [

     

       51
       51
       +
             "-c"

     

       52
       52
       +
             "${./builder.sh}"

     

       53
       53
       +
           ];

     

       48
       54
        
         };

     

       49
       55
        
       }

     

       50
       56
        
       # => {

     
···

       69
       75
        
       let

     

       70
       76
        
         pkg = hello;

     

       71
       77
        
       in

     

       72
       72
       -
       devShellTools.derivationOutputEnv { outputList = pkg.outputs; outputMap = pkg; }

     

       78
       78
       +
       devShellTools.derivationOutputEnv {

     

       79
       79
       +
         outputList = pkg.outputs;

     

       80
       80
       +
         outputMap = pkg;

     

       81
       81
       +
       }

     

       73
       82
        
       ```

     

       74
       83
        
       

     

       75
       84
        
       :::

+12 -5

doc/build-helpers/fetchers.chapter.md

···

       491
       491
        
       In this example, we'll adapt [](#ex-fetchers-fetchurl-nixpkgs-version) to append the result of running the `hello` package to the contents we download, purely to illustrate how to manipulate the content.

     

       492
       492
        
       

     

       493
       493
        
       ```nix

     

       494
       494
       -
       { fetchurl, hello, lib }:

     

       494
       494
       +
       {

     

       495
       495
       +
         fetchurl,

     

       496
       496
       +
         hello,

     

       497
       497
       +
         lib,

     

       498
       498
       +
       }:

     

       495
       499
        
       fetchurl {

     

       496
       500
        
         url = "https://raw.githubusercontent.com/NixOS/nixpkgs/23.11/.version";

     

       497
       501
        
       

     
···

       714
       718
        
       Here is an example of `fetchDebianPatch` in action:

     

       715
       719
        
       

     

       716
       720
        
       ```nix

     

       717
       717
       -
       { lib

     

       718
       718
       -
       , fetchDebianPatch

     

       719
       719
       -
       , buildPythonPackage

     

       721
       721
       +
       {

     

       722
       722
       +
         lib,

     

       723
       723
       +
         fetchDebianPatch,

     

       724
       724
       +
         buildPythonPackage,

     

       720
       725
        
       }:

     

       721
       726
        
       

     

       722
       727
        
       buildPythonPackage rec {

     
···

       914
       919
        
       { fetchtorrent }:

     

       915
       920
        
       

     

       916
       921
        
       fetchtorrent {

     

       917
       917
       -
         config = { peer-limit-global = 100; };

     

       922
       922
       +
         config = {

     

       923
       923
       +
           peer-limit-global = 100;

     

       924
       924
       +
         };

     

       918
       925
        
         url = "magnet:?xt=urn:btih:dd8255ecdc7ca55fb0bbf81323d87062db1f6d1c";

     

       919
       926
        
         hash = "";

     

       920
       927
        
       }

+6 -3

doc/build-helpers/images/appimagetools.section.md

···

       66
       66
        
           url = "https://github.com/irccloud/irccloud-desktop/releases/download/v${version}/IRCCloud-${version}-linux-x86_64.AppImage";

     

       67
       67
        
           hash = "sha256-/hMPvYdnVB1XjKgU2v47HnVvW4+uC3rhRjbucqin4iI=";

     

       68
       68
        
         };

     

       69
       69
       -
       in appimageTools.wrapType2 {

     

       69
       69
       +
       in

     

       70
       70
       +
       appimageTools.wrapType2 {

     

       70
       71
        
         inherit pname version src;

     

       71
       72
        
         extraPkgs = pkgs: [ pkgs.at-spi2-core ];

     

       72
       73
        
       }

     
···

       106
       107
        
         appimageContents = appimageTools.extract {

     

       107
       108
        
           inherit pname version src;

     

       108
       109
        
         };

     

       109
       109
       -
       in appimageTools.wrapType2 {

     

       110
       110
       +
       in

     

       111
       111
       +
       appimageTools.wrapType2 {

     

       110
       112
        
         inherit pname version src;

     

       111
       113
        
       

     

       112
       114
        
         extraPkgs = pkgs: [ pkgs.at-spi2-core ];

     
···

       150
       152
        
             substituteInPlace $out/irccloud.desktop --replace-fail 'Exec=AppRun' 'Exec=${pname}'

     

       151
       153
        
           '';

     

       152
       154
        
         };

     

       153
       153
       -
       in appimageTools.wrapType2 {

     

       155
       155
       +
       in

     

       156
       156
       +
       appimageTools.wrapType2 {

     

       154
       157
        
         inherit pname version src;

     

       155
       158
        
       

     

       156
       159
        
         extraPkgs = pkgs: [ pkgs.at-spi2-core ];

+1 -1

doc/build-helpers/images/binarycache.section.md

···

       35
       35
        
       ```nix

     

       36
       36
        
       { mkBinaryCache, hello }:

     

       37
       37
        
       mkBinaryCache {

     

       38
       38
       -
         rootPaths = [hello];

     

       38
       38
       +
         rootPaths = [ hello ];

     

       39
       39
        
       }

     

       40
       40
        
       ```

     

       41
       41

+34 -8

doc/build-helpers/images/dockertools.section.md

···

       235
       235
        
       The Docker image will have name `redis` and tag `latest`.

     

       236
       236
        
       

     

       237
       237
        
       ```nix

     

       238
       238
       -
       { dockerTools, buildEnv, redis }:

     

       238
       238
       +
       {

     

       239
       239
       +
         dockerTools,

     

       240
       240
       +
         buildEnv,

     

       241
       241
       +
         redis,

     

       242
       242
       +
       }:

     

       239
       243
        
       dockerTools.buildImage {

     

       240
       244
        
         name = "redis";

     

       241
       245
        
         tag = "latest";

     
···

       253
       257
        
         config = {

     

       254
       258
        
           Cmd = [ "/bin/redis-server" ];

     

       255
       259
        
           WorkingDir = "/data";

     

       256
       256
       -
           Volumes = { "/data" = { }; };

     

       260
       260
       +
           Volumes = {

     

       261
       261
       +
             "/data" = { };

     

       262
       262
       +
           };

     

       257
       263
        
         };

     

       258
       264
        
       }

     

       259
       265
        
       ```

     
···

       286
       292
        
       This works the same as [](#ex-dockerTools-buildImage-extraCommands), but uses `runAsRoot` instead of `extraCommands`.

     

       287
       293
        
       

     

       288
       294
        
       ```nix

     

       289
       289
       -
       { dockerTools, buildEnv, hello }:

     

       295
       295
       +
       {

     

       296
       296
       +
         dockerTools,

     

       297
       297
       +
         buildEnv,

     

       298
       298
       +
         hello,

     

       299
       299
       +
       }:

     

       290
       300
        
       dockerTools.buildImage {

     

       291
       301
        
         name = "hello";

     

       292
       302
        
         tag = "latest";

     
···

       320
       330
        
       Note that with `extraCommands`, we can't directly reference `/` and must create files and directories as if we were already on `/`.

     

       321
       331
        
       

     

       322
       332
        
       ```nix

     

       323
       323
       -
       { dockerTools, buildEnv, hello }:

     

       333
       333
       +
       {

     

       334
       334
       +
         dockerTools,

     

       335
       335
       +
         buildEnv,

     

       336
       336
       +
         hello,

     

       337
       337
       +
       }:

     

       324
       338
        
       dockerTools.buildImage {

     

       325
       339
        
         name = "hello";

     

       326
       340
        
         tag = "latest";

     
···

       350
       364
        
       Note that using a value of `"now"` in the `created` attribute will break reproducibility.

     

       351
       365
        
       

     

       352
       366
        
       ```nix

     

       353
       353
       -
       { dockerTools, buildEnv, hello }:

     

       367
       367
       +
       {

     

       368
       368
       +
         dockerTools,

     

       369
       369
       +
         buildEnv,

     

       370
       370
       +
         hello,

     

       371
       371
       +
       }:

     

       354
       372
        
       dockerTools.buildImage {

     

       355
       373
        
         name = "hello";

     

       356
       374
        
         tag = "latest";

     
···

       766
       784
        
       The following package shows a more compact way to create the same output generated in [](#ex-dockerTools-streamLayeredImage-hello).

     

       767
       785
        
       

     

       768
       786
        
       ```nix

     

       769
       769
       -
       { dockerTools, hello, lib }:

     

       787
       787
       +
       {

     

       788
       788
       +
         dockerTools,

     

       789
       789
       +
         hello,

     

       790
       790
       +
         lib,

     

       791
       791
       +
       }:

     

       770
       792
        
       dockerTools.streamLayeredImage {

     

       771
       793
        
         name = "hello";

     

       772
       794
        
         tag = "latest";

     
···

       1547
       1569
        
       This example uses [](#ex-dockerTools-streamNixShellImage-hello) as a starting point.

     

       1548
       1570
        
       

     

       1549
       1571
        
       ```nix

     

       1550
       1550
       -
       { dockerTools, cowsay, hello }:

     

       1572
       1572
       +
       {

     

       1573
       1573
       +
         dockerTools,

     

       1574
       1574
       +
         cowsay,

     

       1575
       1575
       +
         hello,

     

       1576
       1576
       +
       }:

     

       1551
       1577
        
       dockerTools.streamNixShellImage {

     

       1552
       1578
        
         tag = "latest";

     

       1553
       1579
        
         drv = hello.overrideAttrs (old: {

     

       1554
       1554
       -
           nativeBuildInputs = old.nativeBuildInputs or [] ++ [

     

       1580
       1580
       +
           nativeBuildInputs = old.nativeBuildInputs or [ ] ++ [

     

       1555
       1581
        
             cowsay

     

       1556
       1582
        
           ];

     

       1557
       1583
        
         });

+37 -30

doc/build-helpers/images/makediskimage.section.md

···

       52
       52
        
       To produce a Nix-store only image:

     

       53
       53
        
       ```nix

     

       54
       54
        
       let

     

       55
       55
       -
         pkgs = import <nixpkgs> {};

     

       55
       55
       +
         pkgs = import <nixpkgs> { };

     

       56
       56
        
         lib = pkgs.lib;

     

       57
       57
        
         make-disk-image = import <nixpkgs/nixos/lib/make-disk-image.nix>;

     

       58
       58
        
       in

     

       59
       59
       -
         make-disk-image {

     

       60
       60
       -
           inherit pkgs lib;

     

       61
       61
       -
           config = {};

     

       62
       62
       -
           additionalPaths = [ ];

     

       63
       63
       -
           format = "qcow2";

     

       64
       64
       -
           onlyNixStore = true;

     

       65
       65
       -
           partitionTableType = "none";

     

       66
       66
       -
           installBootLoader = false;

     

       67
       67
       -
           touchEFIVars = false;

     

       68
       68
       -
           diskSize = "auto";

     

       69
       69
       -
           additionalSpace = "0M"; # Defaults to 512M.

     

       70
       70
       -
           copyChannel = false;

     

       71
       71
       -
         }

     

       59
       59
       +
       make-disk-image {

     

       60
       60
       +
         inherit pkgs lib;

     

       61
       61
       +
         config = { };

     

       62
       62
       +
         additionalPaths = [ ];

     

       63
       63
       +
         format = "qcow2";

     

       64
       64
       +
         onlyNixStore = true;

     

       65
       65
       +
         partitionTableType = "none";

     

       66
       66
       +
         installBootLoader = false;

     

       67
       67
       +
         touchEFIVars = false;

     

       68
       68
       +
         diskSize = "auto";

     

       69
       69
       +
         additionalSpace = "0M"; # Defaults to 512M.

     

       70
       70
       +
         copyChannel = false;

     

       71
       71
       +
       }

     

       72
       72
        
       ```

     

       73
       73
        
       

     

       74
       74
        
       Some arguments can be left out, they are shown explicitly for the sake of the example.

     
···

       78
       78
        
       To produce a NixOS installation image disk with UEFI and bootloader installed:

     

       79
       79
        
       ```nix

     

       80
       80
        
       let

     

       81
       81
       -
         pkgs = import <nixpkgs> {};

     

       81
       81
       +
         pkgs = import <nixpkgs> { };

     

       82
       82
        
         lib = pkgs.lib;

     

       83
       83
        
         make-disk-image = import <nixpkgs/nixos/lib/make-disk-image.nix>;

     

       84
       84
        
         evalConfig = import <nixpkgs/nixos/lib/eval-config.nix>;

     

       85
       85
        
       in

     

       86
       86
       -
         make-disk-image {

     

       87
       87
       -
           inherit pkgs lib;

     

       88
       88
       -
           inherit (evalConfig {

     

       86
       86
       +
       make-disk-image {

     

       87
       87
       +
         inherit pkgs lib;

     

       88
       88
       +
         inherit

     

       89
       89
       +
           (evalConfig {

     

       89
       90
        
             modules = [

     

       90
       91
        
               {

     

       91
       91
       -
                 fileSystems."/" = { device = "/dev/vda"; fsType = "ext4"; autoFormat = true; };

     

       92
       92
       +
                 fileSystems."/" = {

     

       93
       93
       +
                   device = "/dev/vda";

     

       94
       94
       +
                   fsType = "ext4";

     

       95
       95
       +
                   autoFormat = true;

     

       96
       96
       +
                 };

     

       92
       97
        
                 boot.grub.device = "/dev/vda";

     

       93
       98
        
               }

     

       94
       99
        
             ];

     

       95
       95
       -
           }) config;

     

       96
       96
       -
           format = "qcow2";

     

       97
       97
       -
           onlyNixStore = false;

     

       98
       98
       -
           partitionTableType = "legacy+gpt";

     

       99
       99
       -
           installBootLoader = true;

     

       100
       100
       -
           touchEFIVars = true;

     

       101
       101
       -
           diskSize = "auto";

     

       102
       102
       -
           additionalSpace = "0M"; # Defaults to 512M.

     

       103
       103
       -
           copyChannel = false;

     

       104
       104
       -
           memSize = 2048; # Qemu VM memory size in megabytes. Defaults to 1024M.

     

       105
       105
       -
         }

     

       100
       100
       +
           })

     

       101
       101
       +
           config

     

       102
       102
       +
           ;

     

       103
       103
       +
         format = "qcow2";

     

       104
       104
       +
         onlyNixStore = false;

     

       105
       105
       +
         partitionTableType = "legacy+gpt";

     

       106
       106
       +
         installBootLoader = true;

     

       107
       107
       +
         touchEFIVars = true;

     

       108
       108
       +
         diskSize = "auto";

     

       109
       109
       +
         additionalSpace = "0M"; # Defaults to 512M.

     

       110
       110
       +
         copyChannel = false;

     

       111
       111
       +
         memSize = 2048; # Qemu VM memory size in megabytes. Defaults to 1024M.

     

       112
       112
       +
       }

     

       106
       113
        
       ```

+5 -1

doc/build-helpers/images/ocitools.section.md

···

       76
       76
        
       This example uses `ociTools.buildContainer` to create a simple container that runs `bash`.

     

       77
       77
        
       

     

       78
       78
        
       ```nix

     

       79
       79
       -
       { ociTools, lib, bash }:

     

       79
       79
       +
       {

     

       80
       80
       +
         ociTools,

     

       81
       81
       +
         lib,

     

       82
       82
       +
         bash,

     

       83
       83
       +
       }:

     

       80
       84
        
       ociTools.buildContainer {

     

       81
       85
        
         args = [

     

       82
       86
        
           (lib.getExe bash)

+17 -3

doc/build-helpers/images/portableservice.section.md

···

       91
       91
        
       The following example builds a Portable Service image with the `hello` package, along with a service unit that runs it.

     

       92
       92
        
       

     

       93
       93
        
       ```nix

     

       94
       94
       -
       { lib, writeText, portableService, hello }:

     

       94
       94
       +
       {

     

       95
       95
       +
         lib,

     

       96
       96
       +
         writeText,

     

       97
       97
       +
         portableService,

     

       98
       98
       +
         hello,

     

       99
       99
       +
       }:

     

       95
       100
        
       let

     

       96
       101
        
         hello-service = writeText "hello.service" ''

     

       97
       102
        
           [Unit]

     
···

       151
       156
        
       The following package builds on the package from [](#ex-portableService-hello) to make `/etc/ssl` available globally (this is only for illustrative purposes, because `hello` doesn't use `/etc/ssl`).

     

       152
       157
        
       

     

       153
       158
        
       ```nix

     

       154
       154
       -
       { lib, writeText, portableService, hello, cacert }:

     

       159
       159
       +
       {

     

       160
       160
       +
         lib,

     

       161
       161
       +
         writeText,

     

       162
       162
       +
         portableService,

     

       163
       163
       +
         hello,

     

       164
       164
       +
         cacert,

     

       165
       165
       +
       }:

     

       155
       166
        
       let

     

       156
       167
        
         hello-service = writeText "hello.service" ''

     

       157
       168
        
           [Unit]

     
···

       167
       178
        
         inherit (hello) version;

     

       168
       179
        
         units = [ hello-service ];

     

       169
       180
        
         symlinks = [

     

       170
       170
       -
           { object = "${cacert}/etc/ssl"; symlink = "/etc/ssl"; }

     

       181
       181
       +
           {

     

       182
       182
       +
             object = "${cacert}/etc/ssl";

     

       183
       183
       +
             symlink = "/etc/ssl";

     

       184
       184
       +
           }

     

       171
       185
        
         ];

     

       172
       186
        
       }

     

       173
       187
        
       ```

+5 -2

doc/build-helpers/special/checkpoint-build.section.md

···

       26
       26
        
       

     

       27
       27
        
       ## Example {#sec-checkpoint-build-example}

     

       28
       28
        
       ```nix

     

       29
       29
       -
       { pkgs ? import <nixpkgs> {} }:

     

       29
       29
       +
       {

     

       30
       30
       +
         pkgs ? import <nixpkgs> { },

     

       31
       31
       +
       }:

     

       30
       32
        
       let

     

       31
       33
        
         inherit (pkgs.checkpointBuildTools)

     

       32
       34
        
           prepareCheckpointBuild

     
···

       39
       41
        
             sed -i 's/Hello, world!/Hello, Nix!/g' src/hello.c

     

       40
       42
        
           '';

     

       41
       43
        
         });

     

       42
       42
       -
       in mkCheckpointBuild changedHello helloCheckpoint

     

       44
       44
       +
       in

     

       45
       45
       +
       mkCheckpointBuild changedHello helloCheckpoint

     

       43
       46
        
       ```

+11 -4

doc/build-helpers/special/fakenss.section.md

···

       48
       48
        
       This example includes the `hello` binary in the image so it can do something besides just have the extra files.

     

       49
       49
        
       

     

       50
       50
        
       ```nix

     

       51
       51
       -
       { dockerTools, fakeNss, hello }:

     

       51
       51
       +
       {

     

       52
       52
       +
         dockerTools,

     

       53
       53
       +
         fakeNss,

     

       54
       54
       +
         hello,

     

       55
       55
       +
       }:

     

       52
       56
        
       dockerTools.buildImage {

     

       53
       57
        
         name = "image-with-passwd";

     

       54
       58
        
         tag = "latest";

     

       55
       59
        
       

     

       56
       56
       -
         copyToRoot = [ fakeNss hello ];

     

       60
       60
       +
         copyToRoot = [

     

       61
       61
       +
           fakeNss

     

       62
       62
       +
           hello

     

       63
       63
       +
         ];

     

       57
       64
        
       

     

       58
       65
        
         config = {

     

       59
       66
        
           Cmd = [ "/bin/hello" ];

     
···

       70
       77
        
       ```nix

     

       71
       78
        
       { fakeNss }:

     

       72
       79
        
       fakeNss.override {

     

       73
       73
       -
         extraPasswdLines = ["newuser:x:9001:9001:new user:/var/empty:/bin/sh"];

     

       74
       74
       -
         extraGroupLines = ["newuser:x:9001:"];

     

       80
       80
       +
         extraPasswdLines = [ "newuser:x:9001:9001:new user:/var/empty:/bin/sh" ];

     

       81
       81
       +
         extraGroupLines = [ "newuser:x:9001:" ];

     

       75
       82
        
       }

     

       76
       83
        
       ```

     

       77
       84
        
       :::

+20 -13

doc/build-helpers/special/fhs-environments.section.md

···

       36
       36
        
       You can create a simple environment using a `shell.nix` like this:

     

       37
       37
        
       

     

       38
       38
        
       ```nix

     

       39
       39
       -
       { pkgs ? import <nixpkgs> {} }:

     

       39
       39
       +
       {

     

       40
       40
       +
         pkgs ? import <nixpkgs> { },

     

       41
       41
       +
       }:

     

       40
       42
        
       

     

       41
       43
        
       (pkgs.buildFHSEnv {

     

       42
       44
        
         name = "simple-x11-env";

     

       43
       43
       -
         targetPkgs = pkgs: (with pkgs; [

     

       44
       44
       -
           udev

     

       45
       45
       -
           alsa-lib

     

       46
       46
       -
         ]) ++ (with pkgs.xorg; [

     

       47
       47
       -
           libX11

     

       48
       48
       -
           libXcursor

     

       49
       49
       -
           libXrandr

     

       50
       50
       -
         ]);

     

       51
       51
       -
         multiPkgs = pkgs: (with pkgs; [

     

       52
       52
       -
           udev

     

       53
       53
       -
           alsa-lib

     

       54
       54
       -
         ]);

     

       45
       45
       +
         targetPkgs =

     

       46
       46
       +
           pkgs:

     

       47
       47
       +
           (with pkgs; [

     

       48
       48
       +
             udev

     

       49
       49
       +
             alsa-lib

     

       50
       50
       +
           ])

     

       51
       51
       +
           ++ (with pkgs.xorg; [

     

       52
       52
       +
             libX11

     

       53
       53
       +
             libXcursor

     

       54
       54
       +
             libXrandr

     

       55
       55
       +
           ]);

     

       56
       56
       +
         multiPkgs =

     

       57
       57
       +
           pkgs:

     

       58
       58
       +
           (with pkgs; [

     

       59
       59
       +
             udev

     

       60
       60
       +
             alsa-lib

     

       61
       61
       +
           ]);

     

       55
       62
        
         runScript = "bash";

     

       56
       63
        
       }).env

     

       57
       64
        
       ```

+7 -2

doc/build-helpers/special/mkshell.section.md

···

       8
       8
        
       Here is a common usage example:

     

       9
       9
        
       

     

       10
       10
        
       ```nix

     

       11
       11
       -
       { pkgs ? import <nixpkgs> {} }:

     

       11
       11
       +
       {

     

       12
       12
       +
         pkgs ? import <nixpkgs> { },

     

       13
       13
       +
       }:

     

       12
       14
        
       pkgs.mkShell {

     

       13
       15
        
         packages = [ pkgs.gnumake ];

     

       14
       16
        
       

     

       15
       15
       -
         inputsFrom = [ pkgs.hello pkgs.gnutar ];

     

       17
       17
       +
         inputsFrom = [

     

       18
       18
       +
           pkgs.hello

     

       19
       19
       +
           pkgs.gnutar

     

       20
       20
       +
         ];

     

       16
       21
        
       

     

       17
       22
        
         shellHook = ''

     

       18
       23
        
           export DEBUG=1

+30 -19

doc/build-helpers/special/vm-tools.section.md

···

       31
       31
        
       

     

       32
       32
        
       Build the derivation hello inside a VM:

     

       33
       33
        
       ```nix

     

       34
       34
       -
       { pkgs }: with pkgs; with vmTools;

     

       35
       35
       -
       runInLinuxVM hello

     

       34
       34
       +
       { pkgs }: with pkgs; with vmTools; runInLinuxVM hello

     

       36
       35
        
       ```

     

       37
       36
        
       

     

       38
       37
        
       Build inside a VM with extra memory:

     

       39
       38
        
       ```nix

     

       40
       40
       -
       { pkgs }: with pkgs; with vmTools;

     

       41
       41
       -
       runInLinuxVM (hello.overrideAttrs (_: { memSize = 1024; }))

     

       39
       39
       +
       { pkgs }:

     

       40
       40
       +
       with pkgs;

     

       41
       41
       +
       with vmTools;

     

       42
       42
       +
       runInLinuxVM (

     

       43
       43
       +
         hello.overrideAttrs (_: {

     

       44
       44
       +
           memSize = 1024;

     

       45
       45
       +
         })

     

       46
       46
       +
       )

     

       42
       47
        
       ```

     

       43
       48
        
       

     

       44
       49
        
       Use VM with a disk image (implicitly sets `diskImage`, see [`vmTools.createEmptyImage`](#vm-tools-createEmptyImage)):

     

       45
       50
        
       ```nix

     

       46
       46
       -
       { pkgs }: with pkgs; with vmTools;

     

       47
       47
       -
       runInLinuxVM (hello.overrideAttrs (_: {

     

       48
       48
       -
         preVM = createEmptyImage {

     

       49
       49
       -
           size = 1024;

     

       50
       50
       -
           fullName = "vm-image";

     

       51
       51
       -
         };

     

       52
       52
       -
       }))

     

       51
       51
       +
       { pkgs }:

     

       52
       52
       +
       with pkgs;

     

       53
       53
       +
       with vmTools;

     

       54
       54
       +
       runInLinuxVM (

     

       55
       55
       +
         hello.overrideAttrs (_: {

     

       56
       56
       +
           preVM = createEmptyImage {

     

       57
       57
       +
             size = 1024;

     

       58
       58
       +
             fullName = "vm-image";

     

       59
       59
       +
           };

     

       60
       60
       +
         })

     

       61
       61
       +
       )

     

       53
       62
        
       ```

     

       54
       63
        
       

     

       55
       64
        
       ## `vmTools.extractFs` {#vm-tools-extractFs}

     
···

       66
       75
        
       

     

       67
       76
        
       Extract the contents of an ISO file:

     

       68
       77
        
       ```nix

     

       69
       69
       -
       { pkgs }: with pkgs; with vmTools;

     

       70
       70
       -
       extractFs { file = ./image.iso; }

     

       78
       78
       +
       { pkgs }: with pkgs; with vmTools; extractFs { file = ./image.iso; }

     

       71
       79
        
       ```

     

       72
       80
        
       

     

       73
       81
        
       ## `vmTools.extractMTDfs` {#vm-tools-extractMTDfs}

     
···

       86
       94
        
       

     

       87
       95
        
       Create a script for running a Fedora 27 VM:

     

       88
       96
        
       ```nix

     

       89
       89
       -
       { pkgs }: with pkgs; with vmTools;

     

       90
       90
       -
       makeImageTestScript diskImages.fedora27x86_64

     

       97
       97
       +
       { pkgs }: with pkgs; with vmTools; makeImageTestScript diskImages.fedora27x86_64

     

       91
       98
        
       ```

     

       92
       99
        
       

     

       93
       100
        
       Create a script for running an Ubuntu 20.04 VM:

     

       94
       101
        
       ```nix

     

       95
       95
       -
       { pkgs }: with pkgs; with vmTools;

     

       96
       96
       -
       makeImageTestScript diskImages.ubuntu2004x86_64

     

       102
       102
       +
       { pkgs }: with pkgs; with vmTools; makeImageTestScript diskImages.ubuntu2004x86_64

     

       97
       103
        
       ```

     

       98
       104
        
       

     

       99
       105
        
       ## `vmTools.diskImageFuns` {#vm-tools-diskImageFuns}

     
···

       137
       143
        
       

     

       138
       144
        
       8GiB image containing Firefox in addition to the default packages:

     

       139
       145
        
       ```nix

     

       140
       140
       -
       { pkgs }: with pkgs; with vmTools;

     

       141
       141
       -
       diskImageFuns.ubuntu2004x86_64 { extraPackages = [ "firefox" ]; size = 8192; }

     

       146
       146
       +
       { pkgs }:

     

       147
       147
       +
       with pkgs;

     

       148
       148
       +
       with vmTools;

     

       149
       149
       +
       diskImageFuns.ubuntu2004x86_64 {

     

       150
       150
       +
         extraPackages = [ "firefox" ];

     

       151
       151
       +
         size = 8192;

     

       152
       152
       +
       }

     

       142
       153
        
       ```

     

       143
       154
        
       

     

       144
       155
        
       ## `vmTools.diskImageExtraFuns` {#vm-tools-diskImageExtraFuns}

+64 -40

doc/build-helpers/testers.chapter.md

···

       98
       98
        
         ```nix

     

       99
       99
        
         {

     

       100
       100
        
           "https://nix\\.dev/manual/nix/[a-z0-9.-]*" = "${nix.doc}/share/doc/nix/manual";

     

       101
       101
       -
           "https://nixos\\.org/manual/nix/(un)?stable" = "${emptyDirectory}/placeholder-to-disallow-old-nix-docs-urls";

     

       101
       101
       +
           "https://nixos\\.org/manual/nix/(un)?stable" =

     

       102
       102
       +
             "${emptyDirectory}/placeholder-to-disallow-old-nix-docs-urls";

     

       102
       103
        
         }

     

       103
       104
        
         ```

     

       104
       105
        
       

     
···

       302
       303
        
       # Check that a build fails, and verify the changes made during build

     

       303
       304
        
       

     

       304
       305
        
       ```nix

     

       305
       305
       -
       runCommand "example" {

     

       306
       306
       -
         failed = testers.testBuildFailure (runCommand "fail" {} ''

     

       307
       307
       -
           echo ok-ish >$out

     

       308
       308
       -
           echo failing though

     

       309
       309
       -
           exit 3

     

       310
       310
       -
         '');

     

       311
       311
       -
       } ''

     

       312
       312
       -
         grep -F 'ok-ish' $failed/result

     

       313
       313
       -
         grep -F 'failing though' $failed/testBuildFailure.log

     

       314
       314
       -
         [[ 3 = $(cat $failed/testBuildFailure.exit) ]]

     

       315
       315
       -
         touch $out

     

       316
       316
       -
       ''

     

       306
       306
       +
       runCommand "example"

     

       307
       307
       +
         {

     

       308
       308
       +
           failed = testers.testBuildFailure (

     

       309
       309
       +
             runCommand "fail" { } ''

     

       310
       310
       +
               echo ok-ish >$out

     

       311
       311
       +
               echo failing though

     

       312
       312
       +
               exit 3

     

       313
       313
       +
             ''

     

       314
       314
       +
           );

     

       315
       315
       +
         }

     

       316
       316
       +
         ''

     

       317
       317
       +
           grep -F 'ok-ish' $failed/result

     

       318
       318
       +
           grep -F 'failing though' $failed/testBuildFailure.log

     

       319
       319
       +
           [[ 3 = $(cat $failed/testBuildFailure.exit) ]]

     

       320
       320
       +
           touch $out

     

       321
       321
       +
         ''

     

       317
       322
        
       ```

     

       318
       323
        
       

     

       319
       324
        
       :::

     
···

       396
       401
        
         expected = writeText "expected" ''

     

       397
       402
        
           foo baz baz

     

       398
       403
        
         '';

     

       399
       399
       -
         actual = runCommand "actual" {

     

       400
       400
       -
           # not really necessary for a package that's in stdenv

     

       401
       401
       -
           nativeBuildInputs = [ gnused ];

     

       402
       402
       -
           base = writeText "base" ''

     

       403
       403
       -
             foo bar baz

     

       404
       404
       -
           '';

     

       405
       405
       -
         } ''

     

       406
       406
       -
           sed -e 's/bar/baz/g' $base >$out

     

       407
       407
       -
         '';

     

       404
       404
       +
         actual =

     

       405
       405
       +
           runCommand "actual"

     

       406
       406
       +
             {

     

       407
       407
       +
               # not really necessary for a package that's in stdenv

     

       408
       408
       +
               nativeBuildInputs = [ gnused ];

     

       409
       409
       +
               base = writeText "base" ''

     

       410
       410
       +
                 foo bar baz

     

       411
       411
       +
               '';

     

       412
       412
       +
             }

     

       413
       413
       +
             ''

     

       414
       414
       +
               sed -e 's/bar/baz/g' $base >$out

     

       415
       415
       +
             '';

     

       408
       416
        
       }

     

       409
       417
        
       ```

     

       410
       418
        
       

     
···

       515
       523
        
       # Check that two packages produce the same derivation

     

       516
       524
        
       

     

       517
       525
        
       ```nix

     

       518
       518
       -
       testers.testEqualDerivation

     

       519
       519
       -
         "The hello package must stay the same when enabling checks."

     

       520
       520
       -
         hello

     

       521
       521
       -
         (hello.overrideAttrs(o: { doCheck = true; }))

     

       526
       526
       +
       testers.testEqualDerivation "The hello package must stay the same when enabling checks." hello (

     

       527
       527
       +
         hello.overrideAttrs (o: {

     

       528
       528
       +
           doCheck = true;

     

       529
       529
       +
         })

     

       530
       530
       +
       )

     

       522
       531
        
       ```

     

       523
       532
        
       

     

       524
       533
        
       :::

     
···

       586
       595
        
           curl -o /dev/null https://example.com

     

       587
       596
        
           touch $out

     

       588
       597
        
         '';

     

       589
       589
       -
         nativeBuildInputs = with pkgs; [ cacert curl ];

     

       598
       598
       +
         nativeBuildInputs = with pkgs; [

     

       599
       599
       +
           cacert

     

       600
       600
       +
           curl

     

       601
       601
       +
         ];

     

       590
       602
        
       }

     

       591
       603
        
       ```

     

       592
       604
        
       

     
···

       603
       615
        
       # Run a NixOS test using `runNixOSTest`

     

       604
       616
        
       

     

       605
       617
        
       ```nix

     

       606
       606
       -
       pkgs.testers.runNixOSTest ({ lib, ... }: {

     

       607
       607
       -
         name = "hello";

     

       608
       608
       -
         nodes.machine = { pkgs, ... }: {

     

       609
       609
       -
           environment.systemPackages = [ pkgs.hello ];

     

       610
       610
       -
         };

     

       611
       611
       -
         testScript = ''

     

       612
       612
       -
           machine.succeed("hello")

     

       613
       613
       -
         '';

     

       614
       614
       -
       })

     

       618
       618
       +
       pkgs.testers.runNixOSTest (

     

       619
       619
       +
         { lib, ... }:

     

       620
       620
       +
         {

     

       621
       621
       +
           name = "hello";

     

       622
       622
       +
           nodes.machine =

     

       623
       623
       +
             { pkgs, ... }:

     

       624
       624
       +
             {

     

       625
       625
       +
               environment.systemPackages = [ pkgs.hello ];

     

       626
       626
       +
             };

     

       627
       627
       +
           testScript = ''

     

       628
       628
       +
             machine.succeed("hello")

     

       629
       629
       +
           '';

     

       630
       630
       +
         }

     

       631
       631
       +
       )

     

       615
       632
        
       ```

     

       616
       633
        
       

     

       617
       634
        
       :::

     
···

       634
       651
        
       {

     

       635
       652
        
         name = "my-test";

     

       636
       653
        
         nodes = {

     

       637
       637
       -
           machine1 = { lib, pkgs, nodes, ... }: {

     

       638
       638
       -
             environment.systemPackages = [ pkgs.hello ];

     

       639
       639
       -
             services.foo.enable = true;

     

       640
       640
       -
           };

     

       654
       654
       +
           machine1 =

     

       655
       655
       +
             {

     

       656
       656
       +
               lib,

     

       657
       657
       +
               pkgs,

     

       658
       658
       +
               nodes,

     

       659
       659
       +
               ...

     

       660
       660
       +
             }:

     

       661
       661
       +
             {

     

       662
       662
       +
               environment.systemPackages = [ pkgs.hello ];

     

       663
       663
       +
               services.foo.enable = true;

     

       664
       664
       +
             };

     

       641
       665
        
           # machine2 = ...;

     

       642
       666
        
         };

     

       643
       667
        
         testScript = ''

+84 -57

doc/build-helpers/trivial-build-helpers.chapter.md

···

       66
       66
        
       # Invocation of `runCommandWith`

     

       67
       67
        
       

     

       68
       68
        
       ```nix

     

       69
       69
       -
       runCommandWith {

     

       70
       70
       -
         name = "example";

     

       71
       71
       -
         derivationArgs.nativeBuildInputs = [ cowsay ];

     

       72
       72
       -
       } ''

     

       73
       73
       -
         cowsay > $out <<EOMOO

     

       74
       74
       -
         'runCommandWith' is a bit cumbersome,

     

       75
       75
       -
         so we have more ergonomic wrappers.

     

       76
       76
       -
         EOMOO

     

       77
       77
       -
       ''

     

       69
       69
       +
       runCommandWith

     

       70
       70
       +
         {

     

       71
       71
       +
           name = "example";

     

       72
       72
       +
           derivationArgs.nativeBuildInputs = [ cowsay ];

     

       73
       73
       +
         }

     

       74
       74
       +
         ''

     

       75
       75
       +
           cowsay > $out <<EOMOO

     

       76
       76
       +
           'runCommandWith' is a bit cumbersome,

     

       77
       77
       +
           so we have more ergonomic wrappers.

     

       78
       78
       +
           EOMOO

     

       79
       79
       +
         ''

     

       78
       80
        
       ```

     

       79
       81
        
       

     

       80
       82
        
       :::

     
···

       118
       120
        
       # Invocation of `runCommand`

     

       119
       121
        
       

     

       120
       122
        
       ```nix

     

       121
       121
       -
       runCommand "my-example" {} ''

     

       123
       123
       +
       runCommand "my-example" { } ''

     

       122
       124
        
         echo My example command is running

     

       123
       125
        
       

     

       124
       126
        
         mkdir $out

     
···

       238
       240
        
       Write a desktop file `/nix/store/<store path>/my-program.desktop` to the Nix store.

     

       239
       241
        
       

     

       240
       242
        
       ```nix

     

       241
       241
       -
       {makeDesktopItem}:

     

       243
       243
       +
       { makeDesktopItem }:

     

       242
       244
        
       makeDesktopItem {

     

       243
       245
        
         name = "my-program";

     

       244
       246
        
         desktopName = "My Program";

     
···

       260
       262
        
         mimeTypes = [ "video/mp4" ];

     

       261
       263
        
         categories = [ "Utility" ];

     

       262
       264
        
         implements = [ "org.my-program" ];

     

       263
       263
       -
         keywords = [ "Video" "Player" ];

     

       265
       265
       +
         keywords = [

     

       266
       266
       +
           "Video"

     

       267
       267
       +
           "Player"

     

       268
       268
       +
         ];

     

       264
       269
        
         startupNotify = false;

     

       265
       270
        
         startupWMClass = "MyProgram";

     

       266
       271
        
         prefersNonDefaultGPU = false;

     
···

       276
       281
        
       Override the `hello` package to add a desktop item.

     

       277
       282
        
       

     

       278
       283
        
       ```nix

     

       279
       279
       -
       { copyDesktopItems

     

       280
       280
       -
       , hello

     

       281
       281
       -
       , makeDesktopItem }:

     

       284
       284
       +
       {

     

       285
       285
       +
         copyDesktopItems,

     

       286
       286
       +
         hello,

     

       287
       287
       +
         makeDesktopItem,

     

       288
       288
       +
       }:

     

       282
       289
        
       

     

       283
       290
        
       hello.overrideAttrs {

     

       284
       291
        
         nativeBuildInputs = [ copyDesktopItems ];

     

       285
       292
        
       

     

       286
       286
       -
         desktopItems = [(makeDesktopItem {

     

       287
       287
       -
           name = "hello";

     

       288
       288
       -
           desktopName = "Hello";

     

       289
       289
       -
           exec = "hello";

     

       290
       290
       -
         })];

     

       293
       293
       +
         desktopItems = [

     

       294
       294
       +
           (makeDesktopItem {

     

       295
       295
       +
             name = "hello";

     

       296
       296
       +
             desktopName = "Hello";

     

       297
       297
       +
             exec = "hello";

     

       298
       298
       +
           })

     

       299
       299
       +
         ];

     

       291
       300
        
       }

     

       292
       301
        
       ```

     

       293
       302
        
       

     
···

       446
       455
        
       Write the string `Contents of File` to `/nix/store/<store path>`:

     

       447
       456
        
       

     

       448
       457
        
       ```nix

     

       449
       449
       -
       writeText "my-file"

     

       450
       450
       -
         ''

     

       458
       458
       +
       writeText "my-file" ''

     

       451
       459
        
         Contents of File

     

       452
       452
       -
         ''

     

       460
       460
       +
       ''

     

       453
       461
        
       ```

     

       454
       462
        
       :::

     

       455
       463
        
       

     
···

       486
       494
        
       Write the string `Contents of File` to `/nix/store/<store path>/share/my-file`:

     

       487
       495
        
       

     

       488
       496
        
       ```nix

     

       489
       489
       -
       writeTextDir "share/my-file"

     

       490
       490
       -
         ''

     

       497
       497
       +
       writeTextDir "share/my-file" ''

     

       491
       498
        
         Contents of File

     

       492
       492
       -
         ''

     

       499
       499
       +
       ''

     

       493
       500
        
       ```

     

       494
       501
        
       :::

     

       495
       502
        
       

     
···

       528
       535
        
       Write the string `Contents of File` to `/nix/store/<store path>` and make the file executable.

     

       529
       536
        
       

     

       530
       537
        
       ```nix

     

       531
       531
       -
       writeScript "my-file"

     

       532
       532
       -
         ''

     

       538
       538
       +
       writeScript "my-file" ''

     

       533
       539
        
         Contents of File

     

       534
       534
       -
         ''

     

       540
       540
       +
       ''

     

       535
       541
        
       ```

     

       536
       542
        
       

     

       537
       543
        
       This is equivalent to:

     
···

       570
       576
        
       # Usage of `writeScriptBin`

     

       571
       577
        
       

     

       572
       578
        
       ```nix

     

       573
       573
       -
       writeScriptBin "my-script"

     

       574
       574
       -
         ''

     

       579
       579
       +
       writeScriptBin "my-script" ''

     

       575
       580
        
         echo "hi"

     

       576
       576
       -
         ''

     

       581
       581
       +
       ''

     

       577
       582
        
       ```

     

       578
       583
        
       :::

     

       579
       584
        
       

     
···

       614
       619
        
       # Usage of `writeShellScript`

     

       615
       620
        
       

     

       616
       621
        
       ```nix

     

       617
       617
       -
       writeShellScript "my-script"

     

       618
       618
       -
         ''

     

       622
       622
       +
       writeShellScript "my-script" ''

     

       619
       623
        
         echo "hi"

     

       620
       620
       -
         ''

     

       624
       624
       +
       ''

     

       621
       625
        
       ```

     

       622
       626
        
       :::

     

       623
       627
        
       

     
···

       657
       661
        
       # Usage of `writeShellScriptBin`

     

       658
       662
        
       

     

       659
       663
        
       ```nix

     

       660
       660
       -
       writeShellScriptBin "my-script"

     

       661
       661
       -
         ''

     

       664
       664
       +
       writeShellScriptBin "my-script" ''

     

       662
       665
        
         echo "hi"

     

       663
       663
       -
         ''

     

       666
       666
       +
       ''

     

       664
       667
        
       ```

     

       665
       668
        
       :::

     

       666
       669
        
       

     
···

       685
       688
        
       

     

       686
       689
        
       Here are a few examples:

     

       687
       690
        
       ```nix

     

       688
       688
       -
       

     

       689
       691
        
       # Writes my-file to /nix/store/<store path>

     

       690
       690
       -
       concatTextFile {

     

       691
       691
       -
         name = "my-file";

     

       692
       692
       -
         files = [ drv1 "${drv2}/path/to/file" ];

     

       693
       693
       -
       }

     

       694
       694
       -
       # See also the `concatText` helper function below.

     

       692
       692
       +
       concatTextFile

     

       693
       693
       +
         {

     

       694
       694
       +
           name = "my-file";

     

       695
       695
       +
           files = [

     

       696
       696
       +
             drv1

     

       697
       697
       +
             "${drv2}/path/to/file"

     

       698
       698
       +
           ];

     

       699
       699
       +
         }

     

       700
       700
       +
         # See also the `concatText` helper function below.

     

       695
       701
        
       

     

       696
       696
       -
       # Writes executable my-file to /nix/store/<store path>/bin/my-file

     

       697
       697
       -
       concatTextFile {

     

       698
       698
       -
         name = "my-file";

     

       699
       699
       -
         files = [ drv1 "${drv2}/path/to/file" ];

     

       700
       700
       -
         executable = true;

     

       701
       701
       -
         destination = "/bin/my-file";

     

       702
       702
       -
       }

     

       703
       703
       -
       # Writes contents of files to /nix/store/<store path>

     

       704
       704
       -
       concatText "my-file" [ file1 file2 ]

     

       702
       702
       +
         # Writes executable my-file to /nix/store/<store path>/bin/my-file

     

       703
       703
       +
         concatTextFile

     

       704
       704
       +
         {

     

       705
       705
       +
           name = "my-file";

     

       706
       706
       +
           files = [

     

       707
       707
       +
             drv1

     

       708
       708
       +
             "${drv2}/path/to/file"

     

       709
       709
       +
           ];

     

       710
       710
       +
           executable = true;

     

       711
       711
       +
           destination = "/bin/my-file";

     

       712
       712
       +
         }

     

       713
       713
       +
         # Writes contents of files to /nix/store/<store path>

     

       714
       714
       +
         concatText

     

       715
       715
       +
         "my-file"

     

       716
       716
       +
         [ file1 file2 ]

     

       705
       717
        
       

     

       706
       706
       -
       # Writes contents of files to /nix/store/<store path>

     

       707
       707
       -
       concatScript "my-file" [ file1 file2 ]

     

       718
       718
       +
         # Writes contents of files to /nix/store/<store path>

     

       719
       719
       +
         concatScript

     

       720
       720
       +
         "my-file"

     

       721
       721
       +
         [

     

       722
       722
       +
           file1

     

       723
       723
       +
           file2

     

       724
       724
       +
         ]

     

       708
       725
        
       ```

     

       709
       726
        
       

     

       710
       727
        
       ## `writeShellApplication` {#trivial-builder-writeShellApplication}

     
···

       722
       739
        
       writeShellApplication {

     

       723
       740
        
         name = "show-nixos-org";

     

       724
       741
        
       

     

       725
       725
       -
         runtimeInputs = [ curl w3m ];

     

       742
       742
       +
         runtimeInputs = [

     

       743
       743
       +
           curl

     

       744
       744
       +
           w3m

     

       745
       745
       +
         ];

     

       726
       746
        
       

     

       727
       747
        
         text = ''

     

       728
       748
        
           curl -s 'https://nixos.org' | w3m -dump -T text/html

     
···

       736
       756
        
       Here is an example:

     

       737
       757
        
       ```nix

     

       738
       758
        
       # adds symlinks of hello and stack to current build and prints "links added"

     

       739
       739
       -
       symlinkJoin { name = "myexample"; paths = [ pkgs.hello pkgs.stack ]; postBuild = "echo links added"; }

     

       759
       759
       +
       symlinkJoin {

     

       760
       760
       +
         name = "myexample";

     

       761
       761
       +
         paths = [

     

       762
       762
       +
           pkgs.hello

     

       763
       763
       +
           pkgs.stack

     

       764
       764
       +
         ];

     

       765
       765
       +
         postBuild = "echo links added";

     

       766
       766
       +
       }

     

       740
       767
        
       ```

     

       741
       768
        
       This creates a derivation with a directory structure like the following:

     

       742
       769
        
       ```

+13 -7

doc/functions/generators.section.md

···

       13
       13
        
           # specifies how to format a key/value pair

     

       14
       14
        
           mkKeyValue = generators.mkKeyValueDefault {

     

       15
       15
        
             # specifies the generated string for a subset of nix values

     

       16
       16
       -
             mkValueString = v:

     

       17
       17
       -
                    if v == true then ''"yes"''

     

       18
       18
       -
               else if v == false then ''"no"''

     

       19
       19
       -
               else if isString v then ''"${v}"''

     

       16
       16
       +
             mkValueString =

     

       17
       17
       +
               v:

     

       18
       18
       +
               if v == true then

     

       19
       19
       +
                 ''"yes"''

     

       20
       20
       +
               else if v == false then

     

       21
       21
       +
                 ''"no"''

     

       22
       22
       +
               else if isString v then

     

       23
       23
       +
                 ''"${v}"''

     

       20
       24
        
               # and delegates all other values to the default generator

     

       21
       21
       -
               else generators.mkValueStringDefault {} v;

     

       25
       25
       +
               else

     

       26
       26
       +
                 generators.mkValueStringDefault { } v;

     

       22
       27
        
           } ":";

     

       23
       28
        
         };

     

       24
       29
        
       

     

       25
       25
       -
       # the INI file can now be given as plain old nix values

     

       26
       26
       -
       in customToINI {

     

       30
       30
       +
         # the INI file can now be given as plain old nix values

     

       31
       31
       +
       in

     

       32
       32
       +
       customToINI {

     

       27
       33
        
         main = {

     

       28
       34
        
           pushinfo = true;

     

       29
       35
        
           autopush = false;

+13 -10

doc/functions/nix-gitignore.section.md

···

       7
       7
        
       `pkgs.nix-gitignore` exports a number of functions, but you'll most likely need either `gitignoreSource` or `gitignoreSourcePure`. As their first argument, they both accept either 1. a file with gitignore lines or 2. a string with gitignore lines, or 3. a list of either of the two. They will be concatenated into a single big string.

     

       8
       8
        
       

     

       9
       9
        
       ```nix

     

       10
       10
       -
       { pkgs ? import <nixpkgs> {} }: {

     

       10
       10
       +
       {

     

       11
       11
       +
         pkgs ? import <nixpkgs> { },

     

       12
       12
       +
       }:

     

       13
       13
       +
       {

     

       11
       14
        
       

     

       12
       12
       -
        src = nix-gitignore.gitignoreSource [] ./source;

     

       13
       13
       -
            # Simplest version

     

       15
       15
       +
         src = nix-gitignore.gitignoreSource [ ] ./source;

     

       16
       16
       +
         # Simplest version

     

       14
       17
        
       

     

       15
       15
       -
        src = nix-gitignore.gitignoreSource "supplemental-ignores\n" ./source;

     

       16
       16
       -
            # This one reads the ./source/.gitignore and concats the auxiliary ignores

     

       18
       18
       +
         src = nix-gitignore.gitignoreSource "supplemental-ignores\n" ./source;

     

       19
       19
       +
         # This one reads the ./source/.gitignore and concats the auxiliary ignores

     

       17
       20
        
       

     

       18
       18
       -
        src = nix-gitignore.gitignoreSourcePure "ignore-this\nignore-that\n" ./source;

     

       19
       19
       -
            # Use this string as gitignore, don't read ./source/.gitignore.

     

       21
       21
       +
         src = nix-gitignore.gitignoreSourcePure "ignore-this\nignore-that\n" ./source;

     

       22
       22
       +
         # Use this string as gitignore, don't read ./source/.gitignore.

     

       20
       23
        
       

     

       21
       21
       -
        src = nix-gitignore.gitignoreSourcePure ["ignore-this\nignore-that\n" ~/.gitignore] ./source;

     

       22
       22
       -
            # It also accepts a list (of strings and paths) that will be concatenated

     

       23
       23
       -
            # once the paths are turned to strings via readFile.

     

       24
       24
       +
         src = nix-gitignore.gitignoreSourcePure [ "ignore-this\nignore-that\n" ~/.gitignore ] ./source;

     

       25
       25
       +
         # It also accepts a list (of strings and paths) that will be concatenated

     

       26
       26
       +
         # once the paths are turned to strings via readFile.

     

       24
       27
        
       }

     

       25
       28
        
       ```

     

       26
       29

+1 -2

doc/functions/prefer-remote-fetch.section.md

···

       3
       3
        
       `prefer-remote-fetch` is an overlay that download sources on remote builder. This is useful when the evaluating machine has a slow upload while the builder can fetch faster directly from the source. To use it, put the following snippet as a new overlay:

     

       4
       4
        
       

     

       5
       5
        
       ```nix

     

       6
       6
       -
       self: super:

     

       7
       7
       -
         (super.prefer-remote-fetch self super)

     

       6
       6
       +
       self: super: (super.prefer-remote-fetch self super)

     

       8
       7
        
       ```

     

       9
       8
        
       

     

       10
       9
        
       A full configuration example for that sets the overlay up for your own account, could look like this

+8 -8

doc/hooks/mpi-check-hook.section.md

···

       11
       11
        
       Example:

     

       12
       12
        
       

     

       13
       13
        
       ```nix

     

       14
       14
       -
         { mpiCheckPhaseHook, mpi, ... }:

     

       15
       15
       -
         {

     

       16
       16
       -
           # ...

     

       14
       14
       +
       { mpiCheckPhaseHook, mpi, ... }:

     

       15
       15
       +
       {

     

       16
       16
       +
         # ...

     

       17
       17
        
       

     

       18
       18
       -
           nativeCheckInputs = [

     

       19
       19
       -
             openssh

     

       20
       20
       -
             mpiCheckPhaseHook

     

       21
       21
       -
           ];

     

       22
       22
       -
         }

     

       18
       18
       +
         nativeCheckInputs = [

     

       19
       19
       +
           openssh

     

       20
       20
       +
           mpiCheckPhaseHook

     

       21
       21
       +
         ];

     

       22
       22
       +
       }

     

       23
       23
        
       ```

     

       24
       24
        
       

     

       25
       25

+12 -2

doc/hooks/patch-rc-path-hooks.section.md

···

       29
       29
        
       patch the init script for users to source without having the above dependencies in their `PATH`:

     

       30
       30
        
       

     

       31
       31
        
       ```nix

     

       32
       32
       -
       { lib, stdenv, patchRcPathFish}:

     

       32
       32
       +
       {

     

       33
       33
       +
         lib,

     

       34
       34
       +
         stdenv,

     

       35
       35
       +
         patchRcPathFish,

     

       36
       36
       +
       }:

     

       33
       37
        
       stdenv.mkDerivation {

     

       34
       38
        
       

     

       35
       39
        
         # ...

     
···

       39
       43
        
         ];

     

       40
       44
        
       

     

       41
       45
        
         postFixup = ''

     

       42
       42
       -
           patchRcPathFish $out/bin/this-foo.fish ${lib.makeBinPath [ coreutils man which ]}

     

       46
       46
       +
           patchRcPathFish $out/bin/this-foo.fish ${

     

       47
       47
       +
             lib.makeBinPath [

     

       48
       48
       +
               coreutils

     

       49
       49
       +
               man

     

       50
       50
       +
               which

     

       51
       51
       +
             ]

     

       52
       52
       +
           }

     

       43
       53
        
         '';

     

       44
       54
        
       }

     

       45
       55
        
       ```

+10 -6

doc/hooks/postgresql-test-hook.section.md

···

       4
       4
        
       This hook starts a PostgreSQL server during the `checkPhase`. Example:

     

       5
       5
        
       

     

       6
       6
        
       ```nix

     

       7
       7
       -
       { stdenv, postgresql, postgresqlTestHook }:

     

       7
       7
       +
       {

     

       8
       8
       +
         stdenv,

     

       9
       9
       +
         postgresql,

     

       10
       10
       +
         postgresqlTestHook,

     

       11
       11
       +
       }:

     

       8
       12
        
       stdenv.mkDerivation {

     

       9
       13
        
       

     

       10
       14
        
         # ...

     
···

       18
       22
        
       

     

       19
       23
        
       If you use a custom `checkPhase`, remember to add the `runHook` calls:

     

       20
       24
        
       ```nix

     

       21
       21
       -
         checkPhase ''

     

       22
       22
       -
           runHook preCheck

     

       25
       25
       +
       checkPhase ''

     

       26
       26
       +
         runHook preCheck

     

       23
       27
        
       

     

       24
       24
       -
           # ... your tests

     

       28
       28
       +
         # ... your tests

     

       25
       29
        
       

     

       26
       26
       -
           runHook postCheck

     

       27
       27
       -
         ''

     

       30
       30
       +
         runHook postCheck

     

       31
       31
       +
       ''

     

       28
       32
        
       ```

     

       29
       33
        
       

     

       30
       34
        
       ## Variables {#sec-postgresqlTestHook-variables}

+7 -2

doc/hooks/redis-test-hook.section.md

···

       7
       7
        
       {

     

       8
       8
        
         stdenv,

     

       9
       9
        
         redis,

     

       10
       10
       -
         redisTestHook

     

       10
       10
       +
         redisTestHook,

     

       11
       11
        
       }:

     

       12
       12
        
       stdenv.mkDerivation {

     

       13
       13
        
       

     
···

       47
       47
        
       Example usage:

     

       48
       48
        
       

     

       49
       49
        
       ```nix

     

       50
       50
       -
       { stdenv, redis, redisTestHook }:

     

       50
       50
       +
       {

     

       51
       51
       +
         stdenv,

     

       52
       52
       +
         redis,

     

       53
       53
       +
         redisTestHook,

     

       54
       54
       +
       }:

     

       51
       55
        
       stdenv.mkDerivation {

     

       52
       56
        
       

     

       53
       57
        
         # ...

     
···

       60
       64
        
           redisTestPort=6390;

     

       61
       65
        
         '';

     

       62
       66
        
       }

     

       67
       67
       +
       ```

+1 -1

doc/hooks/versionCheckHook.section.md

···

       9
       9
        
         lib,

     

       10
       10
        
         stdenv,

     

       11
       11
        
         versionCheckHook,

     

       12
       12
       -
         # ...

     

       12
       12
       +
       # ...

     

       13
       13
        
       }:

     

       14
       14
        
       

     

       15
       15
        
       stdenv.mkDerivation (finalAttrs: {

+4 -3

doc/hooks/zig.section.md

···

       7
       7
        
       ## Example code snippet {#zig-hook-example-code-snippet}

     

       8
       8
        
       

     

       9
       9
        
       ```nix

     

       10
       10
       -
       { lib

     

       11
       11
       -
       , stdenv

     

       12
       12
       -
       , zig

     

       10
       10
       +
       {

     

       11
       11
       +
         lib,

     

       12
       12
       +
         stdenv,

     

       13
       13
       +
         zig,

     

       13
       14
        
       }:

     

       14
       15
        
       

     

       15
       16
        
       stdenv.mkDerivation {

+13 -3

doc/interoperability/cyclonedx.md

···

       63
       63
        
       `nix:fod` properties may be extracted and evaluated to a derivation using code similar to the following, assuming a fictitious function `filterPropertiesToAttrs`:

     

       64
       64
        
       

     

       65
       65
        
       ```nix

     

       66
       66
       -
       { pkgs, filterPropertiesToAttrs, properties }:

     

       66
       66
       +
       {

     

       67
       67
       +
         pkgs,

     

       68
       68
       +
         filterPropertiesToAttrs,

     

       69
       69
       +
         properties,

     

       70
       70
       +
       }:

     

       67
       71
        
       let

     

       68
       72
        
         fodProps = filterPropertiesToAttrs "nix:fod:" properties;

     

       69
       73
        
       

     

       70
       74
        
         methods = {

     

       71
       75
        
           fetchzip =

     

       72
       72
       -
             { name, url, sha256, ... }:

     

       76
       76
       +
             {

     

       77
       77
       +
               name,

     

       78
       78
       +
               url,

     

       79
       79
       +
               sha256,

     

       80
       80
       +
               ...

     

       81
       81
       +
             }:

     

       73
       82
        
             pkgs.fetchzip {

     

       74
       83
        
               inherit name url sha256;

     

       75
       84
        
             };

     

       76
       85
        
         };

     

       77
       86
        
       

     

       78
       78
       -
       in methods.${fodProps.method} fodProps

     

       87
       87
       +
       in

     

       88
       88
       +
       methods.${fodProps.method} fodProps

     

       79
       89
        
       ```

+14 -6

doc/languages-frameworks/agda.section.md

···

       48
       48
        
       agda.withPackages (p: [

     

       49
       49
        
         (p.standard-library.overrideAttrs (oldAttrs: {

     

       50
       50
        
           version = "1.5";

     

       51
       51
       -
           src =  fetchFromGitHub {

     

       51
       51
       +
           src = fetchFromGitHub {

     

       52
       52
        
             repo = "agda-stdlib";

     

       53
       53
        
             owner = "agda";

     

       54
       54
        
             rev = "v1.5";

     
···

       114
       114
        
       

     

       115
       115
        
       ```nix

     

       116
       116
        
       agda.withPackages {

     

       117
       117
       -
         pkgs = [ /* ... */ ];

     

       117
       117
       +
         pkgs = [

     

       118
       118
       +
           # ...

     

       119
       119
       +
         ];

     

       118
       120
        
         ghc = haskell.compiler.ghcHEAD;

     

       119
       121
        
       }

     

       120
       122
        
       ```

     
···

       132
       134
        
       Here is an example `default.nix`

     

       133
       135
        
       

     

       134
       136
        
       ```nix

     

       135
       135
       -
       { nixpkgs ?  <nixpkgs> }:

     

       136
       136
       -
       with (import nixpkgs {});

     

       137
       137
       +
       {

     

       138
       138
       +
         nixpkgs ? <nixpkgs>,

     

       139
       139
       +
       }:

     

       140
       140
       +
       with (import nixpkgs { });

     

       137
       141
        
       agdaPackages.mkDerivation {

     

       138
       142
        
         version = "1.0";

     

       139
       143
        
         pname = "my-agda-lib";

     
···

       179
       183
        
       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:

     

       180
       184
        
       

     

       181
       185
        
       ```nix

     

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

     

       183
       183
       -
       {}

     

       186
       186
       +
       {

     

       187
       187
       +
         mkDerivation,

     

       188
       188
       +
         standard-library,

     

       189
       189
       +
         fetchFromGitHub,

     

       190
       190
       +
       }:

     

       191
       191
       +
       { }

     

       184
       192
        
       ```

     

       185
       193
        
       

     

       186
       194
        
       Note that the derivation function is called with `mkDerivation` set to `agdaPackages.mkDerivation`, therefore you

+24 -16

doc/languages-frameworks/android.section.md

···

       9
       9
        
       

     

       10
       10
        
       ```nix

     

       11
       11
        
       {

     

       12
       12
       -
       buildInputs = [ android-studio-full ];

     

       12
       12
       +
         buildInputs = [ android-studio-full ];

     

       13
       13
        
       }

     

       14
       14
        
       ```

     

       15
       15
        
       

     
···

       17
       17
        
       

     

       18
       18
        
       ```nix

     

       19
       19
        
       {

     

       20
       20
       -
       buildInputs = [ androidStudioPackages.stable.full ];

     

       20
       20
       +
         buildInputs = [ androidStudioPackages.stable.full ];

     

       21
       21
        
       }

     

       22
       22
        
       ```

     

       23
       23
        
       

     
···

       25
       25
        
       

     

       26
       26
        
       ```nix

     

       27
       27
        
       {

     

       28
       28
       -
       buildInputs = [

     

       29
       29
       -
         (android-studio.withSdk (androidenv.composeAndroidPackages {

     

       30
       30
       -
           includeNDK = true;

     

       31
       31
       -
         }).androidsdk)

     

       32
       32
       -
       ];

     

       28
       28
       +
         buildInputs = [

     

       29
       29
       +
           (android-studio.withSdk

     

       30
       30
       +
             (androidenv.composeAndroidPackages {

     

       31
       31
       +
               includeNDK = true;

     

       32
       32
       +
             }).androidsdk

     

       33
       33
       +
           )

     

       34
       34
       +
         ];

     

       33
       35
        
       }

     

       34
       36
        
       ```

     

       35
       37
        
       

     
···

       41
       43
        
       Alternatively, you can deploy the SDK separately with a desired set of plugins, or subsets of an SDK.

     

       42
       44
        
       

     

       43
       45
        
       ```nix

     

       44
       44
       -
       with import <nixpkgs> {};

     

       46
       46
       +
       with import <nixpkgs> { };

     

       45
       47
        
       

     

       46
       48
        
       let

     

       47
       49
        
         androidComposition = androidenv.composeAndroidPackages {

     

       48
       48
       -
           platformVersions = [ "34" "35" ];

     

       50
       50
       +
           platformVersions = [

     

       51
       51
       +
             "34"

     

       52
       52
       +
             "35"

     

       53
       53
       +
           ];

     

       49
       54
        
           systemImageTypes = [ "google_apis_playstore" ];

     

       50
       50
       -
           abiVersions = [ "armeabi-v7a" "arm64-v8a" ];

     

       55
       55
       +
           abiVersions = [

     

       56
       56
       +
             "armeabi-v7a"

     

       57
       57
       +
             "arm64-v8a"

     

       58
       58
       +
           ];

     

       51
       59
        
           includeNDK = true;

     

       52
       60
        
           includeExtras = [

     

       53
       61
        
             "extras;google;auto"

     
···

       171
       179
        
       `platform-tools` package, you can evaluate the following expression:

     

       172
       180
        
       

     

       173
       181
        
       ```nix

     

       174
       174
       -
       with import <nixpkgs> {};

     

       182
       182
       +
       with import <nixpkgs> { };

     

       175
       183
        
       

     

       176
       184
        
       let

     

       177
       185
        
         androidComposition = androidenv.composeAndroidPackages {

     
···

       189
       197
        
       The following Nix expression can be used to deploy the entire SDK:

     

       190
       198
        
       

     

       191
       199
        
       ```nix

     

       192
       192
       -
       with import <nixpkgs> {};

     

       200
       200
       +
       with import <nixpkgs> { };

     

       193
       201
        
       

     

       194
       202
        
       androidenv.androidPkgs.androidsdk

     

       195
       203
        
       ```

     
···

       197
       205
        
       It is also possible to use one plugin only:

     

       198
       206
        
       

     

       199
       207
        
       ```nix

     

       200
       200
       -
       with import <nixpkgs> {};

     

       208
       208
       +
       with import <nixpkgs> { };

     

       201
       209
        
       

     

       202
       210
        
       androidenv.androidPkgs.platform-tools

     

       203
       211
        
       ```

     
···

       211
       219
        
       function:

     

       212
       220
        
       

     

       213
       221
        
       ```nix

     

       214
       214
       -
       with import <nixpkgs> {};

     

       222
       222
       +
       with import <nixpkgs> { };

     

       215
       223
        
       

     

       216
       224
        
       androidenv.emulateApp {

     

       217
       225
        
         name = "emulate-MyAndroidApp";

     
···

       227
       235
        
       and the package and activity names to launch it:

     

       228
       236
        
       

     

       229
       237
        
       ```nix

     

       230
       230
       -
       with import <nixpkgs> {};

     

       238
       238
       +
       with import <nixpkgs> { };

     

       231
       239
        
       

     

       232
       240
        
       androidenv.emulateApp {

     

       233
       241
        
         name = "emulate-MyAndroidApp";

     
···

       350
       358
        
       purposes.

     

       351
       359
        
       

     

       352
       360
        
       ```nix

     

       353
       353
       -
       with import <nixpkgs> {};

     

       361
       361
       +
       with import <nixpkgs> { };

     

       354
       362
        
       

     

       355
       363
        
       androidenv.buildApp {

     

       356
       364
        
         name = "MyAndroidApp";

+67 -33

doc/languages-frameworks/beam.section.md

···

       60
       60
        
       

     

       61
       61
        
       ```nix

     

       62
       62
        
       let

     

       63
       63
       -
         pkgs = import <nixpkgs> { config = {}; overlays = []; };

     

       63
       63
       +
         pkgs = import <nixpkgs> {

     

       64
       64
       +
           config = { };

     

       65
       65
       +
           overlays = [ ];

     

       66
       66
       +
         };

     

       64
       67
        
       in

     

       65
       68
        
       pkgs.mkShell {

     

       66
       69
        
         packages = [ pkgs.beamPackages.rebar3 ];

     
···

       120
       123
        
       {

     

       121
       124
        
         mixNixDeps = import ./mix.nix {

     

       122
       125
        
           inherit beamPackages lib;

     

       123
       123
       -
           overrides = (final: prev: {

     

       124
       124
       -
             # mix2nix does not support git dependencies yet,

     

       125
       125
       -
             # so we need to add them manually

     

       126
       126
       -
             prometheus_ex = beamPackages.buildMix rec {

     

       127
       127
       -
               name = "prometheus_ex";

     

       128
       128
       -
               version = "3.0.5";

     

       126
       126
       +
           overrides = (

     

       127
       127
       +
             final: prev: {

     

       128
       128
       +
               # mix2nix does not support git dependencies yet,

     

       129
       129
       +
               # so we need to add them manually

     

       130
       130
       +
               prometheus_ex = beamPackages.buildMix rec {

     

       131
       131
       +
                 name = "prometheus_ex";

     

       132
       132
       +
                 version = "3.0.5";

     

       129
       133
        
       

     

       130
       130
       -
               # Change the argument src with the git src that you actually need

     

       131
       131
       -
               src = fetchFromGitLab {

     

       132
       132
       -
                 domain = "git.pleroma.social";

     

       133
       133
       -
                 group = "pleroma";

     

       134
       134
       -
                 owner = "elixir-libraries";

     

       135
       135
       -
                 repo = "prometheus.ex";

     

       136
       136
       -
                 rev = "a4e9beb3c1c479d14b352fd9d6dd7b1f6d7deee5";

     

       137
       137
       -
                 hash = "sha256-U17LlN6aGUKUFnT4XyYXppRN+TvUBIBRHEUsfeIiGOw=";

     

       134
       134
       +
                 # Change the argument src with the git src that you actually need

     

       135
       135
       +
                 src = fetchFromGitLab {

     

       136
       136
       +
                   domain = "git.pleroma.social";

     

       137
       137
       +
                   group = "pleroma";

     

       138
       138
       +
                   owner = "elixir-libraries";

     

       139
       139
       +
                   repo = "prometheus.ex";

     

       140
       140
       +
                   rev = "a4e9beb3c1c479d14b352fd9d6dd7b1f6d7deee5";

     

       141
       141
       +
                   hash = "sha256-U17LlN6aGUKUFnT4XyYXppRN+TvUBIBRHEUsfeIiGOw=";

     

       142
       142
       +
                 };

     

       143
       143
       +
                 # you can re-use the same beamDeps argument as generated

     

       144
       144
       +
                 beamDeps = with final; [ prometheus ];

     

       138
       145
        
               };

     

       139
       139
       -
               # you can re-use the same beamDeps argument as generated

     

       140
       140
       -
               beamDeps = with final; [ prometheus ];

     

       141
       141
       -
             };

     

       142
       142
       -
           });

     

       146
       146
       +
             }

     

       147
       147
       +
           );

     

       143
       148
        
         };

     

       144
       149
        
       }

     

       145
       150
        
       ```

     
···

       195
       200
        
           hash = lib.fakeHash;

     

       196
       201
        
           mixEnv = ""; # default is "prod", when empty includes all dependencies, such as "dev", "test".

     

       197
       202
        
           # if you have build time environment variables add them here

     

       198
       198
       -
           MY_ENV_VAR="my_value";

     

       203
       203
       +
           MY_ENV_VAR = "my_value";

     

       199
       204
        
         };

     

       200
       205
        
       

     

       201
       206
        
         nodeDependencies = (pkgs.callPackage ./assets/default.nix { }).shell.nodeDependencies;

     

       202
       207
        
       

     

       203
       203
       -
       in packages.mixRelease {

     

       204
       204
       -
         inherit src pname version mixFodDeps;

     

       208
       208
       +
       in

     

       209
       209
       +
       packages.mixRelease {

     

       210
       210
       +
         inherit

     

       211
       211
       +
           src

     

       212
       212
       +
           pname

     

       213
       213
       +
           version

     

       214
       214
       +
           mixFodDeps

     

       215
       215
       +
           ;

     

       205
       216
        
         # if you have build time environment variables add them here

     

       206
       206
       -
         MY_ENV_VAR="my_value";

     

       217
       217
       +
         MY_ENV_VAR = "my_value";

     

       207
       218
        
       

     

       208
       219
        
         postBuild = ''

     

       209
       220
        
           ln -sf ${nodeDependencies}/lib/node_modules assets/node_modules

     
···

       231
       242
        
       in your project with the following

     

       232
       243
        
       

     

       233
       244
        
       ```nix

     

       234
       234
       -
       {config, pkgs, lib, ...}:

     

       245
       245
       +
       {

     

       246
       246
       +
         config,

     

       247
       247
       +
         pkgs,

     

       248
       248
       +
         lib,

     

       249
       249
       +
         ...

     

       250
       250
       +
       }:

     

       235
       251
        
       

     

       236
       252
        
       let

     

       237
       253
        
         release = pkgs.callPackage ./default.nix;

     
···

       241
       257
        
       {

     

       242
       258
        
         systemd.services.${release_name} = {

     

       243
       259
        
           wantedBy = [ "multi-user.target" ];

     

       244
       244
       -
           after = [ "network.target" "postgresql.service" ];

     

       260
       260
       +
           after = [

     

       261
       261
       +
             "network.target"

     

       262
       262
       +
             "postgresql.service"

     

       263
       263
       +
           ];

     

       245
       264
        
           # note that if you are connecting to a postgres instance on a different host

     

       246
       265
        
           # postgresql.service should not be included in the requires.

     

       247
       247
       -
           requires = [ "network-online.target" "postgresql.service" ];

     

       266
       266
       +
           requires = [

     

       267
       267
       +
             "network-online.target"

     

       268
       268
       +
             "postgresql.service"

     

       269
       269
       +
           ];

     

       248
       270
        
           description = "my app";

     

       249
       271
        
           environment = {

     

       250
       272
        
             # RELEASE_TMP is used to write the state of the

     
···

       292
       314
        
       Usually, we need to create a `shell.nix` file and do our development inside of the environment specified therein. Just install your version of Erlang and any other interpreters, and then use your normal build tools. As an example with Elixir:

     

       293
       315
        
       

     

       294
       316
        
       ```nix

     

       295
       295
       -
       { pkgs ? import <nixpkgs> {} }:

     

       317
       317
       +
       {

     

       318
       318
       +
         pkgs ? import <nixpkgs> { },

     

       319
       319
       +
       }:

     

       296
       320
        
       

     

       297
       321
        
       with pkgs;

     

       298
       322
        
       let

     
···

       311
       335
        
       

     

       312
       336
        
       ```nix

     

       313
       337
        
       let

     

       314
       314
       -
         elixir_1_18_1_overlay = (self: super: {

     

       338
       338
       +
         elixir_1_18_1_overlay = (

     

       339
       339
       +
           self: super: {

     

       315
       340
        
             elixir_1_18 = super.elixir_1_18.override {

     

       316
       341
        
               version = "1.18.1";

     

       317
       342
        
               sha256 = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";

     

       318
       343
        
             };

     

       319
       319
       -
           });

     

       344
       344
       +
           }

     

       345
       345
       +
         );

     

       320
       346
        
         pkgs = import <nixpkgs> { overlays = [ elixir_1_18_1_overlay ]; };

     

       321
       347
        
       in

     

       322
       348
        
       with pkgs;

     
···

       349
       375
        
           nodePackages.prettier

     

       350
       376
        
         ];

     

       351
       377
        
       

     

       352
       352
       -
         inputs = basePackages ++ lib.optionals stdenv.hostPlatform.isLinux [ inotify-tools ]

     

       353
       353
       -
           ++ lib.optionals stdenv.hostPlatform.isDarwin

     

       354
       354
       -
           (with darwin.apple_sdk.frameworks; [ CoreFoundation CoreServices ]);

     

       378
       378
       +
         inputs =

     

       379
       379
       +
           basePackages

     

       380
       380
       +
           ++ lib.optionals stdenv.hostPlatform.isLinux [ inotify-tools ]

     

       381
       381
       +
           ++ lib.optionals stdenv.hostPlatform.isDarwin (

     

       382
       382
       +
             with darwin.apple_sdk.frameworks;

     

       383
       383
       +
             [

     

       384
       384
       +
               CoreFoundation

     

       385
       385
       +
               CoreServices

     

       386
       386
       +
             ]

     

       387
       387
       +
           );

     

       355
       388
        
       

     

       356
       389
        
         # define shell startup command

     

       357
       390
        
         hooks = ''

     
···

       380
       413
        
           export ENV_VAR="your_env_var"

     

       381
       414
        
         '';

     

       382
       415
        
       

     

       383
       383
       -
       in mkShell {

     

       416
       416
       +
       in

     

       417
       417
       +
       mkShell {

     

       384
       418
        
         buildInputs = inputs;

     

       385
       419
        
         shellHook = hooks;

     

       386
       420
        
       }

+17 -8

doc/languages-frameworks/bower.section.md

···

       24
       24
        
       

     

       25
       25
        
       ```nix

     

       26
       26
        
       { fetchbower, buildEnv }:

     

       27
       27
       -
       buildEnv { name = "bower-env"; ignoreCollisions = true; paths = [

     

       28
       28
       -
         (fetchbower "angular" "1.5.3" "~1.5.0" "1749xb0firxdra4rzadm4q9x90v6pzkbd7xmcyjk6qfza09ykk9y")

     

       29
       29
       -
         (fetchbower "bootstrap" "3.3.6" "~3.3.6" "1vvqlpbfcy0k5pncfjaiskj3y6scwifxygfqnw393sjfxiviwmbv")

     

       30
       30
       -
         (fetchbower "jquery" "2.2.2" "1.9.1 - 2" "10sp5h98sqwk90y4k6hbdviwqzvzwqf47r3r51pakch5ii2y7js1")

     

       31
       31
       -
       ]; }

     

       27
       27
       +
       buildEnv {

     

       28
       28
       +
         name = "bower-env";

     

       29
       29
       +
         ignoreCollisions = true;

     

       30
       30
       +
         paths = [

     

       31
       31
       +
           (fetchbower "angular" "1.5.3" "~1.5.0" "1749xb0firxdra4rzadm4q9x90v6pzkbd7xmcyjk6qfza09ykk9y")

     

       32
       32
       +
           (fetchbower "bootstrap" "3.3.6" "~3.3.6" "1vvqlpbfcy0k5pncfjaiskj3y6scwifxygfqnw393sjfxiviwmbv")

     

       33
       33
       +
           (fetchbower "jquery" "2.2.2" "1.9.1 - 2" "10sp5h98sqwk90y4k6hbdviwqzvzwqf47r3r51pakch5ii2y7js1")

     

       34
       34
       +
         ];

     

       35
       35
       +
       }

     

       32
       36
        
       ```

     

       33
       37
        
       

     

       34
       38
        
       Using the `bower2nix` command line arguments, the output can be redirected to a file. A name like `bower-packages.nix` would be fine.

     
···

       80
       84
        
       ### Example Full example — default.nix {#ex-buildBowerComponentsDefaultNix}

     

       81
       85
        
       

     

       82
       86
        
       ```nix

     

       83
       83
       -
       { myWebApp ? { outPath = ./.; name = "myWebApp"; }

     

       84
       84
       -
       , pkgs ? import <nixpkgs> {}

     

       87
       87
       +
       {

     

       88
       88
       +
         myWebApp ? {

     

       89
       89
       +
           outPath = ./.;

     

       90
       90
       +
           name = "myWebApp";

     

       91
       91
       +
         },

     

       92
       92
       +
         pkgs ? import <nixpkgs> { },

     

       85
       93
        
       }:

     

       86
       94
        
       

     

       87
       95
        
       pkgs.stdenv.mkDerivation {

     
···

       90
       98
        
       

     

       91
       99
        
         buildInputs = [ pkgs.nodePackages.gulp ];

     

       92
       100
        
       

     

       93
       93
       -
         bowerComponents = pkgs.buildBowerComponents { # note 1

     

       101
       101
       +
         bowerComponents = pkgs.buildBowerComponents {

     

       102
       102
       +
           # note 1

     

       94
       103
        
           name = "my-web-app";

     

       95
       104
        
           generated = ./bower-packages.nix;

     

       96
       105
        
           src = myWebApp;

+12 -8

doc/languages-frameworks/chicken.section.md

···

       60
       60
        
       

     

       61
       61
        
       ```nix

     

       62
       62
        
       let

     

       63
       63
       -
         myChickenPackages = pkgs.chickenPackages.overrideScope (self: super: {

     

       63
       63
       +
         myChickenPackages = pkgs.chickenPackages.overrideScope (

     

       64
       64
       +
           self: super: {

     

       64
       65
        
             # The chicken package itself can be overridden to effect the whole ecosystem.

     

       65
       66
        
             # chicken = super.chicken.overrideAttrs {

     

       66
       67
        
             #   src = ...

     

       67
       68
        
             # };

     

       68
       69
        
       

     

       69
       69
       -
             chickenEggs = super.chickenEggs.overrideScope (eggself: eggsuper: {

     

       70
       70
       -
               srfi-180 = eggsuper.srfi-180.overrideAttrs {

     

       71
       71
       -
                 # path to a local copy of srfi-180

     

       72
       72
       -
                 src = <...>;

     

       73
       73
       -
               };

     

       74
       74
       -
             });

     

       75
       75
       -
         });

     

       70
       70
       +
             chickenEggs = super.chickenEggs.overrideScope (

     

       71
       71
       +
               eggself: eggsuper: {

     

       72
       72
       +
                 srfi-180 = eggsuper.srfi-180.overrideAttrs {

     

       73
       73
       +
                   # path to a local copy of srfi-180

     

       74
       74
       +
                   src = <...>;

     

       75
       75
       +
                 };

     

       76
       76
       +
               }

     

       77
       77
       +
             );

     

       78
       78
       +
           }

     

       79
       79
       +
         );

     

       76
       80
        
       in

     

       77
       81
        
       # Here, `myChickenPackages.chickenEggs.json-rpc`, which depends on `srfi-180` will use

     

       78
       82
        
       # the local copy of `srfi-180`.

+70 -27

doc/languages-frameworks/coq.section.md

···

       54
       54
        
       Here is a simple package example. It is a pure Coq library, thus it depends on Coq. It builds on the Mathematical Components library, thus it also takes some `mathcomp` derivations as `extraBuildInputs`.

     

       55
       55
        
       

     

       56
       56
        
       ```nix

     

       57
       57
       -
       { lib, mkCoqDerivation, version ? null

     

       58
       58
       -
       , coq, mathcomp, mathcomp-finmap, mathcomp-bigenough }:

     

       57
       57
       +
       {

     

       58
       58
       +
         lib,

     

       59
       59
       +
         mkCoqDerivation,

     

       60
       60
       +
         version ? null,

     

       61
       61
       +
         coq,

     

       62
       62
       +
         mathcomp,

     

       63
       63
       +
         mathcomp-finmap,

     

       64
       64
       +
         mathcomp-bigenough,

     

       65
       65
       +
       }:

     

       59
       66
        
       

     

       60
       67
        
       mkCoqDerivation {

     

       61
       61
       -
         /* namePrefix leads to e.g. `name = coq8.11-mathcomp1.11-multinomials-1.5.2` */

     

       62
       62
       -
         namePrefix = [ "coq" "mathcomp" ];

     

       68
       68
       +
         # namePrefix leads to e.g. `name = coq8.11-mathcomp1.11-multinomials-1.5.2`

     

       69
       69
       +
         namePrefix = [

     

       70
       70
       +
           "coq"

     

       71
       71
       +
           "mathcomp"

     

       72
       72
       +
         ];

     

       63
       73
        
         pname = "multinomials";

     

       64
       74
        
         owner = "math-comp";

     

       65
       75
        
         inherit version;

     

       66
       66
       -
         defaultVersion = with lib.versions; lib.switch [ coq.version mathcomp.version ] [

     

       67
       67
       -
             { cases = [ (range "8.7" "8.12") (isEq "1.11") ];        out = "1.5.2"; }

     

       68
       68
       -
             { cases = [ (range "8.7" "8.11") (range "1.8" "1.10") ]; out = "1.5.0"; }

     

       69
       69
       -
             { cases = [ (range "8.7" "8.10") (range "1.8" "1.10") ]; out = "1.4"; }

     

       70
       70
       -
             { cases = [ (isEq "8.6")         (range "1.6" "1.7") ];  out = "1.1"; }

     

       71
       71
       -
           ] null;

     

       76
       76
       +
         defaultVersion =

     

       77
       77
       +
           with lib.versions;

     

       78
       78
       +
           lib.switch

     

       79
       79
       +
             [ coq.version mathcomp.version ]

     

       80
       80
       +
             [

     

       81
       81
       +
               {

     

       82
       82
       +
                 cases = [

     

       83
       83
       +
                   (range "8.7" "8.12")

     

       84
       84
       +
                   (isEq "1.11")

     

       85
       85
       +
                 ];

     

       86
       86
       +
                 out = "1.5.2";

     

       87
       87
       +
               }

     

       88
       88
       +
               {

     

       89
       89
       +
                 cases = [

     

       90
       90
       +
                   (range "8.7" "8.11")

     

       91
       91
       +
                   (range "1.8" "1.10")

     

       92
       92
       +
                 ];

     

       93
       93
       +
                 out = "1.5.0";

     

       94
       94
       +
               }

     

       95
       95
       +
               {

     

       96
       96
       +
                 cases = [

     

       97
       97
       +
                   (range "8.7" "8.10")

     

       98
       98
       +
                   (range "1.8" "1.10")

     

       99
       99
       +
                 ];

     

       100
       100
       +
                 out = "1.4";

     

       101
       101
       +
               }

     

       102
       102
       +
               {

     

       103
       103
       +
                 cases = [

     

       104
       104
       +
                   (isEq "8.6")

     

       105
       105
       +
                   (range "1.6" "1.7")

     

       106
       106
       +
                 ];

     

       107
       107
       +
                 out = "1.1";

     

       108
       108
       +
               }

     

       109
       109
       +
             ]

     

       110
       110
       +
             null;

     

       72
       111
        
         release = {

     

       73
       112
        
           "1.5.2".hash = "sha256-mjCx9XKa38Nz9E6wNK7YSqHdJ7YTua5fD3d6J4e7WpU=";

     

       74
       113
        
           "1.5.1".hash = "sha256-Q8tm0y2FQAt2V1kZYkDlHWRia/lTvXAMVjdmzEV11I4=";

     

       75
       114
        
           "1.5.0".hash = "sha256-HIK0f21G69oEW8JG46gSBde/Q2LR3GiBCv680gHbmRg=";

     

       76
       76
       -
           "1.5.0".rev  = "1.5";

     

       77
       77
       -
           "1.4".hash   = "sha256-F9g3MSIr3B6UZ3p8QWjz3/Jpw9sudJ+KRlvjiHSO024=";

     

       78
       78
       -
           "1.3".hash   = "sha256-BPJTlAL0ETHvLMBslE0KFVt3DNoaGuMrHt2SBGyJe1A=";

     

       79
       79
       -
           "1.2".hash   = "sha256-mHXBXSLYO4BN+jfN50y/+XCx0Qq5g4Ac2Y/qlsbgAdY=";

     

       80
       80
       -
           "1.1".hash   = "sha256-ejAsMQbB/LtU9j+g160VdGXULrCe9s0gBWzyhKqmCuE=";

     

       81
       81
       -
           "1.0".hash   = "sha256-tZTOltEBBKWciDxDMs/Ye4Jnq/33CANrHJ4FBMPtq+I=";

     

       115
       115
       +
           "1.5.0".rev = "1.5";

     

       116
       116
       +
           "1.4".hash = "sha256-F9g3MSIr3B6UZ3p8QWjz3/Jpw9sudJ+KRlvjiHSO024=";

     

       117
       117
       +
           "1.3".hash = "sha256-BPJTlAL0ETHvLMBslE0KFVt3DNoaGuMrHt2SBGyJe1A=";

     

       118
       118
       +
           "1.2".hash = "sha256-mHXBXSLYO4BN+jfN50y/+XCx0Qq5g4Ac2Y/qlsbgAdY=";

     

       119
       119
       +
           "1.1".hash = "sha256-ejAsMQbB/LtU9j+g160VdGXULrCe9s0gBWzyhKqmCuE=";

     

       120
       120
       +
           "1.0".hash = "sha256-tZTOltEBBKWciDxDMs/Ye4Jnq/33CANrHJ4FBMPtq+I=";

     

       82
       121
        
         };

     

       83
       122
        
       

     

       84
       84
       -
         propagatedBuildInputs =

     

       85
       85
       -
           [ mathcomp.ssreflect mathcomp.algebra mathcomp-finmap mathcomp-bigenough ];

     

       123
       123
       +
         propagatedBuildInputs = [

     

       124
       124
       +
           mathcomp.ssreflect

     

       125
       125
       +
           mathcomp.algebra

     

       126
       126
       +
           mathcomp-finmap

     

       127
       127
       +
           mathcomp-bigenough

     

       128
       128
       +
         ];

     

       86
       129
        
       

     

       87
       130
        
         meta = {

     

       88
       131
        
           description = "Coq/SSReflect Library for Monoidal Rings and Multinomials";

     
···

       124
       167
        
       For example, here is how you could locally add a new release of the `multinomials` library, and set the `defaultVersion` to use this release:

     

       125
       168
        
       

     

       126
       169
        
       ```nix

     

       127
       127
       -
       coqPackages.lib.overrideCoqDerivation

     

       128
       128
       -
         {

     

       129
       129
       -
           defaultVersion = "2.0";

     

       130
       130
       -
           release."2.0".hash = "sha256-czoP11rtrIM7+OLdMisv2EF7n/IbGuwFxHiPtg3qCNM=";

     

       131
       131
       -
         }

     

       132
       132
       -
         coqPackages.multinomials

     

       170
       170
       +
       coqPackages.lib.overrideCoqDerivation {

     

       171
       171
       +
         defaultVersion = "2.0";

     

       172
       172
       +
         release."2.0".hash = "sha256-czoP11rtrIM7+OLdMisv2EF7n/IbGuwFxHiPtg3qCNM=";

     

       173
       173
       +
       } coqPackages.multinomials

     

       133
       174
        
       ```

     

       134
       175
        
       

     

       135
       176
        
       ### `.overrideAttrs` {#coq-overrideAttrs}

     
···

       140
       181
        
       

     

       141
       182
        
       ```nix

     

       142
       183
        
       coqPackages.multinomials.overrideAttrs (oldAttrs: {

     

       143
       143
       -
         postInstall = oldAttrs.postInstall or "" + ''

     

       144
       144
       -
           echo "you can do anything you want here"

     

       145
       145
       -
         '';

     

       184
       184
       +
         postInstall =

     

       185
       185
       +
           oldAttrs.postInstall or ""

     

       186
       186
       +
           + ''

     

       187
       187
       +
             echo "you can do anything you want here"

     

       188
       188
       +
           '';

     

       146
       189
        
       })

     

       147
       190
        
       ```

+6 -3

doc/languages-frameworks/crystal.section.md

···

       18
       18
        
       Next create a Nix file for your derivation and use `pkgs.crystal.buildCrystalPackage` as follows:

     

       19
       19
        
       

     

       20
       20
        
       ```nix

     

       21
       21
       -
       with import <nixpkgs> {};

     

       21
       21
       +
       with import <nixpkgs> { };

     

       22
       22
        
       crystal.buildCrystalPackage rec {

     

       23
       23
        
         pname = "mint";

     

       24
       24
        
         version = "0.5.0";

     
···

       51
       51
        
       

     

       52
       52
        
       ```nix

     

       53
       53
        
       {

     

       54
       54
       -
         crystalBinaries.mint.options = [ "--release" "--verbose" ];

     

       54
       54
       +
         crystalBinaries.mint.options = [

     

       55
       55
       +
           "--release"

     

       56
       56
       +
           "--verbose"

     

       57
       57
       +
         ];

     

       55
       58
        
       }

     

       56
       59
        
       ```

     

       57
       60
        
       

     

       58
       61
        
       Depending on the project, you might need additional steps to get it to compile successfully. In Mint's case, we need to link against openssl, so in the end the Nix file looks as follows:

     

       59
       62
        
       

     

       60
       63
        
       ```nix

     

       61
       61
       -
       with import <nixpkgs> {};

     

       64
       64
       +
       with import <nixpkgs> { };

     

       62
       65
        
       crystal.buildCrystalPackage rec {

     

       63
       66
        
         version = "0.5.0";

     

       64
       67
        
         pname = "mint";

+16 -10

doc/languages-frameworks/cuda.section.md

···

       12
       12
        
       

     

       13
       13
        
       To use one or more CUDA packages in an expression, give the expression a `cudaPackages` parameter, and in case CUDA is optional

     

       14
       14
        
       ```nix

     

       15
       15
       -
       { config

     

       16
       16
       -
       , cudaSupport ? config.cudaSupport

     

       17
       17
       -
       , cudaPackages ? { }

     

       18
       18
       -
       , ...

     

       19
       19
       -
       }: {}

     

       15
       15
       +
       {

     

       16
       16
       +
         config,

     

       17
       17
       +
         cudaSupport ? config.cudaSupport,

     

       18
       18
       +
         cudaPackages ? { },

     

       19
       19
       +
         ...

     

       20
       20
       +
       }:

     

       21
       21
       +
       { }

     

       20
       22
        
       ```

     

       21
       23
        
       

     

       22
       24
        
       When using `callPackage`, you can choose to pass in a different variant, e.g.

     
···

       32
       34
        
       set.

     

       33
       35
        
       ```nix

     

       34
       36
        
       {

     

       35
       35
       -
         mypkg = let

     

       36
       36
       -
           cudaPackages = cudaPackages_11_5.overrideScope (final: prev: {

     

       37
       37
       -
             cudnn = prev.cudnn_8_3;

     

       38
       38
       -
           });

     

       39
       39
       -
         in callPackage { inherit cudaPackages; };

     

       37
       37
       +
         mypkg =

     

       38
       38
       +
           let

     

       39
       39
       +
             cudaPackages = cudaPackages_11_5.overrideScope (

     

       40
       40
       +
               final: prev: {

     

       41
       41
       +
                 cudnn = prev.cudnn_8_3;

     

       42
       42
       +
               }

     

       43
       43
       +
             );

     

       44
       44
       +
           in

     

       45
       45
       +
           callPackage { inherit cudaPackages; };

     

       40
       46
        
       }

     

       41
       47
        
       ```

     

       42
       48

+12 -14

doc/languages-frameworks/cuelang.section.md

···

       27
       27
        
       

     

       28
       28
        
       Here is an example:

     

       29
       29
        
       ```nix

     

       30
       30
       -
       pkgs.writeCueValidator

     

       31
       31
       -
         (pkgs.writeText "schema.cue" ''

     

       32
       32
       -
           #Def1: {

     

       33
       33
       -
             field1: string

     

       34
       34
       -
           }

     

       35
       35
       -
         '')

     

       36
       36
       -
         { document = "#Def1"; }

     

       30
       30
       +
       pkgs.writeCueValidator (pkgs.writeText "schema.cue" ''

     

       31
       31
       +
         #Def1: {

     

       32
       32
       +
           field1: string

     

       33
       33
       +
         }

     

       34
       34
       +
       '') { document = "#Def1"; }

     

       37
       35
        
       ```

     

       38
       36
        
       

     

       39
       37
        
       - The first parameter is the Cue schema file.

     
···

       43
       41
        
       

     

       44
       42
        
       Another example, given the following `validator.nix` :

     

       45
       43
        
       ```nix

     

       46
       46
       -
       { pkgs ? import <nixpkgs> {} }:

     

       44
       44
       +
       {

     

       45
       45
       +
         pkgs ? import <nixpkgs> { },

     

       46
       46
       +
       }:

     

       47
       47
        
       let

     

       48
       48
       -
         genericValidator = version:

     

       49
       49
       -
         pkgs.writeCueValidator

     

       50
       50
       -
           (pkgs.writeText "schema.cue" ''

     

       48
       48
       +
         genericValidator =

     

       49
       49
       +
           version:

     

       50
       50
       +
           pkgs.writeCueValidator (pkgs.writeText "schema.cue" ''

     

       51
       51
        
             #Version1: {

     

       52
       52
        
               field1: string

     

       53
       53
        
             }

     

       54
       54
        
             #Version2: #Version1 & {

     

       55
       55
        
               field1: "unused"

     

       56
       56
       -
             }''

     

       57
       57
       -
           )

     

       58
       58
       -
           { document = "#Version${toString version}"; };

     

       56
       56
       +
             }'') { document = "#Version${toString version}"; };

     

       59
       57
        
       in

     

       60
       58
        
       {

     

       61
       59
        
         validateV1 = genericValidator 1;

+6 -2

doc/languages-frameworks/dart.section.md

···

       30
       30
        
       Dart supports multiple [outputs types](https://dart.dev/tools/dart-compile#types-of-output), you can choose between them using `dartOutputType` (defaults to `exe`). If you want to override the binaries path or the source path they come from, you can use `dartEntryPoints`. Outputs that require a runtime will automatically be wrapped with the relevant runtime (`dartaotruntime` for `aot-snapshot`, `dart run` for `jit-snapshot` and `kernel`, `node` for `js`), this can be overridden through `dartRuntimeCommand`.

     

       31
       31
        
       

     

       32
       32
        
       ```nix

     

       33
       33
       -
       { lib, buildDartApplication, fetchFromGitHub }:

     

       33
       33
       +
       {

     

       34
       34
       +
         lib,

     

       35
       35
       +
         buildDartApplication,

     

       36
       36
       +
         fetchFromGitHub,

     

       37
       37
       +
       }:

     

       34
       38
        
       

     

       35
       39
        
       buildDartApplication rec {

     

       36
       40
        
         pname = "dart-sass";

     
···

       101
       105
        
       `flutter` in Nixpkgs always points to `flutterPackages.stable`, which is the latest packaged version. To avoid unforeseen breakage during upgrade, packages in Nixpkgs should use a specific flutter version, such as `flutter319` and `flutter322`, instead of using `flutter` directly.

     

       102
       106
        
       

     

       103
       107
        
       ```nix

     

       104
       104
       -
       {  flutter322, fetchFromGitHub }:

     

       108
       108
       +
       { flutter322, fetchFromGitHub }:

     

       105
       109
        
       

     

       106
       110
        
       flutter322.buildFlutterApplication {

     

       107
       111
        
         pname = "firmware-updater";

+8 -7

doc/languages-frameworks/dhall.section.md

···

       90
       90
        
       

     

       91
       91
        
       let

     

       92
       92
        
         nixpkgs = builtins.fetchTarball {

     

       93
       93
       -
           url    = "https://github.com/NixOS/nixpkgs/archive/94b2848559b12a8ed1fe433084686b2a81123c99.tar.gz";

     

       93
       93
       +
           url = "https://github.com/NixOS/nixpkgs/archive/94b2848559b12a8ed1fe433084686b2a81123c99.tar.gz";

     

       94
       94
        
           hash = "sha256-B4Q3c6IvTLg3Q92qYa8y+i4uTaphtFdjp+Ir3QQjdN0=";

     

       95
       95
        
         };

     

       96
       96
        
       

     
···

       100
       100
        
       

     

       101
       101
        
         overlay = self: super: {

     

       102
       102
        
           dhallPackages = super.dhallPackages.override (old: {

     

       103
       103
       -
             overrides =

     

       104
       104
       -
               self.lib.composeExtensions (old.overrides or (_: _: {})) dhallOverlay;

     

       103
       103
       +
             overrides = self.lib.composeExtensions (old.overrides or (_: _: { })) dhallOverlay;

     

       105
       104
        
           });

     

       106
       105
        
         };

     

       107
       106
        
       

     

       108
       108
       -
         pkgs = import nixpkgs { config = {}; overlays = [ overlay ]; };

     

       107
       107
       +
         pkgs = import nixpkgs {

     

       108
       108
       +
           config = { };

     

       109
       109
       +
           overlays = [ overlay ];

     

       110
       110
       +
         };

     

       109
       111
        
       

     

       110
       112
        
       in

     

       111
       111
       -
         pkgs

     

       113
       113
       +
       pkgs

     

       112
       114
        
       ```

     

       113
       115
        
       

     

       114
       116
        
       … which we can then build using this command:

     
···

       190
       192
        
       {

     

       191
       193
        
         dhallOverrides = self: super: {

     

       192
       194
        
           # Enable source for all Dhall packages

     

       193
       193
       -
           buildDhallPackage =

     

       194
       194
       -
             args: super.buildDhallPackage (args // { source = true; });

     

       195
       195
       +
           buildDhallPackage = args: super.buildDhallPackage (args // { source = true; });

     

       195
       196
        
       

     

       196
       197
        
           true = self.callPackage ./true.nix { };

     

       197
       198
        
         };

+21 -10

doc/languages-frameworks/dotnet.section.md

···

       6
       6
        
       

     

       7
       7
        
       ```nix

     

       8
       8
        
       # shell.nix

     

       9
       9
       -
       with import <nixpkgs> {};

     

       9
       9
       +
       with import <nixpkgs> { };

     

       10
       10
        
       

     

       11
       11
        
       mkShell {

     

       12
       12
        
         name = "dotnet-env";

     
···

       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
        
       ```nix

     

       24
       24
       -
       with import <nixpkgs> {};

     

       24
       24
       +
       with import <nixpkgs> { };

     

       25
       25
        
       

     

       26
       26
        
       mkShell {

     

       27
       27
        
         name = "dotnet-env";

     

       28
       28
        
         packages = [

     

       29
       29
       -
           (with dotnetCorePackages; combinePackages [

     

       30
       30
       -
             sdk_8_0

     

       31
       31
       -
             sdk_9_0

     

       32
       32
       -
           ])

     

       29
       29
       +
           (

     

       30
       30
       +
             with dotnetCorePackages;

     

       31
       31
       +
             combinePackages [

     

       32
       32
       +
               sdk_8_0

     

       33
       33
       +
               sdk_9_0

     

       34
       34
       +
             ]

     

       35
       35
       +
           )

     

       33
       36
        
         ];

     

       34
       37
        
       }

     

       35
       38
        
       ```

     
···

       137
       140
        
       

     

       138
       141
        
       Here is an example `default.nix`, using some of the previously discussed arguments:

     

       139
       142
        
       ```nix

     

       140
       140
       -
       { lib, buildDotnetModule, dotnetCorePackages, ffmpeg }:

     

       143
       143
       +
       {

     

       144
       144
       +
         lib,

     

       145
       145
       +
         buildDotnetModule,

     

       146
       146
       +
         dotnetCorePackages,

     

       147
       147
       +
         ffmpeg,

     

       148
       148
       +
       }:

     

       141
       149
        
       

     

       142
       150
        
       let

     

       143
       143
       -
         referencedProject = import ../../bar { /* ... */ };

     

       144
       144
       -
       in buildDotnetModule rec {

     

       151
       151
       +
         referencedProject = import ../../bar {

     

       152
       152
       +
           # ...

     

       153
       153
       +
         };

     

       154
       154
       +
       in

     

       155
       155
       +
       buildDotnetModule rec {

     

       145
       156
        
         pname = "someDotnetApplication";

     

       146
       157
        
         version = "0.1";

     

       147
       158
        
       

     
···

       156
       167
        
         dotnet-runtime = dotnetCorePackages.runtime_8_0;

     

       157
       168
        
       

     

       158
       169
        
         executables = [ "foo" ]; # This wraps "$out/lib/$pname/foo" to `$out/bin/foo`.

     

       159
       159
       -
         executables = []; # Don't install any executables.

     

       170
       170
       +
         executables = [ ]; # Don't install any executables.

     

       160
       171
        
       

     

       161
       172
        
         packNupkg = true; # This packs the project as "foo-0.1.nupkg" at `$out/share`.

     

       162
       173

+65 -47

doc/languages-frameworks/emscripten.section.md

···

       41
       41
        
       (pkgs.zlib.override {

     

       42
       42
        
         stdenv = pkgs.emscriptenStdenv;

     

       43
       43
        
       }).overrideAttrs

     

       44
       44
       -
       (old: rec {

     

       45
       45
       -
         buildInputs = old.buildInputs ++ [ pkg-config ];

     

       46
       46
       -
         # we need to reset this setting!

     

       47
       47
       -
         env = (old.env or { }) // { NIX_CFLAGS_COMPILE = ""; };

     

       48
       48
       -
         configurePhase = ''

     

       49
       49
       -
           # FIXME: Some tests require writing at $HOME

     

       50
       50
       -
           HOME=$TMPDIR

     

       51
       51
       -
           runHook preConfigure

     

       44
       44
       +
         (old: rec {

     

       45
       45
       +
           buildInputs = old.buildInputs ++ [ pkg-config ];

     

       46
       46
       +
           # we need to reset this setting!

     

       47
       47
       +
           env = (old.env or { }) // {

     

       48
       48
       +
             NIX_CFLAGS_COMPILE = "";

     

       49
       49
       +
           };

     

       50
       50
       +
           configurePhase = ''

     

       51
       51
       +
             # FIXME: Some tests require writing at $HOME

     

       52
       52
       +
             HOME=$TMPDIR

     

       53
       53
       +
             runHook preConfigure

     

       52
       54
        
       

     

       53
       53
       -
           #export EMCC_DEBUG=2

     

       54
       54
       -
           emconfigure ./configure --prefix=$out --shared

     

       55
       55
       +
             #export EMCC_DEBUG=2

     

       56
       56
       +
             emconfigure ./configure --prefix=$out --shared

     

       55
       57
        
       

     

       56
       56
       -
           runHook postConfigure

     

       57
       57
       -
         '';

     

       58
       58
       -
         dontStrip = true;

     

       59
       59
       -
         outputs = [ "out" ];

     

       60
       60
       -
         buildPhase = ''

     

       61
       61
       -
           emmake make

     

       62
       62
       -
         '';

     

       63
       63
       -
         installPhase = ''

     

       64
       64
       -
           emmake make install

     

       65
       65
       -
         '';

     

       66
       66
       -
         checkPhase = ''

     

       67
       67
       -
           echo "================= testing zlib using node ================="

     

       58
       58
       +
             runHook postConfigure

     

       59
       59
       +
           '';

     

       60
       60
       +
           dontStrip = true;

     

       61
       61
       +
           outputs = [ "out" ];

     

       62
       62
       +
           buildPhase = ''

     

       63
       63
       +
             emmake make

     

       64
       64
       +
           '';

     

       65
       65
       +
           installPhase = ''

     

       66
       66
       +
             emmake make install

     

       67
       67
       +
           '';

     

       68
       68
       +
           checkPhase = ''

     

       69
       69
       +
             echo "================= testing zlib using node ================="

     

       68
       70
        
       

     

       69
       69
       -
           echo "Compiling a custom test"

     

       70
       70
       -
           set -x

     

       71
       71
       -
           emcc -O2 -s EMULATE_FUNCTION_POINTER_CASTS=1 test/example.c -DZ_SOLO \

     

       72
       72
       -
           libz.so.${old.version} -I . -o example.js

     

       71
       71
       +
             echo "Compiling a custom test"

     

       72
       72
       +
             set -x

     

       73
       73
       +
             emcc -O2 -s EMULATE_FUNCTION_POINTER_CASTS=1 test/example.c -DZ_SOLO \

     

       74
       74
       +
             libz.so.${old.version} -I . -o example.js

     

       73
       75
        
       

     

       74
       74
       -
           echo "Using node to execute the test"

     

       75
       75
       -
           ${pkgs.nodejs}/bin/node ./example.js

     

       76
       76
       +
             echo "Using node to execute the test"

     

       77
       77
       +
             ${pkgs.nodejs}/bin/node ./example.js

     

       76
       78
        
       

     

       77
       77
       -
           set +x

     

       78
       78
       -
           if [ $? -ne 0 ]; then

     

       79
       79
       -
             echo "test failed for some reason"

     

       80
       80
       -
             exit 1;

     

       81
       81
       -
           else

     

       82
       82
       -
             echo "it seems to work! very good."

     

       83
       83
       -
           fi

     

       84
       84
       -
           echo "================= /testing zlib using node ================="

     

       85
       85
       -
         '';

     

       79
       79
       +
             set +x

     

       80
       80
       +
             if [ $? -ne 0 ]; then

     

       81
       81
       +
               echo "test failed for some reason"

     

       82
       82
       +
               exit 1;

     

       83
       83
       +
             else

     

       84
       84
       +
               echo "it seems to work! very good."

     

       85
       85
       +
             fi

     

       86
       86
       +
             echo "================= /testing zlib using node ================="

     

       87
       87
       +
           '';

     

       86
       88
        
       

     

       87
       87
       -
         postPatch = pkgs.lib.optionalString pkgs.stdenv.hostPlatform.isDarwin ''

     

       88
       88
       -
           substituteInPlace configure \

     

       89
       89
       -
             --replace-fail '/usr/bin/libtool' 'ar' \

     

       90
       90
       -
             --replace-fail 'AR="libtool"' 'AR="ar"' \

     

       91
       91
       -
             --replace-fail 'ARFLAGS="-o"' 'ARFLAGS="-r"'

     

       92
       92
       -
         '';

     

       93
       93
       -
       })

     

       89
       89
       +
           postPatch = pkgs.lib.optionalString pkgs.stdenv.hostPlatform.isDarwin ''

     

       90
       90
       +
             substituteInPlace configure \

     

       91
       91
       +
               --replace-fail '/usr/bin/libtool' 'ar' \

     

       92
       92
       +
               --replace-fail 'AR="libtool"' 'AR="ar"' \

     

       93
       93
       +
               --replace-fail 'ARFLAGS="-o"' 'ARFLAGS="-r"'

     

       94
       94
       +
           '';

     

       95
       95
       +
         })

     

       94
       96
        
       ```

     

       95
       97
        
       

     

       96
       98
        
       :::{.example #usage-2-pkgs.buildemscriptenpackage}

     
···

       103
       105
        
       pkgs.buildEmscriptenPackage rec {

     

       104
       106
        
         name = "xmlmirror";

     

       105
       107
        
       

     

       106
       106
       -
         buildInputs = [ pkg-config autoconf automake libtool gnumake libxml2 nodejs openjdk json_c ];

     

       107
       107
       -
         nativeBuildInputs = [ pkg-config zlib ];

     

       108
       108
       +
         buildInputs = [

     

       109
       109
       +
           pkg-config

     

       110
       110
       +
           autoconf

     

       111
       111
       +
           automake

     

       112
       112
       +
           libtool

     

       113
       113
       +
           gnumake

     

       114
       114
       +
           libxml2

     

       115
       115
       +
           nodejs

     

       116
       116
       +
           openjdk

     

       117
       117
       +
           json_c

     

       118
       118
       +
         ];

     

       119
       119
       +
         nativeBuildInputs = [

     

       120
       120
       +
           pkg-config

     

       121
       121
       +
           zlib

     

       122
       122
       +
         ];

     

       108
       123
        
       

     

       109
       124
        
         src = pkgs.fetchgit {

     

       110
       125
        
           url = "https://gitlab.com/odfplugfest/xmlmirror.git";

     
···

       129
       144
        
           make -f Makefile.emEnv

     

       130
       145
        
         '';

     

       131
       146
        
       

     

       132
       132
       -
         outputs = [ "out" "doc" ];

     

       147
       147
       +
         outputs = [

     

       148
       148
       +
           "out"

     

       149
       149
       +
           "doc"

     

       150
       150
       +
         ];

     

       133
       151
        
       

     

       134
       152
        
         installPhase = ''

     

       135
       153
        
           mkdir -p $out/share

+6 -1

doc/languages-frameworks/gnome.section.md

···

       96
       96
        
               --prefix XDG_DATA_DIRS : "$out/share/gsettings-schemas/${name}" \

     

       97
       97
        
               --prefix XDG_DATA_DIRS : "${gsettings-desktop-schemas}/share/gsettings-schemas/${gsettings-desktop-schemas.name}" \

     

       98
       98
        
               --prefix XDG_DATA_DIRS : "${hicolor-icon-theme}/share" \

     

       99
       99
       -
               --prefix GI_TYPELIB_PATH : "${lib.makeSearchPath "lib/girepository-1.0" [ pango json-glib ]}"

     

       99
       99
       +
               --prefix GI_TYPELIB_PATH : "${

     

       100
       100
       +
                 lib.makeSearchPath "lib/girepository-1.0" [

     

       101
       101
       +
                   pango

     

       102
       102
       +
                   json-glib

     

       103
       103
       +
                 ]

     

       104
       104
       +
               }"

     

       100
       105
        
           done

     

       101
       106
        
         '';

     

       102
       107
        
       }

+10 -6

doc/languages-frameworks/gradle.section.md

···

       21
       21
        
           hash = "sha256-ciKotTHSEcITfQYKFZ6sY2LZnXGChBJy0+eno8B3YHY=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
       -
         nativeBuildInputs = [ gradle makeWrapper ];

     

       24
       24
       +
         nativeBuildInputs = [

     

       25
       25
       +
           gradle

     

       26
       26
       +
           makeWrapper

     

       27
       27
       +
         ];

     

       25
       28
        
       

     

       26
       29
        
         # if the package has dependencies, mitmCache must be set

     

       27
       30
        
         mitmCache = gradle.fetchDeps {

     
···

       72
       75
        
       package. Using the pdftk example above:

     

       73
       76
        
       

     

       74
       77
        
       ```nix

     

       75
       75
       -
       { lib

     

       76
       76
       -
       , stdenv

     

       77
       77
       -
       , gradle

     

       78
       78
       -
       # ...

     

       79
       79
       -
       , pdftk

     

       78
       78
       +
       {

     

       79
       79
       +
         lib,

     

       80
       80
       +
         stdenv,

     

       81
       81
       +
         gradle,

     

       82
       82
       +
         # ...

     

       83
       83
       +
         pdftk,

     

       80
       84
        
       }:

     

       81
       85
        
       

     

       82
       86
        
       stdenv.mkDerivation (finalAttrs: {

+2 -1

doc/languages-frameworks/hare.section.md

···

       25
       25
        
         hareHook,

     

       26
       26
        
         lib,

     

       27
       27
        
         stdenv,

     

       28
       28
       -
       }: stdenv.mkDerivation {

     

       28
       28
       +
       }:

     

       29
       29
       +
       stdenv.mkDerivation {

     

       29
       30
        
         pname = "<name>";

     

       30
       31
        
         version = "<version>";

     

       31
       32
        
         src = "<src>";

+85 -63

doc/languages-frameworks/haskell.section.md

···

       487
       487
        
       

     

       488
       488
        
       ```nix

     

       489
       489
        
       let

     

       490
       490
       -
         pkgs = import <nixpkgs> {};

     

       490
       490
       +
         pkgs = import <nixpkgs> { };

     

       491
       491
        
         inherit (pkgs) haskell;

     

       492
       492
        
         inherit (haskell.lib.compose) overrideCabal;

     

       493
       493
        
       

     
···

       511
       511
        
           previousIntermediates = turtle-full-build-with-incremental-output.intermediates;

     

       512
       512
        
         }) turtle;

     

       513
       513
        
       in

     

       514
       514
       -
         turtle-incremental-build

     

       514
       514
       +
       turtle-incremental-build

     

       515
       515
        
       ```

     

       516
       516
        
       

     

       517
       517
        
       ## Development environments {#haskell-development-environments}

     
···

       590
       590
        
       

     

       591
       591
        
       ```nix

     

       592
       592
        
       # Retrieve nixpkgs impurely from NIX_PATH for now, you can pin it instead, of course.

     

       593
       593
       -
       { pkgs ? import <nixpkgs> {} }:

     

       593
       593
       +
       {

     

       594
       594
       +
         pkgs ? import <nixpkgs> { },

     

       595
       595
       +
       }:

     

       594
       596
        
       

     

       595
       597
        
       # use the nixpkgs default haskell package set

     

       596
       598
        
       pkgs.haskellPackages.callPackage ./my-project.nix { }

     
···

       654
       656
        
       file set up for both, we can add the following `shell.nix` expression:

     

       655
       657
        
       

     

       656
       658
        
       ```nix

     

       657
       657
       -
       { pkgs ? import <nixpkgs> {} }:

     

       659
       659
       +
       {

     

       660
       660
       +
         pkgs ? import <nixpkgs> { },

     

       661
       661
       +
       }:

     

       658
       662
        
       

     

       659
       663
        
       pkgs.haskellPackages.shellFor {

     

       660
       664
        
         packages = hpkgs: [

     
···

       703
       707
        
       with e.g.

     

       704
       708
        
       

     

       705
       709
        
       ```nix

     

       706
       706
       -
       pkgs.haskell-language-server.override { supportedGhcVersions = [ "90" "94" ]; }

     

       710
       710
       +
       pkgs.haskell-language-server.override {

     

       711
       711
       +
         supportedGhcVersions = [

     

       712
       712
       +
           "90"

     

       713
       713
       +
           "94"

     

       714
       714
       +
         ];

     

       715
       715
       +
       }

     

       707
       716
        
       ```

     

       708
       717
        
       Where all strings `version` are allowed such that

     

       709
       718
        
       `haskell.packages.ghc${version}` is an existing package set.

     
···

       886
       895
        
         derivation:

     

       887
       896
        
       

     

       888
       897
        
         ```nix

     

       889
       889
       -
         pkgs.haskell.lib.overrideCabal

     

       890
       890
       -
           (pkgs.haskell.lib.justStaticExecutables my-haskell-package)

     

       891
       891
       -
           (drv: {

     

       892
       892
       -
             disallowGhcReference = false;

     

       893
       893
       -
           })

     

       898
       898
       +
         pkgs.haskell.lib.overrideCabal (pkgs.haskell.lib.justStaticExecutables my-haskell-package) (drv: {

     

       899
       899
       +
           disallowGhcReference = false;

     

       900
       900
       +
         })

     

       894
       901
        
         ```

     

       895
       902
        
       

     

       896
       903
        
         Then use `strings` to determine which libraries are responsible:

     
···

       906
       913
        
         Finally, use `remove-references-to` to delete those store paths from the produced output:

     

       907
       914
        
       

     

       908
       915
        
         ```nix

     

       909
       909
       -
         pkgs.haskell.lib.overrideCabal

     

       910
       910
       -
           (pkgs.haskell.lib.justStaticExecutables my-haskell-package)

     

       911
       911
       -
           (drv: {

     

       912
       912
       -
             postInstall = ''

     

       913
       913
       -
               ${drv.postInstall or ""}

     

       914
       914
       -
               remove-references-to -t ${pkgs.haskellPackages.hs-opentelemetry-sdk}

     

       915
       915
       -
             '';

     

       916
       916
       -
           })

     

       916
       916
       +
         pkgs.haskell.lib.overrideCabal (pkgs.haskell.lib.justStaticExecutables my-haskell-package) (drv: {

     

       917
       917
       +
           postInstall = ''

     

       918
       918
       +
             ${drv.postInstall or ""}

     

       919
       919
       +
             remove-references-to -t ${pkgs.haskellPackages.hs-opentelemetry-sdk}

     

       920
       920
       +
           '';

     

       921
       921
       +
         })

     

       917
       922
        
         ```

     

       918
       923
        
       

     

       919
       924
        
       [164630]: https://github.com/NixOS/nixpkgs/issues/164630

     
···

       1122
       1127
        
       

     

       1123
       1128
        
       ```nix

     

       1124
       1129
        
       # cabal get mtl-2.2.1 && cd mtl-2.2.1 && cabal2nix .

     

       1125
       1125
       -
       { mkDerivation, base, lib, transformers }:

     

       1130
       1130
       +
       {

     

       1131
       1131
       +
         mkDerivation,

     

       1132
       1132
       +
         base,

     

       1133
       1133
       +
         lib,

     

       1134
       1134
       +
         transformers,

     

       1135
       1135
       +
       }:

     

       1126
       1136
        
       mkDerivation {

     

       1127
       1137
        
         pname = "mtl";

     

       1128
       1138
        
         version = "2.2.1";

     

       1129
       1139
        
         src = ./.;

     

       1130
       1130
       -
         libraryHaskellDepends = [ base transformers ];

     

       1140
       1140
       +
         libraryHaskellDepends = [

     

       1141
       1141
       +
           base

     

       1142
       1142
       +
           transformers

     

       1143
       1143
       +
         ];

     

       1131
       1144
        
         homepage = "http://github.com/ekmett/mtl";

     

       1132
       1145
        
         description = "Monad classes, using functional dependencies";

     

       1133
       1146
        
         license = lib.licenses.bsd3;

     
···

       1274
       1287
        
         # recommended to only use such an overlay if you are enabling profiling on a

     

       1275
       1288
        
         # platform that doesn't by default, because compiling GHC from scratch is

     

       1276
       1289
        
         # quite expensive.

     

       1277
       1277
       -
         (final: prev:

     

       1278
       1278
       -
         let

     

       1279
       1279
       -
           inherit (final) lib;

     

       1280
       1280
       -
         in

     

       1290
       1290
       +
         (

     

       1291
       1291
       +
           final: prev:

     

       1292
       1292
       +
           let

     

       1293
       1293
       +
             inherit (final) lib;

     

       1294
       1294
       +
           in

     

       1281
       1295
        
       

     

       1282
       1282
       -
         {

     

       1283
       1283
       -
           haskell = prev.haskell // {

     

       1284
       1284
       -
             compiler = prev.haskell.compiler // {

     

       1285
       1285
       -
               ${ghcName} = prev.haskell.compiler.${ghcName}.override {

     

       1286
       1286
       -
                 # Unfortunately, the GHC setting is named differently for historical reasons

     

       1287
       1287
       -
                 enableProfiledLibs = enableProfiling;

     

       1296
       1296
       +
           {

     

       1297
       1297
       +
             haskell = prev.haskell // {

     

       1298
       1298
       +
               compiler = prev.haskell.compiler // {

     

       1299
       1299
       +
                 ${ghcName} = prev.haskell.compiler.${ghcName}.override {

     

       1300
       1300
       +
                   # Unfortunately, the GHC setting is named differently for historical reasons

     

       1301
       1301
       +
                   enableProfiledLibs = enableProfiling;

     

       1302
       1302
       +
                 };

     

       1288
       1303
        
               };

     

       1289
       1304
        
             };

     

       1290
       1290
       -
           };

     

       1291
       1291
       -
         })

     

       1305
       1305
       +
           }

     

       1306
       1306
       +
         )

     

       1292
       1307
        
       

     

       1293
       1293
       -
         (final: prev:

     

       1294
       1294
       -
         let

     

       1295
       1295
       -
           inherit (final) lib;

     

       1296
       1296
       -
           haskellLib = final.haskell.lib.compose;

     

       1297
       1297
       -
         in

     

       1308
       1308
       +
         (

     

       1309
       1309
       +
           final: prev:

     

       1310
       1310
       +
           let

     

       1311
       1311
       +
             inherit (final) lib;

     

       1312
       1312
       +
             haskellLib = final.haskell.lib.compose;

     

       1313
       1313
       +
           in

     

       1298
       1314
        
       

     

       1299
       1299
       -
         {

     

       1300
       1300
       -
           haskell = prev.haskell // {

     

       1301
       1301
       -
             packages = prev.haskell.packages // {

     

       1302
       1302
       -
               ${ghcName} = prev.haskell.packages.${ghcName}.override {

     

       1303
       1303
       -
                 overrides = hfinal: hprev: {

     

       1304
       1304
       -
                   mkDerivation = args: hprev.mkDerivation (args // {

     

       1305
       1305
       -
                     # Since we are forcing our ideas upon mkDerivation, this change will

     

       1306
       1306
       -
                     # affect every package in the package set.

     

       1307
       1307
       -
                     enableLibraryProfiling = enableProfiling;

     

       1315
       1315
       +
           {

     

       1316
       1316
       +
             haskell = prev.haskell // {

     

       1317
       1317
       +
               packages = prev.haskell.packages // {

     

       1318
       1318
       +
                 ${ghcName} = prev.haskell.packages.${ghcName}.override {

     

       1319
       1319
       +
                   overrides = hfinal: hprev: {

     

       1320
       1320
       +
                     mkDerivation =

     

       1321
       1321
       +
                       args:

     

       1322
       1322
       +
                       hprev.mkDerivation (

     

       1323
       1323
       +
                         args

     

       1324
       1324
       +
                         // {

     

       1325
       1325
       +
                           # Since we are forcing our ideas upon mkDerivation, this change will

     

       1326
       1326
       +
                           # affect every package in the package set.

     

       1327
       1327
       +
                           enableLibraryProfiling = enableProfiling;

     

       1308
       1328
        
       

     

       1309
       1309
       -
                     # To actually use profiling on an executable, executable profiling

     

       1310
       1310
       -
                     # needs to be enabled for the executable you want to profile. You

     

       1311
       1311
       -
                     # can either do this globally or…

     

       1312
       1312
       -
                     enableExecutableProfiling = enableProfiling;

     

       1313
       1313
       -
                   });

     

       1329
       1329
       +
                           # To actually use profiling on an executable, executable profiling

     

       1330
       1330
       +
                           # needs to be enabled for the executable you want to profile. You

     

       1331
       1331
       +
                           # can either do this globally or…

     

       1332
       1332
       +
                           enableExecutableProfiling = enableProfiling;

     

       1333
       1333
       +
                         }

     

       1334
       1334
       +
                       );

     

       1314
       1335
        
       

     

       1315
       1315
       -
                   # …only for the package that contains an executable you want to profile.

     

       1316
       1316
       -
                   # That saves on unnecessary rebuilds for packages that you only depend

     

       1317
       1317
       -
                   # on for their library, but also contain executables (e.g. pandoc).

     

       1318
       1318
       -
                   my-executable = haskellLib.enableExecutableProfiling hprev.my-executable;

     

       1336
       1336
       +
                     # …only for the package that contains an executable you want to profile.

     

       1337
       1337
       +
                     # That saves on unnecessary rebuilds for packages that you only depend

     

       1338
       1338
       +
                     # on for their library, but also contain executables (e.g. pandoc).

     

       1339
       1339
       +
                     my-executable = haskellLib.enableExecutableProfiling hprev.my-executable;

     

       1319
       1340
        
       

     

       1320
       1320
       -
                   # If you are disabling profiling to save on build time, but want to

     

       1321
       1321
       -
                   # retain the ability to substitute from the binary cache. Drop the

     

       1322
       1322
       -
                   # override for mkDerivation above and instead have an override like

     

       1323
       1323
       -
                   # this for the specific packages you are building locally and want

     

       1324
       1324
       -
                   # to make cheaper to build.

     

       1325
       1325
       -
                   my-library = haskellLib.disableLibraryProfiling hprev.my-library;

     

       1341
       1341
       +
                     # If you are disabling profiling to save on build time, but want to

     

       1342
       1342
       +
                     # retain the ability to substitute from the binary cache. Drop the

     

       1343
       1343
       +
                     # override for mkDerivation above and instead have an override like

     

       1344
       1344
       +
                     # this for the specific packages you are building locally and want

     

       1345
       1345
       +
                     # to make cheaper to build.

     

       1346
       1346
       +
                     my-library = haskellLib.disableLibraryProfiling hprev.my-library;

     

       1347
       1347
       +
                   };

     

       1326
       1348
        
                 };

     

       1327
       1349
        
               };

     

       1328
       1350
        
             };

     

       1329
       1329
       -
           };

     

       1330
       1330
       -
         })

     

       1351
       1351
       +
           }

     

       1352
       1352
       +
         )

     

       1331
       1353
        
       ]

     

       1332
       1354
        
       ```

     

       1333
       1355

+8 -2

doc/languages-frameworks/hy.section.md

···

       22
       22
        
       

     

       23
       23
        
       Or if you want to extend your `configuration.nix`:

     

       24
       24
        
       ```nix

     

       25
       25
       -
       { # ...

     

       25
       25
       +
       {

     

       26
       26
       +
         # ...

     

       26
       27
        
       

     

       27
       28
        
         environment.systemPackages = with pkgs; [

     

       28
       28
       -
           (hy.withPackages (py-packages: with py-packages; [ numpy matplotlib ]))

     

       29
       29
       +
           (hy.withPackages (

     

       30
       30
       +
             py-packages: with py-packages; [

     

       31
       31
       +
               numpy

     

       32
       32
       +
               matplotlib

     

       33
       33
       +
             ]

     

       34
       34
       +
           ))

     

       29
       35
        
         ];

     

       30
       36
        
       }

     

       31
       37
        
       ```

+24 -11

doc/languages-frameworks/idris.section.md

···

       12
       12
        
       

     

       13
       13
        
       ```nix

     

       14
       14
        
       self: super: {

     

       15
       15
       -
         myIdris = with self.idrisPackages; with-packages [ contrib pruviloj ];

     

       15
       15
       +
         myIdris =

     

       16
       16
       +
           with self.idrisPackages;

     

       17
       17
       +
           with-packages [

     

       18
       18
       +
             contrib

     

       19
       19
       +
             pruviloj

     

       20
       20
       +
           ];

     

       16
       21
        
       }

     

       17
       22
        
       ```

     

       18
       23
        
       

     
···

       68
       73
        
       As an example of how a Nix expression for an Idris package can be created, here is the one for `idrisPackages.yaml`:

     

       69
       74
        
       

     

       70
       75
        
       ```nix

     

       71
       71
       -
       { lib

     

       72
       72
       -
       , build-idris-package

     

       73
       73
       -
       , fetchFromGitHub

     

       74
       74
       -
       , contrib

     

       75
       75
       -
       , lightyear

     

       76
       76
       +
       {

     

       77
       77
       +
         lib,

     

       78
       78
       +
         build-idris-package,

     

       79
       79
       +
         fetchFromGitHub,

     

       80
       80
       +
         contrib,

     

       81
       81
       +
         lightyear,

     

       76
       82
        
       }:

     

       77
       77
       -
       build-idris-package  {

     

       83
       83
       +
       build-idris-package {

     

       78
       84
        
         name = "yaml";

     

       79
       85
        
         version = "2018-01-25";

     

       80
       86
        
       

     
···

       84
       90
        
         # different from its package name here.

     

       85
       91
        
         ipkgName = "Yaml";

     

       86
       92
        
         # Idris dependencies to provide for the build

     

       87
       87
       -
         idrisDeps = [ contrib lightyear ];

     

       93
       93
       +
         idrisDeps = [

     

       94
       94
       +
           contrib

     

       95
       95
       +
           lightyear

     

       96
       96
       +
         ];

     

       88
       97
        
       

     

       89
       98
        
         src = fetchFromGitHub {

     

       90
       99
        
           owner = "Heather";

     
···

       111
       120
        
       Or it's possible to use

     

       112
       121
        
       

     

       113
       122
        
       ```nix

     

       114
       114
       -
       with import <nixpkgs> {};

     

       123
       123
       +
       with import <nixpkgs> { };

     

       115
       124
        
       

     

       116
       125
        
       {

     

       117
       117
       -
         yaml = idrisPackages.callPackage ./yaml.nix {};

     

       126
       126
       +
         yaml = idrisPackages.callPackage ./yaml.nix { };

     

       118
       127
        
       }

     

       119
       128
        
       ```

     

       120
       129
        
       

     
···

       134
       143
        
       

     

       135
       144
        
       ```nix

     

       136
       145
        
       build-idris-package {

     

       137
       137
       -
         idrisBuildOptions = [ "--log" "1" "--verbose" ];

     

       146
       146
       +
         idrisBuildOptions = [

     

       147
       147
       +
           "--log"

     

       148
       148
       +
           "1"

     

       149
       149
       +
           "--verbose"

     

       150
       150
       +
         ];

     

       138
       151
        
       

     

       139
       152
        
         # ...

     

       140
       153
        
       }

+34 -23

doc/languages-frameworks/idris2.section.md

···

       9
       9
        
       A simple example of a fully packaged library would be the [`LSP-lib`](https://github.com/idris-community/LSP-lib) found in the `idris-community` GitHub organization.

     

       10
       10
        
       ```nix

     

       11
       11
        
       { fetchFromGitHub, idris2Packages }:

     

       12
       12
       -
       let lspLibPkg = idris2Packages.buildIdris {

     

       13
       13
       -
         ipkgName = "lsp-lib";

     

       14
       14
       -
         src = fetchFromGitHub {

     

       15
       15
       -
          owner = "idris-community";

     

       16
       16
       -
          repo = "LSP-lib";

     

       17
       17
       -
          rev = "main";

     

       18
       18
       -
          hash = "sha256-EvSyMCVyiy9jDZMkXQmtwwMoLaem1GsKVFqSGNNHHmY=";

     

       12
       12
       +
       let

     

       13
       13
       +
         lspLibPkg = idris2Packages.buildIdris {

     

       14
       14
       +
           ipkgName = "lsp-lib";

     

       15
       15
       +
           src = fetchFromGitHub {

     

       16
       16
       +
             owner = "idris-community";

     

       17
       17
       +
             repo = "LSP-lib";

     

       18
       18
       +
             rev = "main";

     

       19
       19
       +
             hash = "sha256-EvSyMCVyiy9jDZMkXQmtwwMoLaem1GsKVFqSGNNHHmY=";

     

       20
       20
       +
           };

     

       21
       21
       +
           idrisLibraries = [ ];

     

       19
       22
        
         };

     

       20
       20
       -
         idrisLibraries = [ ];

     

       21
       21
       -
       };

     

       22
       22
       -
       in lspLibPkg.library { withSource = true; }

     

       23
       23
       +
       in

     

       24
       24
       +
       lspLibPkg.library { withSource = true; }

     

       23
       25
        
       ```

     

       24
       26
        
       

     

       25
       27
        
       The above results in a derivation with the installed library results (with sourcecode).

     

       26
       28
        
       

     

       27
       29
        
       A slightly more involved example of a fully packaged executable would be the [`idris2-lsp`](https://github.com/idris-community/idris2-lsp) which is an Idris2 language server that uses the `LSP-lib` found above.

     

       28
       30
        
       ```nix

     

       29
       29
       -
       { callPackage, fetchFromGitHub, idris2Packages }:

     

       31
       31
       +
       {

     

       32
       32
       +
         callPackage,

     

       33
       33
       +
         fetchFromGitHub,

     

       34
       34
       +
         idris2Packages,

     

       35
       35
       +
       }:

     

       30
       36
        
       

     

       31
       37
        
       # Assuming the previous example lives in `lsp-lib.nix`:

     

       32
       32
       -
       let lspLib = callPackage ./lsp-lib.nix { };

     

       33
       33
       -
           inherit (idris2Packages) idris2Api;

     

       34
       34
       -
           lspPkg = idris2Packages.buildIdris {

     

       35
       35
       -
             ipkgName = "idris2-lsp";

     

       36
       36
       -
             src = fetchFromGitHub {

     

       37
       37
       -
                owner = "idris-community";

     

       38
       38
       -
                repo = "idris2-lsp";

     

       39
       39
       -
                rev = "main";

     

       40
       40
       -
                hash = "sha256-vQTzEltkx7uelDtXOHc6QRWZ4cSlhhm5ziOqWA+aujk=";

     

       41
       41
       -
             };

     

       42
       42
       -
             idrisLibraries = [idris2Api lspLib];

     

       38
       38
       +
       let

     

       39
       39
       +
         lspLib = callPackage ./lsp-lib.nix { };

     

       40
       40
       +
         inherit (idris2Packages) idris2Api;

     

       41
       41
       +
         lspPkg = idris2Packages.buildIdris {

     

       42
       42
       +
           ipkgName = "idris2-lsp";

     

       43
       43
       +
           src = fetchFromGitHub {

     

       44
       44
       +
             owner = "idris-community";

     

       45
       45
       +
             repo = "idris2-lsp";

     

       46
       46
       +
             rev = "main";

     

       47
       47
       +
             hash = "sha256-vQTzEltkx7uelDtXOHc6QRWZ4cSlhhm5ziOqWA+aujk=";

     

       43
       48
        
           };

     

       44
       44
       -
       in lspPkg.executable

     

       49
       49
       +
           idrisLibraries = [

     

       50
       50
       +
             idris2Api

     

       51
       51
       +
             lspLib

     

       52
       52
       +
           ];

     

       53
       53
       +
         };

     

       54
       54
       +
       in

     

       55
       55
       +
       lspPkg.executable

     

       45
       56
        
       ```

     

       46
       57
        
       

     

       47
       58
        
       The above uses the default value of `withSource = false` for the `idris2Api` but could be modified to include that library's source by passing `(idris2Api { withSource = true; })` to `idrisLibraries` instead. `idris2Api` in the above derivation comes built in with `idris2Packages`. This library exposes many of the otherwise internal APIs of the Idris2 compiler.

+4 -4

doc/languages-frameworks/ios.section.md

···

       29
       29
        
       

     

       30
       30
        
       ```nix

     

       31
       31
        
       let

     

       32
       32
       -
         pkgs = import <nixpkgs> {};

     

       32
       32
       +
         pkgs = import <nixpkgs> { };

     

       33
       33
        
       

     

       34
       34
        
         xcodeenv = import ./xcodeenv {

     

       35
       35
        
           inherit (pkgs) stdenv;

     
···

       63
       63
        
       

     

       64
       64
        
       ```nix

     

       65
       65
        
       let

     

       66
       66
       -
         pkgs = import <nixpkgs> {};

     

       66
       66
       +
         pkgs = import <nixpkgs> { };

     

       67
       67
        
       

     

       68
       68
        
         xcodeenv = import ./xcodeenv {

     

       69
       69
        
           inherit (pkgs) stdenv;

     
···

       159
       159
        
       

     

       160
       160
        
       ```nix

     

       161
       161
        
       let

     

       162
       162
       -
         pkgs = import <nixpkgs> {};

     

       162
       162
       +
         pkgs = import <nixpkgs> { };

     

       163
       163
        
       

     

       164
       164
        
         xcodeenv = import ./xcodeenv {

     

       165
       165
        
           inherit (pkgs) stdenv;

     
···

       193
       193
        
       

     

       194
       194
        
       ```nix

     

       195
       195
        
       let

     

       196
       196
       -
         pkgs = import <nixpkgs> {};

     

       196
       196
       +
         pkgs = import <nixpkgs> { };

     

       197
       197
        
       

     

       198
       198
        
         xcodeenv = import ./xcodeenv {

     

       199
       199
        
           inherit (pkgs) stdenv;

+8 -3

doc/languages-frameworks/java.section.md

···

       7
       7
        
         pname = "...";

     

       8
       8
        
         version = "...";

     

       9
       9
        
       

     

       10
       10
       -
         src = fetchurl { /* ... */ };

     

       10
       10
       +
         src = fetchurl {

     

       11
       11
       +
           # ...

     

       12
       12
       +
         };

     

       11
       13
        
       

     

       12
       14
        
         nativeBuildInputs = [

     

       13
       15
        
           ant

     
···

       95
       97
        
         something = (pkgs.something.override { jre = my_jre; });

     

       96
       98
        
         other = (pkgs.other.override { jre = my_jre; });

     

       97
       99
        
       in

     

       98
       98
       -
         <...>

     

       100
       100
       +
       <...>

     

       99
       101
        
       ```

     

       100
       102
        
       

     

       101
       103
        
       You can also specify what JDK your JRE should be based on, for example

     
···

       122
       124
        
       

     

       123
       125
        
       ```nix

     

       124
       126
        
       {

     

       125
       125
       -
         nativeBuildInputs = [ gcj ant ];

     

       127
       127
       +
         nativeBuildInputs = [

     

       128
       128
       +
           gcj

     

       129
       129
       +
           ant

     

       130
       130
       +
         ];

     

       126
       131
        
       }

     

       127
       132
        
       ```

     

       128
       133

+45 -28

doc/languages-frameworks/javascript.section.md

···

       117
       117
        
       For example, `dat` requires `node-gyp-build`, so we override its expression in [pkgs/development/node-packages/overrides.nix](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/node-packages/overrides.nix):

     

       118
       118
        
       

     

       119
       119
        
       ```nix

     

       120
       120
       -
         {

     

       121
       121
       -
           dat = prev.dat.override (oldAttrs: {

     

       122
       122
       -
             buildInputs = [ final.node-gyp-build pkgs.libtool pkgs.autoconf pkgs.automake ];

     

       123
       123
       -
             meta = oldAttrs.meta // { broken = since "12"; };

     

       124
       124
       -
           });

     

       125
       125
       -
         }

     

       120
       120
       +
       {

     

       121
       121
       +
         dat = prev.dat.override (oldAttrs: {

     

       122
       122
       +
           buildInputs = [

     

       123
       123
       +
             final.node-gyp-build

     

       124
       124
       +
             pkgs.libtool

     

       125
       125
       +
             pkgs.autoconf

     

       126
       126
       +
             pkgs.automake

     

       127
       127
       +
           ];

     

       128
       128
       +
           meta = oldAttrs.meta // {

     

       129
       129
       +
             broken = since "12";

     

       130
       130
       +
           };

     

       131
       131
       +
         });

     

       132
       132
       +
       }

     

       126
       133
        
       ```

     

       127
       134
        
       

     

       128
       135
        
       ### Adding and Updating Javascript packages in nixpkgs {#javascript-adding-or-updating-packages}

     
···

       185
       192
        
       Here's an example:

     

       186
       193
        
       

     

       187
       194
        
       ```nix

     

       188
       188
       -
       { lib, buildNpmPackage, fetchFromGitHub }:

     

       195
       195
       +
       {

     

       196
       196
       +
         lib,

     

       197
       197
       +
         buildNpmPackage,

     

       198
       198
       +
         fetchFromGitHub,

     

       199
       199
       +
       }:

     

       189
       200
        
       

     

       190
       201
        
       buildNpmPackage rec {

     

       191
       202
        
         pname = "flood";

     
···

       323
       334
        
           npmRoot = ./.;

     

       324
       335
        
           fetcherOpts = {

     

       325
       336
        
             # Pass 'curlOptsList' to 'pkgs.fetchurl' while fetching 'axios'

     

       326
       326
       -
             "node_modules/axios" = { curlOptsList = [ "--verbose" ]; };

     

       337
       337
       +
             "node_modules/axios" = {

     

       338
       338
       +
               curlOptsList = [ "--verbose" ];

     

       339
       339
       +
             };

     

       327
       340
        
           };

     

       328
       341
        
         };

     

       329
       342
        
       

     
···

       403
       416
        
         stdenv,

     

       404
       417
        
         nodejs,

     

       405
       418
        
         # This is pinned as { pnpm = pnpm_9; }

     

       406
       406
       -
         pnpm

     

       419
       419
       +
         pnpm,

     

       407
       420
        
       }:

     

       408
       421
        
       

     

       409
       422
        
       stdenv.mkDerivation (finalAttrs: {

     
···

       491
       504
        
       

     

       492
       505
        
       ```nix

     

       493
       506
        
       {

     

       494
       494
       -
       # ...

     

       495
       495
       -
       pnpmWorkspaces = [ "@astrojs/language-server" ];

     

       496
       496
       -
       pnpmDeps = pnpm.fetchDeps {

     

       497
       497
       -
         inherit (finalAttrs) pnpmWorkspaces;

     

       498
       498
       -
         #...

     

       499
       499
       -
       };

     

       507
       507
       +
         # ...

     

       508
       508
       +
         pnpmWorkspaces = [ "@astrojs/language-server" ];

     

       509
       509
       +
         pnpmDeps = pnpm.fetchDeps {

     

       510
       510
       +
           inherit (finalAttrs) pnpmWorkspaces;

     

       511
       511
       +
           #...

     

       512
       512
       +
         };

     

       500
       513
        
       }

     

       501
       514
        
       ```

     

       502
       515
        
       

     
···

       507
       520
        
       

     

       508
       521
        
       ```nix

     

       509
       522
        
       {

     

       510
       510
       -
       buildPhase = ''

     

       511
       511
       -
         runHook preBuild

     

       523
       523
       +
         buildPhase = ''

     

       524
       524
       +
           runHook preBuild

     

       512
       525
        
       

     

       513
       513
       -
         pnpm --filter=@astrojs/language-server build

     

       526
       526
       +
           pnpm --filter=@astrojs/language-server build

     

       514
       527
        
       

     

       515
       515
       -
         runHook postBuild

     

       516
       516
       -
       '';

     

       528
       528
       +
           runHook postBuild

     

       529
       529
       +
         '';

     

       517
       530
        
       }

     

       518
       531
        
       ```

     

       519
       532
        
       

     
···

       524
       537
        
       

     

       525
       538
        
       ```nix

     

       526
       539
        
       {

     

       527
       527
       -
       prePnpmInstall = ''

     

       528
       528
       -
         pnpm config set dedupe-peer-dependants false

     

       529
       529
       -
       '';

     

       530
       530
       -
       pnpmDeps = pnpm.fetchDeps {

     

       531
       531
       -
         inherit (finalAttrs) prePnpmInstall;

     

       532
       532
       -
         # ...

     

       533
       533
       -
       };

     

       540
       540
       +
         prePnpmInstall = ''

     

       541
       541
       +
           pnpm config set dedupe-peer-dependants false

     

       542
       542
       +
         '';

     

       543
       543
       +
         pnpmDeps = pnpm.fetchDeps {

     

       544
       544
       +
           inherit (finalAttrs) prePnpmInstall;

     

       545
       545
       +
           # ...

     

       546
       546
       +
         };

     

       534
       547
        
       }

     

       535
       548
        
       ```

     

       536
       549
        
       

     
···

       690
       703
        
       mkYarnPackage rec {

     

       691
       704
        
         pkgConfig = {

     

       692
       705
        
           node-sass = {

     

       693
       693
       -
             buildInputs = with final;[ python libsass pkg-config ];

     

       706
       706
       +
             buildInputs = with final; [

     

       707
       707
       +
               python

     

       708
       708
       +
               libsass

     

       709
       709
       +
               pkg-config

     

       710
       710
       +
             ];

     

       694
       711
        
             postInstall = ''

     

       695
       712
        
               LIBSASS_EXT=auto yarn --offline run build

     

       696
       713
        
               rm build/config.gypi

+3 -2

doc/languages-frameworks/julia.section.md

···

       19
       19
        
       For example, you can build a Julia environment with the `Plots` package as follows.

     

       20
       20
        
       

     

       21
       21
        
       ```nix

     

       22
       22
       -
       julia.withPackages ["Plots"]

     

       22
       22
       +
       julia.withPackages [ "Plots" ]

     

       23
       23
        
       ```

     

       24
       24
        
       

     

       25
       25
        
       Arguments can be passed using `.override`.

     
···

       28
       28
        
       ```nix

     

       29
       29
        
       (julia.withPackages.override {

     

       30
       30
        
         precompile = false; # Turn off precompilation

     

       31
       31
       -
       }) ["Plots"]

     

       31
       31
       +
       })

     

       32
       32
       +
         [ "Plots" ]

     

       32
       33
        
       ```

     

       33
       34
        
       

     

       34
       35
        
       Here's a nice way to run a Julia environment with a shell one-liner:

+13 -6

doc/languages-frameworks/lisp.section.md

···

       48
       48
        
       ```nix

     

       49
       49
        
       let

     

       50
       50
        
         sbcl' = sbcl.withPackages (ps: [ ps.alexandria ]);

     

       51
       51
       -
       in mkShell {

     

       51
       51
       +
       in

     

       52
       52
       +
       mkShell {

     

       52
       53
        
         packages = [ sbcl' ];

     

       53
       54
        
       }

     

       54
       55
        
       ```

     
···

       188
       189
        
             hash = "sha256-1Hzxt65dZvgOFIljjjlSGgKYkj+YBLwJCACi5DZsKmQ=";

     

       189
       190
        
           };

     

       190
       191
        
         };

     

       191
       191
       -
         sbcl' = sbcl.withOverrides (self: super: {

     

       192
       192
       -
           inherit alexandria;

     

       193
       193
       -
         });

     

       194
       194
       -
       in sbcl'.pkgs.alexandria

     

       192
       192
       +
         sbcl' = sbcl.withOverrides (

     

       193
       193
       +
           self: super: {

     

       194
       194
       +
             inherit alexandria;

     

       195
       195
       +
           }

     

       196
       196
       +
         );

     

       197
       197
       +
       in

     

       198
       198
       +
       sbcl'.pkgs.alexandria

     

       195
       199
        
       ```

     

       196
       200
        
       

     

       197
       201
        
       ## Overriding package attributes {#lisp-overriding-package-attributes}

     
···

       296
       300
        
       wrapLisp {

     

       297
       301
        
         pkg = clisp;

     

       298
       302
        
         faslExt = "fas";

     

       299
       299
       -
         flags = ["-E" "UTF8"];

     

       303
       303
       +
         flags = [

     

       304
       304
       +
           "-E"

     

       305
       305
       +
           "UTF8"

     

       306
       306
       +
         ];

     

       300
       307
        
       }

     

       301
       308
        
       ```

+45 -17

doc/languages-frameworks/lua.section.md

···

       27
       27
        
       Create a file, e.g. `build.nix`, with the following expression

     

       28
       28
        
       

     

       29
       29
        
       ```nix

     

       30
       30
       -
       with import <nixpkgs> {};

     

       30
       30
       +
       with import <nixpkgs> { };

     

       31
       31
        
       

     

       32
       32
       -
       lua5_2.withPackages (ps: with ps; [ busted luafilesystem ])

     

       32
       32
       +
       lua5_2.withPackages (

     

       33
       33
       +
         ps: with ps; [

     

       34
       34
       +
           busted

     

       35
       35
       +
           luafilesystem

     

       36
       36
       +
         ]

     

       37
       37
       +
       )

     

       33
       38
        
       ```

     

       34
       39
        
       

     

       35
       40
        
       and install it in your profile with

     
···

       46
       51
        
       using `config.nix`,

     

       47
       52
        
       

     

       48
       53
        
       ```nix

     

       49
       49
       -
       { # ...

     

       54
       54
       +
       {

     

       55
       55
       +
         # ...

     

       50
       56
        
       

     

       51
       51
       -
         packageOverrides = pkgs: with pkgs; {

     

       52
       52
       -
           myLuaEnv = lua5_2.withPackages (ps: with ps; [ busted luafilesystem ]);

     

       53
       53
       -
         };

     

       57
       57
       +
         packageOverrides =

     

       58
       58
       +
           pkgs: with pkgs; {

     

       59
       59
       +
             myLuaEnv = lua5_2.withPackages (

     

       60
       60
       +
               ps: with ps; [

     

       61
       61
       +
                 busted

     

       62
       62
       +
                 luafilesystem

     

       63
       63
       +
               ]

     

       64
       64
       +
             );

     

       65
       65
       +
           };

     

       54
       66
        
       }

     

       55
       67
        
       ```

     

       56
       68
        
       

     
···

       67
       79
        
       For the sake of completeness, here's another example how to install the environment system-wide.

     

       68
       80
        
       

     

       69
       81
        
       ```nix

     

       70
       70
       -
       { # ...

     

       82
       82
       +
       {

     

       83
       83
       +
         # ...

     

       71
       84
        
       

     

       72
       85
        
         environment.systemPackages = with pkgs; [

     

       73
       73
       -
           (lua.withPackages(ps: with ps; [ busted luafilesystem ]))

     

       86
       86
       +
           (lua.withPackages (

     

       87
       87
       +
             ps: with ps; [

     

       88
       88
       +
               busted

     

       89
       89
       +
               luafilesystem

     

       90
       90
       +
             ]

     

       91
       91
       +
           ))

     

       74
       92
        
         ];

     

       75
       93
        
       }

     

       76
       94
        
       ```

     
···

       80
       98
        
       Use the following overlay template:

     

       81
       99
        
       

     

       82
       100
        
       ```nix

     

       83
       83
       -
       final: prev:

     

       84
       84
       -
       {

     

       101
       101
       +
       final: prev: {

     

       85
       102
        
       

     

       86
       103
        
         lua = prev.lua.override {

     

       87
       104
        
           packageOverrides = luaself: luaprev: {

     

       88
       105
        
       

     

       89
       89
       -
             luarocks-nix = luaprev.luarocks-nix.overrideAttrs(oa: {

     

       106
       106
       +
             luarocks-nix = luaprev.luarocks-nix.overrideAttrs (oa: {

     

       90
       107
        
               pname = "luarocks-nix";

     

       91
       108
        
               src = /home/my_luarocks/repository;

     

       92
       109
        
             });

     
···

       159
       176
        
       

     

       160
       177
        
       ```nix

     

       161
       178
        
       {

     

       162
       162
       -
         mynewlib = toLuaModule ( stdenv.mkDerivation { /* ... */ });

     

       179
       179
       +
         mynewlib = toLuaModule (

     

       180
       180
       +
           stdenv.mkDerivation {

     

       181
       181
       +
             # ...

     

       182
       182
       +
           }

     

       183
       183
       +
         );

     

       163
       184
        
       }

     

       164
       185
        
       ```

     

       165
       186
        
       

     
···

       194
       215
        
           version = "34.0.4-1";

     

       195
       216
        
       

     

       196
       217
        
           src = fetchurl {

     

       197
       197
       -
             url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/luaposix-34.0.4-1.src.rock";

     

       218
       218
       +
             url = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/luaposix-34.0.4-1.src.rock";

     

       198
       219
        
             hash = "sha256-4mLJG8n4m6y4Fqd0meUDfsOb9RHSR0qa/KD5KCwrNXs=";

     

       199
       220
        
           };

     

       200
       221
        
           disabled = (luaOlder "5.1") || (luaAtLeast "5.4");

     

       201
       201
       -
           propagatedBuildInputs = [ bit32 lua std_normalize ];

     

       222
       222
       +
           propagatedBuildInputs = [

     

       223
       223
       +
             bit32

     

       224
       224
       +
             lua

     

       225
       225
       +
             std_normalize

     

       226
       226
       +
           ];

     

       202
       227
        
       

     

       203
       228
        
           meta = {

     

       204
       229
        
             homepage = "https://github.com/luaposix/luaposix/";

     

       205
       230
        
             description = "Lua bindings for POSIX";

     

       206
       206
       -
             maintainers = with lib.maintainers; [ vyp lblasc ];

     

       231
       231
       +
             maintainers = with lib.maintainers; [

     

       232
       232
       +
               vyp

     

       233
       233
       +
               lblasc

     

       234
       234
       +
             ];

     

       207
       235
        
             license.fullName = "MIT/X11";

     

       208
       236
        
           };

     

       209
       237
        
         };

     
···

       242
       270
        
       Using the `withPackages` function, the previous example for the luafilesystem environment can be written like this:

     

       243
       271
        
       

     

       244
       272
        
       ```nix

     

       245
       245
       -
       lua.withPackages (ps: [ps.luafilesystem])

     

       273
       273
       +
       lua.withPackages (ps: [ ps.luafilesystem ])

     

       246
       274
        
       ```

     

       247
       275
        
       

     

       248
       276
        
       `withPackages` passes the correct package set for the specific interpreter version as an argument to the function. In the above example, `ps` equals `luaPackages`.

     

       249
       277
        
       But you can also easily switch to using `lua5_1`:

     

       250
       278
        
       

     

       251
       279
        
       ```nix

     

       252
       252
       -
       lua5_1.withPackages (ps: [ps.lua])

     

       280
       280
       +
       lua5_1.withPackages (ps: [ ps.lua ])

     

       253
       281
        
       ```

     

       254
       282
        
       

     

       255
       283
        
       Now, `ps` is set to `lua5_1.pkgs`, matching the version of the interpreter.

+46 -15

doc/languages-frameworks/maven.section.md

···

       9
       9
        
       Consider the following package:

     

       10
       10
        
       

     

       11
       11
        
       ```nix

     

       12
       12
       -
       { lib, fetchFromGitHub, jre, makeWrapper, maven }:

     

       12
       12
       +
       {

     

       13
       13
       +
         lib,

     

       14
       14
       +
         fetchFromGitHub,

     

       15
       15
       +
         jre,

     

       16
       16
       +
         makeWrapper,

     

       17
       17
       +
         maven,

     

       18
       18
       +
       }:

     

       13
       19
        
       

     

       14
       20
        
       maven.buildMavenPackage rec {

     

       15
       21
        
         pname = "jd-cli";

     
···

       246
       252
        
       Here is an [example](https://github.com/fzakaria/nixos-maven-example/blob/main/build-maven-repository.nix) of building the Maven repository

     

       247
       253
        
       

     

       248
       254
        
       ```nix

     

       249
       249
       -
       { pkgs ? import <nixpkgs> { } }:

     

       255
       255
       +
       {

     

       256
       256
       +
         pkgs ? import <nixpkgs> { },

     

       257
       257
       +
       }:

     

       250
       258
        
       with pkgs;

     

       251
       259
        
       (buildMaven ./project-info.json).repo

     

       252
       260
        
       ```

     
···

       283
       291
        
       :::

     

       284
       292
        
       

     

       285
       293
        
       ```nix

     

       286
       286
       -
       { lib, stdenv, maven }:

     

       294
       294
       +
       {

     

       295
       295
       +
         lib,

     

       296
       296
       +
         stdenv,

     

       297
       297
       +
         maven,

     

       298
       298
       +
       }:

     

       287
       299
        
       stdenv.mkDerivation {

     

       288
       300
        
         name = "maven-repository";

     

       289
       301
        
         buildInputs = [ maven ];

     
···

       337
       349
        
       Regardless of which strategy is chosen above, the step to build the derivation is the same.

     

       338
       350
        
       

     

       339
       351
        
       ```nix

     

       340
       340
       -
       { stdenv, maven, callPackage }:

     

       352
       352
       +
       {

     

       353
       353
       +
         stdenv,

     

       354
       354
       +
         maven,

     

       355
       355
       +
         callPackage,

     

       356
       356
       +
       }:

     

       341
       357
        
       # pick a repository derivation, here we will use buildMaven

     

       342
       342
       -
       let repository = callPackage ./build-maven-repository.nix { };

     

       343
       343
       -
       in stdenv.mkDerivation rec {

     

       358
       358
       +
       let

     

       359
       359
       +
         repository = callPackage ./build-maven-repository.nix { };

     

       360
       360
       +
       in

     

       361
       361
       +
       stdenv.mkDerivation rec {

     

       344
       362
        
         pname = "maven-demo";

     

       345
       363
        
         version = "1.0";

     

       346
       364
        
       

     
···

       393
       411
        
       We make sure to provide this classpath to the `makeWrapper`.

     

       394
       412
        
       

     

       395
       413
        
       ```nix

     

       396
       396
       -
       { stdenv, maven, callPackage, makeWrapper, jre }:

     

       414
       414
       +
       {

     

       415
       415
       +
         stdenv,

     

       416
       416
       +
         maven,

     

       417
       417
       +
         callPackage,

     

       418
       418
       +
         makeWrapper,

     

       419
       419
       +
         jre,

     

       420
       420
       +
       }:

     

       397
       421
        
       let

     

       398
       422
        
         repository = callPackage ./build-maven-repository.nix { };

     

       399
       399
       -
       in stdenv.mkDerivation rec {

     

       423
       423
       +
       in

     

       424
       424
       +
       stdenv.mkDerivation rec {

     

       400
       425
        
         pname = "maven-demo";

     

       401
       426
        
         version = "1.0";

     

       402
       427
        
       

     

       403
       403
       -
         src = builtins.fetchTarball

     

       404
       404
       -
           "https://github.com/fzakaria/nixos-maven-example/archive/main.tar.gz";

     

       428
       428
       +
         src = builtins.fetchTarball "https://github.com/fzakaria/nixos-maven-example/archive/main.tar.gz";

     

       405
       429
        
         nativeBuildInputs = [ makeWrapper ];

     

       406
       430
        
         buildInputs = [ maven ];

     

       407
       431
        
       

     
···

       471
       495
        
       We will modify the derivation above to add a symlink to our repository so that it's accessible to our JAR during the `installPhase`.

     

       472
       496
        
       

     

       473
       497
        
       ```nix

     

       474
       474
       -
       { stdenv, maven, callPackage, makeWrapper, jre }:

     

       498
       498
       +
       {

     

       499
       499
       +
         stdenv,

     

       500
       500
       +
         maven,

     

       501
       501
       +
         callPackage,

     

       502
       502
       +
         makeWrapper,

     

       503
       503
       +
         jre,

     

       504
       504
       +
       }:

     

       475
       505
        
       # pick a repository derivation, here we will use buildMaven

     

       476
       476
       -
       let repository = callPackage ./build-maven-repository.nix { };

     

       477
       477
       -
       in stdenv.mkDerivation rec {

     

       506
       506
       +
       let

     

       507
       507
       +
         repository = callPackage ./build-maven-repository.nix { };

     

       508
       508
       +
       in

     

       509
       509
       +
       stdenv.mkDerivation rec {

     

       478
       510
        
         pname = "maven-demo";

     

       479
       511
        
         version = "1.0";

     

       480
       512
        
       

     

       481
       481
       -
         src = builtins.fetchTarball

     

       482
       482
       -
           "https://github.com/fzakaria/nixos-maven-example/archive/main.tar.gz";

     

       513
       513
       +
         src = builtins.fetchTarball "https://github.com/fzakaria/nixos-maven-example/archive/main.tar.gz";

     

       483
       514
        
         nativeBuildInputs = [ makeWrapper ];

     

       484
       515
        
         buildInputs = [ maven ];

     

       485
       516

+4 -4

doc/languages-frameworks/neovim.section.md

···

       91
       91
        
       You can explore the configuration with`nix repl` to discover these options and

     

       92
       92
        
       override them. For instance:

     

       93
       93
        
       ```nix

     

       94
       94
       -
       neovim.overrideAttrs(oldAttrs: {

     

       95
       95
       -
          autowrapRuntimeDeps = false;

     

       94
       94
       +
       neovim.overrideAttrs (oldAttrs: {

     

       95
       95
       +
         autowrapRuntimeDeps = false;

     

       96
       96
        
       })

     

       97
       97
        
       ```

     

       98
       98
        
       

     
···

       117
       117
        
       For instance:

     

       118
       118
        
       ```nix

     

       119
       119
        
       {

     

       120
       120
       -
       rtp-nvim = neovimUtils.buildNeovimPlugin {

     

       120
       120
       +
         rtp-nvim = neovimUtils.buildNeovimPlugin {

     

       121
       121
        
           luaAttr = luaPackages.rtp-nvim;

     

       122
       122
       -
       };

     

       122
       122
       +
         };

     

       123
       123
        
       }

     

       124
       124
        
       ```

     

       125
       125
        
       To update these packages, you should use the lua updater rather than vim's.

+29 -13

doc/languages-frameworks/nim.section.md

···

       7
       7
        
       

     

       8
       8
        
       The following example shows a Nim program that depends only on Nim libraries:

     

       9
       9
        
       ```nix

     

       10
       10
       -
       { lib, buildNimPackage, fetchFromGitHub }:

     

       10
       10
       +
       {

     

       11
       11
       +
         lib,

     

       12
       12
       +
         buildNimPackage,

     

       13
       13
       +
         fetchFromGitHub,

     

       14
       14
       +
       }:

     

       11
       15
        
       

     

       12
       16
        
       buildNimPackage (finalAttrs: {

     

       13
       17
        
         pname = "ttop";

     
···

       91
       95
        
       ```nix

     

       92
       96
        
       pkgs.nitter.overrideNimAttrs {

     

       93
       97
        
         # using a different source which has different dependencies from the standard package

     

       94
       94
       -
         src = pkgs.fetchFromGithub { /* … */ };

     

       98
       98
       +
         src = pkgs.fetchFromGithub {

     

       99
       99
       +
           # …

     

       100
       100
       +
         };

     

       95
       101
        
         # new lock file generated from the source

     

       96
       102
        
         lockFile = ./custom-lock.json;

     

       97
       103
        
       }

     
···

       104
       110
        
       

     

       105
       111
        
       For example, to propagate a dependency on SDL2 for lockfiles that select the Nim `sdl2` library, an overlay is added to the set in the `nim-overrides.nix` file:

     

       106
       112
        
       ```nix

     

       107
       107
       -
       { lib

     

       108
       108
       -
       /* … */

     

       109
       109
       -
       , SDL2

     

       110
       110
       -
       /* … */

     

       113
       113
       +
       {

     

       114
       114
       +
         lib,

     

       115
       115
       +
         # …

     

       116
       116
       +
         SDL2,

     

       117
       117
       +
       # …

     

       111
       118
        
       }:

     

       112
       119
        
       

     

       113
       120
        
       {

     

       114
       114
       -
         /* … */

     

       121
       121
       +
         # …

     

       115
       122
        
         sdl2 =

     

       116
       123
        
           lockAttrs:

     

       117
       117
       -
           { buildInputs ? [ ], ... }:

     

       124
       124
       +
           {

     

       125
       125
       +
             buildInputs ? [ ],

     

       126
       126
       +
             ...

     

       127
       127
       +
           }:

     

       118
       128
        
           {

     

       119
       129
        
             buildInputs = buildInputs ++ [ SDL2 ];

     

       120
       130
        
           };

     

       121
       121
       -
         /* … */

     

       131
       131
       +
         # …

     

       122
       132
        
       }

     

       123
       133
        
       ```

     

       124
       134
        
       

     
···

       132
       142
        
       

     

       133
       143
        
       Override a package internal to its definition:

     

       134
       144
        
       ```nix

     

       135
       135
       -
       { lib, buildNimPackage, nimOverrides, libressl }:

     

       145
       145
       +
       {

     

       146
       146
       +
         lib,

     

       147
       147
       +
         buildNimPackage,

     

       148
       148
       +
         nimOverrides,

     

       149
       149
       +
         libressl,

     

       150
       150
       +
       }:

     

       136
       151
        
       

     

       137
       152
        
       let

     

       138
       153
        
         buildNimPackage' = buildNimPackage.override {

     

       139
       154
        
           nimOverrides = nimOverrides.override { openssl = libressl; };

     

       140
       155
        
         };

     

       141
       141
       -
       in buildNimPackage' (finalAttrs: {

     

       156
       156
       +
       in

     

       157
       157
       +
       buildNimPackage' (finalAttrs: {

     

       142
       158
        
         pname = "foo";

     

       143
       159
        
         # …

     

       144
       160
        
       })

     

       145
       145
       -
       

     

       146
       161
        
       ```

     

       147
       162
        
       

     

       148
       163
        
       Override a package externally:

     

       149
       164
        
       ```nix

     

       150
       150
       -
       { pkgs }: {

     

       165
       165
       +
       { pkgs }:

     

       166
       166
       +
       {

     

       151
       167
        
         foo = pkgs.foo.override {

     

       152
       168
        
           buildNimPackage = pkgs.buildNimPackage.override {

     

       153
       169
        
             nimOverrides = pkgs.nimOverrides.override { openssl = libressl; };

+30 -13

doc/languages-frameworks/ocaml.section.md

···

       12
       12
        
       For example:

     

       13
       13
        
       ```nix

     

       14
       14
        
       let

     

       15
       15
       -
        pkgs = import <nixpkgs> {};

     

       16
       16
       -
        # choose the ocaml version you want to use

     

       17
       17
       -
        ocamlPackages = pkgs.ocaml-ng.ocamlPackages_4_12;

     

       15
       15
       +
         pkgs = import <nixpkgs> { };

     

       16
       16
       +
         # choose the ocaml version you want to use

     

       17
       17
       +
         ocamlPackages = pkgs.ocaml-ng.ocamlPackages_4_12;

     

       18
       18
        
       in

     

       19
       19
        
       pkgs.mkShell {

     

       20
       20
        
         # build tools

     

       21
       21
       -
         nativeBuildInputs = with ocamlPackages; [ ocaml findlib dune_2 ocaml-lsp ];

     

       21
       21
       +
         nativeBuildInputs = with ocamlPackages; [

     

       22
       22
       +
           ocaml

     

       23
       23
       +
           findlib

     

       24
       24
       +
           dune_2

     

       25
       25
       +
           ocaml-lsp

     

       26
       26
       +
         ];

     

       22
       27
        
         # dependencies

     

       23
       28
        
         buildInputs = with ocamlPackages; [ ocamlgraph ];

     

       24
       29
        
       }

     
···

       58
       63
        
         generates.

     

       59
       64
        
       

     

       60
       65
        
       ```nix

     

       61
       61
       -
       { lib,

     

       66
       66
       +
       {

     

       67
       67
       +
         lib,

     

       62
       68
        
         fetchFromGitHub,

     

       63
       69
        
         buildDunePackage,

     

       64
       70
        
         ocaml,

     
···

       66
       72
        
         alcotest,

     

       67
       73
        
         result,

     

       68
       74
        
         bigstringaf,

     

       69
       69
       -
         ppx_let }:

     

       75
       75
       +
         ppx_let,

     

       76
       76
       +
       }:

     

       70
       77
        
       

     

       71
       78
        
       buildDunePackage rec {

     

       72
       79
        
         pname = "angstrom";

     
···

       75
       82
        
         minimalOCamlVersion = "4.04";

     

       76
       83
        
       

     

       77
       84
        
         src = fetchFromGitHub {

     

       78
       78
       -
           owner  = "inhabitedtype";

     

       79
       79
       -
           repo   = pname;

     

       80
       80
       -
           rev    = version;

     

       81
       81
       -
           hash   = "sha256-MK8o+iPGANEhrrTc1Kz9LBilx2bDPQt7Pp5P2libucI=";

     

       85
       85
       +
           owner = "inhabitedtype";

     

       86
       86
       +
           repo = pname;

     

       87
       87
       +
           rev = version;

     

       88
       88
       +
           hash = "sha256-MK8o+iPGANEhrrTc1Kz9LBilx2bDPQt7Pp5P2libucI=";

     

       82
       89
        
         };

     

       83
       90
        
       

     

       84
       84
       -
         checkInputs = [ alcotest ppx_let ];

     

       91
       91
       +
         checkInputs = [

     

       92
       92
       +
           alcotest

     

       93
       93
       +
           ppx_let

     

       94
       94
       +
         ];

     

       85
       95
        
         buildInputs = [ ocaml-syntax-shims ];

     

       86
       86
       -
         propagatedBuildInputs = [ bigstringaf result ];

     

       96
       96
       +
         propagatedBuildInputs = [

     

       97
       97
       +
           bigstringaf

     

       98
       98
       +
           result

     

       99
       99
       +
         ];

     

       87
       100
        
         doCheck = lib.versionAtLeast ocaml.version "4.05";

     

       88
       101
        
       

     

       89
       102
        
         meta = {

     
···

       98
       111
        
       Here is a second example, this time using a source archive generated with `dune-release`. It is a good idea to use this archive when it is available as it will usually contain substituted variables such as a `%%VERSION%%` field. This library does not depend on any other OCaml library and no tests are run after building it.

     

       99
       112
        
       

     

       100
       113
        
       ```nix

     

       101
       101
       -
       { lib, fetchurl, buildDunePackage }:

     

       114
       114
       +
       {

     

       115
       115
       +
         lib,

     

       116
       116
       +
         fetchurl,

     

       117
       117
       +
         buildDunePackage,

     

       118
       118
       +
       }:

     

       102
       119
        
       

     

       103
       120
        
       buildDunePackage rec {

     

       104
       121
        
         pname = "wtf8";

+3 -1

doc/languages-frameworks/octave.section.md

···

       39
       39
        
       This will also work in a `shell.nix` file.

     

       40
       40
        
       

     

       41
       41
        
       ```nix

     

       42
       42
       -
       { pkgs ? import <nixpkgs> { }}:

     

       42
       42
       +
       {

     

       43
       43
       +
         pkgs ? import <nixpkgs> { },

     

       44
       44
       +
       }:

     

       43
       45
        
       

     

       44
       46
        
       pkgs.mkShell {

     

       45
       47
        
         nativeBuildInputs = with pkgs; [

+20 -4

doc/languages-frameworks/perl.section.md

···

       51
       51
        
       ```nix

     

       52
       52
        
       {

     

       53
       53
        
         foo = import ../path/to/foo.nix {

     

       54
       54
       -
           inherit stdenv fetchurl /* ... */;

     

       54
       54
       +
           inherit

     

       55
       55
       +
             stdenv

     

       56
       56
       +
             fetchurl # ...

     

       57
       57
       +
             ;

     

       55
       58
        
           inherit (perlPackages) ClassC3;

     

       56
       59
        
         };

     

       57
       60
        
       }

     
···

       74
       77
        
       `buildPerlPackage` is built on top of `stdenv`, so everything can be customised in the usual way. For instance, the `BerkeleyDB` module has a `preConfigure` hook to generate a configuration file used by `Makefile.PL`:

     

       75
       78
        
       

     

       76
       79
        
       ```nix

     

       77
       77
       -
       { buildPerlPackage, fetchurl, db }:

     

       80
       80
       +
       {

     

       81
       81
       +
         buildPerlPackage,

     

       82
       82
       +
         fetchurl,

     

       83
       83
       +
         db,

     

       84
       84
       +
       }:

     

       78
       85
        
       

     

       79
       86
        
       buildPerlPackage rec {

     

       80
       87
        
         pname = "BerkeleyDB";

     
···

       104
       111
        
             hash = "sha256-ASO9rV/FzJYZ0BH572Fxm2ZrFLMZLFATJng1NuU4FHc=";

     

       105
       112
        
           };

     

       106
       113
        
           propagatedBuildInputs = [

     

       107
       107
       -
             ClassC3 ClassInspector TestException MROCompat

     

       114
       114
       +
             ClassC3

     

       115
       115
       +
             ClassInspector

     

       116
       116
       +
             TestException

     

       117
       117
       +
             MROCompat

     

       108
       118
        
           ];

     

       109
       119
        
         };

     

       110
       120
        
       }

     
···

       113
       123
        
       On Darwin, if a script has too many `-Idir` flags in its first line (its “shebang line”), it will not run. This can be worked around by calling the `shortenPerlShebang` function from the `postInstall` phase:

     

       114
       124
        
       

     

       115
       125
        
       ```nix

     

       116
       116
       -
       { lib, stdenv, buildPerlPackage, fetchurl, shortenPerlShebang }:

     

       126
       126
       +
       {

     

       127
       127
       +
         lib,

     

       128
       128
       +
         stdenv,

     

       129
       129
       +
         buildPerlPackage,

     

       130
       130
       +
         fetchurl,

     

       131
       131
       +
         shortenPerlShebang,

     

       132
       132
       +
       }:

     

       117
       133
        
       

     

       118
       134
        
       {

     

       119
       135
        
         ImageExifTool = buildPerlPackage {

+91 -48

doc/languages-frameworks/php.section.md

···

       45
       45
        
       ImageMagick enabled:

     

       46
       46
        
       

     

       47
       47
        
       ```nix

     

       48
       48
       -
       php.withExtensions ({ enabled, all }:

     

       49
       49
       -
         enabled ++ [ all.imagick ])

     

       48
       48
       +
       php.withExtensions ({ enabled, all }: enabled ++ [ all.imagick ])

     

       50
       49
        
       ```

     

       51
       50
        
       

     

       52
       51
        
       To exclude some, but not all, of the default extensions, you can

     

       53
       52
        
       filter the `enabled` list like this:

     

       54
       53
        
       

     

       55
       54
        
       ```nix

     

       56
       56
       -
       php.withExtensions ({ enabled, all }:

     

       57
       57
       -
         (lib.filter (e: e != php.extensions.opcache) enabled)

     

       58
       58
       -
         ++ [ all.imagick ])

     

       55
       55
       +
       php.withExtensions (

     

       56
       56
       +
         { enabled, all }: (lib.filter (e: e != php.extensions.opcache) enabled) ++ [ all.imagick ]

     

       57
       57
       +
       )

     

       59
       58
        
       ```

     

       60
       59
        
       

     

       61
       60
        
       To build your list of extensions from the ground up, you can

     

       62
       61
        
       ignore `enabled`:

     

       63
       62
        
       

     

       64
       63
        
       ```nix

     

       65
       65
       -
       php.withExtensions ({ all, ... }: with all; [ imagick opcache ])

     

       64
       64
       +
       php.withExtensions (

     

       65
       65
       +
         { all, ... }:

     

       66
       66
       +
         with all;

     

       67
       67
       +
         [

     

       68
       68
       +
           imagick

     

       69
       69
       +
           opcache

     

       70
       70
       +
         ]

     

       71
       71
       +
       )

     

       66
       72
        
       ```

     

       67
       73
        
       

     

       68
       74
        
       `php.withExtensions` provides extensions by wrapping a minimal php

     
···

       82
       88
        
       

     

       83
       89
        
       ```nix

     

       84
       90
        
       php.buildEnv {

     

       85
       85
       -
         extensions = { all, ... }: with all; [ imagick opcache ];

     

       91
       91
       +
         extensions =

     

       92
       92
       +
           { all, ... }:

     

       93
       93
       +
           with all;

     

       94
       94
       +
           [

     

       95
       95
       +
             imagick

     

       96
       96
       +
             opcache

     

       97
       97
       +
           ];

     

       86
       98
        
         extraConfig = "memory_limit=256M";

     

       87
       99
        
       }

     

       88
       100
        
       ```

     
···

       94
       106
        
       

     

       95
       107
        
       ```nix

     

       96
       108
        
       let

     

       97
       97
       -
         myPhp = php.withExtensions ({ all, ... }: with all; [ imagick opcache ]);

     

       98
       98
       -
       in {

     

       109
       109
       +
         myPhp = php.withExtensions (

     

       110
       110
       +
           { all, ... }:

     

       111
       111
       +
           with all;

     

       112
       112
       +
           [

     

       113
       113
       +
             imagick

     

       114
       114
       +
             opcache

     

       115
       115
       +
           ]

     

       116
       116
       +
         );

     

       117
       117
       +
       in

     

       118
       118
       +
       {

     

       99
       119
        
         services.phpfpm.pools."foo".phpPackage = myPhp;

     

       100
       120
        
       }

     

       101
       121
        
       ```

     
···

       103
       123
        
       ```nix

     

       104
       124
        
       let

     

       105
       125
        
         myPhp = php.buildEnv {

     

       106
       106
       -
           extensions = { all, ... }: with all; [ imagick opcache ];

     

       126
       126
       +
           extensions =

     

       127
       127
       +
             { all, ... }:

     

       128
       128
       +
             with all;

     

       129
       129
       +
             [

     

       130
       130
       +
               imagick

     

       131
       131
       +
               opcache

     

       132
       132
       +
             ];

     

       107
       133
        
           extraConfig = "memory_limit=256M";

     

       108
       134
        
         };

     

       109
       109
       -
       in {

     

       135
       135
       +
       in

     

       136
       136
       +
       {

     

       110
       137
        
         services.phpfpm.pools."foo".phpPackage = myPhp;

     

       111
       138
        
       }

     

       112
       139
        
       ```

     
···

       132
       159
        
       Example of building `composer` with additional extensions:

     

       133
       160
        
       

     

       134
       161
        
       ```nix

     

       135
       135
       -
       (php.withExtensions ({ all, enabled }:

     

       136
       136
       -
         enabled ++ (with all; [ imagick redis ]))

     

       137
       137
       -
       ).packages.composer

     

       162
       162
       +
       (php.withExtensions (

     

       163
       163
       +
         { all, enabled }:

     

       164
       164
       +
         enabled

     

       165
       165
       +
         ++ (with all; [

     

       166
       166
       +
           imagick

     

       167
       167
       +
           redis

     

       168
       168
       +
         ])

     

       169
       169
       +
       )).packages.composer

     

       138
       170
        
       ```

     

       139
       171
        
       

     

       140
       172
        
       ### Overriding PHP packages {#ssec-php-user-guide-overriding-packages}

     
···

       148
       180
        
         packageOverrides = final: prev: {

     

       149
       181
        
           extensions = prev.extensions // {

     

       150
       182
        
             mysqlnd = prev.extensions.mysqlnd.overrideAttrs (attrs: {

     

       151
       151
       -
               patches = attrs.patches or [] ++ [

     

       183
       183
       +
               patches = attrs.patches or [ ] ++ [

     

       152
       184
        
                 # ...

     

       153
       185
        
               ];

     

       154
       186
        
             });

     
···

       235
       267
        
       

     

       236
       268
        
         # PHP version containing the `ast` extension enabled

     

       237
       269
        
         php = php.buildEnv {

     

       238
       238
       -
           extensions = ({ enabled, all }: enabled ++ (with all; [

     

       239
       239
       -
             ast

     

       240
       240
       -
           ]));

     

       270
       270
       +
           extensions = (

     

       271
       271
       +
             { enabled, all }:

     

       272
       272
       +
             enabled

     

       273
       273
       +
             ++ (with all; [

     

       274
       274
       +
               ast

     

       275
       275
       +
             ])

     

       276
       276
       +
           );

     

       241
       277
        
         };

     

       242
       278
        
       

     

       243
       279
        
         # The composer vendor hash

     
···

       259
       295
        
       separate functions and hooks:

     

       260
       296
        
       

     

       261
       297
        
       ```nix

     

       262
       262
       -
       { stdenvNoCC, fetchFromGitHub, php }:

     

       298
       298
       +
       {

     

       299
       299
       +
         stdenvNoCC,

     

       300
       300
       +
         fetchFromGitHub,

     

       301
       301
       +
         php,

     

       302
       302
       +
       }:

     

       263
       303
        
       

     

       264
       264
       -
       stdenvNoCC.mkDerivation (finalAttrs:

     

       265
       265
       -
       let

     

       266
       266
       -
         src = fetchFromGitHub {

     

       267
       267
       -
           owner = "git-owner";

     

       268
       268
       -
           repo = "git-repo";

     

       269
       269
       -
           rev = finalAttrs.version;

     

       270
       270
       -
           hash = "sha256-VcQRSss2dssfkJ+iUb5qT+FJ10GHiFDzySigcmuVI+8=";

     

       271
       271
       -
         };

     

       272
       272
       -
       in {

     

       273
       273
       -
         inherit src;

     

       274
       274
       -
         pname = "php-app";

     

       275
       275
       -
         version = "1.0.0";

     

       304
       304
       +
       stdenvNoCC.mkDerivation (

     

       305
       305
       +
         finalAttrs:

     

       306
       306
       +
         let

     

       307
       307
       +
           src = fetchFromGitHub {

     

       308
       308
       +
             owner = "git-owner";

     

       309
       309
       +
             repo = "git-repo";

     

       310
       310
       +
             rev = finalAttrs.version;

     

       311
       311
       +
             hash = "sha256-VcQRSss2dssfkJ+iUb5qT+FJ10GHiFDzySigcmuVI+8=";

     

       312
       312
       +
           };

     

       313
       313
       +
         in

     

       314
       314
       +
         {

     

       315
       315
       +
           inherit src;

     

       316
       316
       +
           pname = "php-app";

     

       317
       317
       +
           version = "1.0.0";

     

       276
       318
        
       

     

       277
       277
       -
         buildInputs = [ php ];

     

       319
       319
       +
           buildInputs = [ php ];

     

       278
       320
        
       

     

       279
       279
       -
         nativeBuildInputs = [

     

       280
       280
       -
           php.packages.composer

     

       281
       281
       -
           # This hook will use the attribute `composerRepository`

     

       282
       282
       -
           php.composerHooks.composerInstallHook

     

       283
       283
       -
         ];

     

       321
       321
       +
           nativeBuildInputs = [

     

       322
       322
       +
             php.packages.composer

     

       323
       323
       +
             # This hook will use the attribute `composerRepository`

     

       324
       324
       +
             php.composerHooks.composerInstallHook

     

       325
       325
       +
           ];

     

       284
       326
        
       

     

       285
       285
       -
         composerRepository = php.mkComposerRepository {

     

       286
       286
       -
           inherit (finalAttrs) pname version src;

     

       287
       287
       -
           composerNoDev = true;

     

       288
       288
       -
           composerNoPlugins = true;

     

       289
       289
       -
           composerNoScripts = true;

     

       290
       290
       -
           # Specifying a custom composer.lock since it is not present in the sources.

     

       291
       291
       -
           composerLock = ./composer.lock;

     

       292
       292
       -
           # The composer vendor hash

     

       293
       293
       -
           vendorHash = "sha256-86s/F+/5cBAwBqZ2yaGRM5rTGLmou5//aLRK5SA0WiQ=";

     

       294
       294
       -
         };

     

       295
       295
       -
       })

     

       327
       327
       +
           composerRepository = php.mkComposerRepository {

     

       328
       328
       +
             inherit (finalAttrs) pname version src;

     

       329
       329
       +
             composerNoDev = true;

     

       330
       330
       +
             composerNoPlugins = true;

     

       331
       331
       +
             composerNoScripts = true;

     

       332
       332
       +
             # Specifying a custom composer.lock since it is not present in the sources.

     

       333
       333
       +
             composerLock = ./composer.lock;

     

       334
       334
       +
             # The composer vendor hash

     

       335
       335
       +
             vendorHash = "sha256-86s/F+/5cBAwBqZ2yaGRM5rTGLmou5//aLRK5SA0WiQ=";

     

       336
       336
       +
           };

     

       337
       337
       +
         }

     

       338
       338
       +
       )

     

       296
       339
        
       ```

+6 -3

doc/languages-frameworks/pkg-config.section.md

···

       17
       17
        
       { pkg-config, testers, ... }:

     

       18
       18
        
       

     

       19
       19
        
       stdenv.mkDerivation (finalAttrs: {

     

       20
       20
       -
         /* ... */

     

       20
       20
       +
         # ...

     

       21
       21
        
       

     

       22
       22
       -
         nativeBuildInputs = [ pkg-config validatePkgConfig ];

     

       22
       22
       +
         nativeBuildInputs = [

     

       23
       23
       +
           pkg-config

     

       24
       24
       +
           validatePkgConfig

     

       25
       25
       +
         ];

     

       23
       26
        
       

     

       24
       27
        
         passthru.tests.pkg-config = testers.hasPkgConfigModules {

     

       25
       28
        
           package = finalAttrs.finalPackage;

     
···

       27
       30
        
         };

     

       28
       31
        
       

     

       29
       32
        
         meta = {

     

       30
       30
       -
           /* ... */

     

       33
       33
       +
           # ...

     

       31
       34
        
           pkgConfigModules = [ "miniz" ];

     

       32
       35
        
         };

     

       33
       36
        
       })

+234 -160

doc/languages-frameworks/python.section.md

···

       78
       78
        
       The following is an example:

     

       79
       79
        
       

     

       80
       80
        
       ```nix

     

       81
       81
       -
       { lib

     

       82
       82
       -
       , buildPythonPackage

     

       83
       83
       -
       , fetchPypi

     

       81
       81
       +
       {

     

       82
       82
       +
         lib,

     

       83
       83
       +
         buildPythonPackage,

     

       84
       84
       +
         fetchPypi,

     

       84
       85
        
       

     

       85
       85
       -
       # build-system

     

       86
       86
       -
       , setuptools

     

       87
       87
       -
       , setuptools-scm

     

       86
       86
       +
         # build-system

     

       87
       87
       +
         setuptools,

     

       88
       88
       +
         setuptools-scm,

     

       88
       89
        
       

     

       89
       89
       -
       # dependencies

     

       90
       90
       -
       , attrs

     

       91
       91
       -
       , pluggy

     

       92
       92
       -
       , py

     

       93
       93
       -
       , setuptools

     

       94
       94
       -
       , six

     

       90
       90
       +
         # dependencies

     

       91
       91
       +
         attrs,

     

       92
       92
       +
         pluggy,

     

       93
       93
       +
         py,

     

       94
       94
       +
         setuptools,

     

       95
       95
       +
         six,

     

       95
       96
        
       

     

       96
       96
       -
       # tests

     

       97
       97
       -
       , hypothesis

     

       98
       98
       -
        }:

     

       97
       97
       +
         # tests

     

       98
       98
       +
         hypothesis,

     

       99
       99
       +
       }:

     

       99
       100
        
       

     

       100
       101
        
       buildPythonPackage rec {

     

       101
       102
        
         pname = "pytest";

     
···

       134
       135
        
           description = "Framework for writing tests";

     

       135
       136
        
           homepage = "https://github.com/pytest-dev/pytest";

     

       136
       137
        
           license = lib.licenses.mit;

     

       137
       137
       -
           maintainers = with lib.maintainers; [ domenkozar lovek323 madjar lsix ];

     

       138
       138
       +
           maintainers = with lib.maintainers; [

     

       139
       139
       +
             domenkozar

     

       140
       140
       +
             lovek323

     

       141
       141
       +
             madjar

     

       142
       142
       +
             lsix

     

       143
       143
       +
           ];

     

       138
       144
        
         };

     

       139
       145
        
       }

     

       140
       146
        
       ```

     
···

       231
       237
        
       the overrides for packages in the package set.

     

       232
       238
        
       

     

       233
       239
        
       ```nix

     

       234
       234
       -
       with import <nixpkgs> {};

     

       240
       240
       +
       with import <nixpkgs> { };

     

       235
       241
        
       

     

       236
       236
       -
       (let

     

       237
       237
       -
         python = let

     

       238
       238
       -
           packageOverrides = self: super: {

     

       239
       239
       -
             pandas = super.pandas.overridePythonAttrs(old: rec {

     

       240
       240
       -
               version = "0.19.1";

     

       241
       241
       -
               src =  fetchPypi {

     

       242
       242
       -
                 pname = "pandas";

     

       243
       243
       -
                 inherit version;

     

       244
       244
       -
                 hash = "sha256-JQn+rtpy/OA2deLszSKEuxyttqBzcAil50H+JDHUdCE=";

     

       242
       242
       +
       (

     

       243
       243
       +
         let

     

       244
       244
       +
           python =

     

       245
       245
       +
             let

     

       246
       246
       +
               packageOverrides = self: super: {

     

       247
       247
       +
                 pandas = super.pandas.overridePythonAttrs (old: rec {

     

       248
       248
       +
                   version = "0.19.1";

     

       249
       249
       +
                   src = fetchPypi {

     

       250
       250
       +
                     pname = "pandas";

     

       251
       251
       +
                     inherit version;

     

       252
       252
       +
                     hash = "sha256-JQn+rtpy/OA2deLszSKEuxyttqBzcAil50H+JDHUdCE=";

     

       253
       253
       +
                   };

     

       254
       254
       +
                 });

     

       245
       255
        
               };

     

       246
       246
       -
             });

     

       247
       247
       -
           };

     

       248
       248
       -
         in pkgs.python3.override {inherit packageOverrides; self = python;};

     

       256
       256
       +
             in

     

       257
       257
       +
             pkgs.python3.override {

     

       258
       258
       +
               inherit packageOverrides;

     

       259
       259
       +
               self = python;

     

       260
       260
       +
             };

     

       249
       261
        
       

     

       250
       250
       -
       in python.withPackages(ps: [ ps.blaze ])).env

     

       262
       262
       +
         in

     

       263
       263
       +
         python.withPackages (ps: [ ps.blaze ])

     

       264
       264
       +
       ).env

     

       251
       265
        
       ```

     

       252
       266
        
       

     

       253
       267
        
       The next example shows a non trivial overriding of the `blas` implementation to

     
···

       258
       272
        
         python3MyBlas = pkgs.python3.override {

     

       259
       273
        
           packageOverrides = self: super: {

     

       260
       274
        
             # We need toPythonModule for the package set to evaluate this

     

       261
       261
       -
             blas = super.toPythonModule(super.pkgs.blas.override {

     

       262
       262
       -
               blasProvider = super.pkgs.mkl;

     

       263
       263
       -
             });

     

       264
       264
       -
             lapack = super.toPythonModule(super.pkgs.lapack.override {

     

       265
       265
       -
               lapackProvider = super.pkgs.mkl;

     

       266
       266
       -
             });

     

       275
       275
       +
             blas = super.toPythonModule (

     

       276
       276
       +
               super.pkgs.blas.override {

     

       277
       277
       +
                 blasProvider = super.pkgs.mkl;

     

       278
       278
       +
               }

     

       279
       279
       +
             );

     

       280
       280
       +
             lapack = super.toPythonModule (

     

       281
       281
       +
               super.pkgs.lapack.override {

     

       282
       282
       +
                 lapackProvider = super.pkgs.mkl;

     

       283
       283
       +
               }

     

       284
       284
       +
             );

     

       267
       285
        
           };

     

       268
       286
        
         };

     

       269
       287
        
       }

     
···

       290
       308
        
       specifying an interpreter version), like this:

     

       291
       309
        
       

     

       292
       310
        
       ```nix

     

       293
       293
       -
       { lib

     

       294
       294
       -
       , python3Packages

     

       295
       295
       -
       , fetchPypi

     

       311
       311
       +
       {

     

       312
       312
       +
         lib,

     

       313
       313
       +
         python3Packages,

     

       314
       314
       +
         fetchPypi,

     

       296
       315
        
       }:

     

       297
       316
        
       

     

       298
       317
        
       python3Packages.buildPythonApplication rec {

     
···

       302
       321
        
       

     

       303
       322
        
         src = fetchPypi {

     

       304
       323
        
           inherit pname version;

     

       305
       305
       -
           hash  = "sha256-Pe229rT0aHwA98s+nTHQMEFKZPo/yw6sot8MivFDvAw=";

     

       324
       324
       +
           hash = "sha256-Pe229rT0aHwA98s+nTHQMEFKZPo/yw6sot8MivFDvAw=";

     

       306
       325
        
         };

     

       307
       326
        
       

     

       308
       327
        
         build-system = with python3Packages; [

     
···

       356
       375
        
       

     

       357
       376
        
       ```nix

     

       358
       377
        
       {

     

       359
       359
       -
         opencv = toPythonModule (pkgs.opencv.override {

     

       360
       360
       -
           enablePython = true;

     

       361
       361
       -
           pythonPackages = self;

     

       362
       362
       -
         });

     

       378
       378
       +
         opencv = toPythonModule (

     

       379
       379
       +
           pkgs.opencv.override {

     

       380
       380
       +
             enablePython = true;

     

       381
       381
       +
             pythonPackages = self;

     

       382
       382
       +
           }

     

       383
       383
       +
         );

     

       363
       384
        
       }

     

       364
       385
        
       ```

     

       365
       386
        
       

     
···

       394
       415
        
       

     

       395
       416
        
       Note that overriding packages deeper in the dependency graph _can_ work, but it's not the primary use case and overriding existing packages can make others break in unexpected ways.

     

       396
       417
        
       

     

       397
       397
       -
       ``` nix

     

       398
       398
       -
       { pkgs ? import <nixpkgs> { } }:

     

       418
       418
       +
       ```nix

     

       419
       419
       +
       {

     

       420
       420
       +
         pkgs ? import <nixpkgs> { },

     

       421
       421
       +
       }:

     

       399
       422
        
       

     

       400
       423
        
       let

     

       401
       424
        
         pyproject = pkgs.lib.importTOML ./pyproject.toml;

     
···

       418
       441
        
           };

     

       419
       442
        
         };

     

       420
       443
        
       

     

       421
       421
       -
         pythonEnv =  myPython.withPackages (ps: [ ps.my-editable ]);

     

       444
       444
       +
         pythonEnv = myPython.withPackages (ps: [ ps.my-editable ]);

     

       422
       445
        
       

     

       423
       423
       -
       in pkgs.mkShell {

     

       446
       446
       +
       in

     

       447
       447
       +
       pkgs.mkShell {

     

       424
       448
        
         packages = [ pythonEnv ];

     

       425
       449
        
       }

     

       426
       450
        
       ```

     
···

       432
       456
        
       Saving the following as `default.nix`

     

       433
       457
        
       

     

       434
       458
        
       ```nix

     

       435
       435
       -
       with import <nixpkgs> {};

     

       459
       459
       +
       with import <nixpkgs> { };

     

       436
       460
        
       

     

       437
       461
        
       python3.buildEnv.override {

     

       438
       462
        
         extraLibs = [ python3Packages.pyramid ];

     
···

       453
       477
        
       running `nix-shell` with the following `shell.nix`

     

       454
       478
        
       

     

       455
       479
        
       ```nix

     

       456
       456
       -
       with import <nixpkgs> {};

     

       480
       480
       +
       with import <nixpkgs> { };

     

       457
       481
        
       

     

       458
       482
        
       (python3.buildEnv.override {

     

       459
       483
        
         extraLibs = with python3Packages; [

     
···

       483
       507
        
       example for the Pyramid Web Framework environment can be written like this:

     

       484
       508
        
       

     

       485
       509
        
       ```nix

     

       486
       486
       -
       with import <nixpkgs> {};

     

       510
       510
       +
       with import <nixpkgs> { };

     

       487
       511
        
       

     

       488
       512
        
       python.withPackages (ps: [ ps.pyramid ])

     

       489
       513
        
       ```

     
···

       493
       517
        
       `pythonPackages`. But you can also easily switch to using python3:

     

       494
       518
        
       

     

       495
       519
        
       ```nix

     

       496
       496
       -
       with import <nixpkgs> {};

     

       520
       520
       +
       with import <nixpkgs> { };

     

       497
       521
        
       

     

       498
       522
        
       python3.withPackages (ps: [ ps.pyramid ])

     

       499
       523
        
       ```

     
···

       505
       529
        
       thus be also written like this:

     

       506
       530
        
       

     

       507
       531
        
       ```nix

     

       508
       508
       -
       with import <nixpkgs> {};

     

       532
       532
       +
       with import <nixpkgs> { };

     

       509
       533
        
       

     

       510
       510
       -
       (python3.withPackages (ps: with ps; [

     

       511
       511
       -
         numpy

     

       512
       512
       -
         requests

     

       513
       513
       -
       ])).env

     

       534
       534
       +
       (python3.withPackages (

     

       535
       535
       +
         ps: with ps; [

     

       536
       536
       +
           numpy

     

       537
       537
       +
           requests

     

       538
       538
       +
         ]

     

       539
       539
       +
       )).env

     

       514
       540
        
       ```

     

       515
       541
        
       

     

       516
       542
        
       In contrast to [`python.buildEnv`](#python.buildenv-function), [`python.withPackages`](#python.withpackages-function) does not support the

     
···

       758
       784
        
       in an environment. We can add a `shell.nix` file describing our dependencies:

     

       759
       785
        
       

     

       760
       786
        
       ```nix

     

       761
       761
       -
       with import <nixpkgs> {};

     

       762
       762
       -
       (python312.withPackages (ps: with ps; [

     

       763
       763
       -
         numpy

     

       764
       764
       -
         toolz

     

       765
       765
       -
       ])).env

     

       787
       787
       +
       with import <nixpkgs> { };

     

       788
       788
       +
       (python312.withPackages (

     

       789
       789
       +
         ps: with ps; [

     

       790
       790
       +
           numpy

     

       791
       791
       +
           toolz

     

       792
       792
       +
         ]

     

       793
       793
       +
       )).env

     

       766
       794
        
       ```

     

       767
       795
        
       

     

       768
       796
        
       And then at the command line, just typing `nix-shell` produces the same

     
···

       785
       813
        
       To combine this with `mkShell` you can:

     

       786
       814
        
       

     

       787
       815
        
       ```nix

     

       788
       788
       -
       with import <nixpkgs> {};

     

       816
       816
       +
       with import <nixpkgs> { };

     

       789
       817
        
       let

     

       790
       818
        
         pythonEnv = python312.withPackages (ps: [

     

       791
       819
        
           ps.numpy

     

       792
       820
        
           ps.toolz

     

       793
       821
        
         ]);

     

       794
       794
       -
       in mkShell {

     

       822
       822
       +
       in

     

       823
       823
       +
       mkShell {

     

       795
       824
        
         packages = [

     

       796
       825
        
           pythonEnv

     

       797
       826
        
       

     
···

       868
       897
        
       on NixOS.

     

       869
       898
        
       

     

       870
       899
        
       ```nix

     

       871
       871
       -
       { # ...

     

       900
       900
       +
       {

     

       901
       901
       +
         # ...

     

       872
       902
        
       

     

       873
       903
        
         environment.systemPackages = with pkgs; [

     

       874
       874
       -
           (python310.withPackages(ps: with ps; [ numpy toolz ]))

     

       904
       904
       +
           (python310.withPackages (

     

       905
       905
       +
             ps: with ps; [

     

       906
       906
       +
               numpy

     

       907
       907
       +
               toolz

     

       908
       908
       +
             ]

     

       909
       909
       +
           ))

     

       875
       910
        
         ];

     

       876
       911
        
       }

     

       877
       912
        
       ```

     
···

       891
       926
        
       `toolz` package.

     

       892
       927
        
       

     

       893
       928
        
       ```nix

     

       894
       894
       -
       { lib

     

       895
       895
       -
       , buildPythonPackage

     

       896
       896
       -
       , fetchPypi

     

       897
       897
       -
       , setuptools

     

       929
       929
       +
       {

     

       930
       930
       +
         lib,

     

       931
       931
       +
         buildPythonPackage,

     

       932
       932
       +
         fetchPypi,

     

       933
       933
       +
         setuptools,

     

       898
       934
        
       }:

     

       899
       935
        
       

     

       900
       936
        
       buildPythonPackage rec {

     
···

       952
       988
        
       and adds it along with a `numpy` package to a Python environment.

     

       953
       989
        
       

     

       954
       990
        
       ```nix

     

       955
       955
       -
       with import <nixpkgs> {};

     

       991
       991
       +
       with import <nixpkgs> { };

     

       956
       992
        
       

     

       957
       957
       -
       ( let

     

       993
       993
       +
       (

     

       994
       994
       +
         let

     

       958
       995
        
           my_toolz = python312.pkgs.buildPythonPackage rec {

     

       959
       996
        
             pname = "toolz";

     

       960
       997
        
             version = "0.10.0";

     
···

       979
       1016
        
             };

     

       980
       1017
        
           };

     

       981
       1018
        
       

     

       982
       982
       -
         in python312.withPackages (ps: with ps; [

     

       983
       983
       -
           numpy

     

       984
       984
       -
           my_toolz

     

       985
       985
       -
         ])

     

       1019
       1019
       +
         in

     

       1020
       1020
       +
         python312.withPackages (

     

       1021
       1021
       +
           ps: with ps; [

     

       1022
       1022
       +
             numpy

     

       1023
       1023
       +
             my_toolz

     

       1024
       1024
       +
           ]

     

       1025
       1025
       +
         )

     

       986
       1026
        
       ).env

     

       987
       1027
        
       ```

     

       988
       1028
        
       

     
···

       1014
       1054
        
       order to build [`datashape`](https://github.com/blaze/datashape).

     

       1015
       1055
        
       

     

       1016
       1056
        
       ```nix

     

       1017
       1017
       -
       { lib

     

       1018
       1018
       -
       , buildPythonPackage

     

       1019
       1019
       -
       , fetchPypi

     

       1057
       1057
       +
       {

     

       1058
       1058
       +
         lib,

     

       1059
       1059
       +
         buildPythonPackage,

     

       1060
       1060
       +
         fetchPypi,

     

       1020
       1061
        
       

     

       1021
       1021
       -
       # build dependencies

     

       1022
       1022
       -
       , setuptools

     

       1062
       1062
       +
         # build dependencies

     

       1063
       1063
       +
         setuptools,

     

       1023
       1064
        
       

     

       1024
       1024
       -
       # dependencies

     

       1025
       1025
       -
       , numpy, multipledispatch, python-dateutil

     

       1065
       1065
       +
         # dependencies

     

       1066
       1066
       +
         numpy,

     

       1067
       1067
       +
         multipledispatch,

     

       1068
       1068
       +
         python-dateutil,

     

       1026
       1069
        
       

     

       1027
       1027
       -
       # tests

     

       1028
       1028
       -
       , pytestCheckHook

     

       1070
       1070
       +
         # tests

     

       1071
       1071
       +
         pytestCheckHook,

     

       1029
       1072
        
       }:

     

       1030
       1073
        
       

     

       1031
       1074
        
       buildPythonPackage rec {

     
···

       1072
       1115
        
       when building the bindings and are therefore added as [`buildInputs`](#var-stdenv-buildInputs).

     

       1073
       1116
        
       

     

       1074
       1117
        
       ```nix

     

       1075
       1075
       -
       { lib

     

       1076
       1076
       -
       , buildPythonPackage

     

       1077
       1077
       -
       , fetchPypi

     

       1078
       1078
       -
       , setuptools

     

       1079
       1079
       -
       , libxml2

     

       1080
       1080
       -
       , libxslt

     

       1118
       1118
       +
       {

     

       1119
       1119
       +
         lib,

     

       1120
       1120
       +
         buildPythonPackage,

     

       1121
       1121
       +
         fetchPypi,

     

       1122
       1122
       +
         setuptools,

     

       1123
       1123
       +
         libxml2,

     

       1124
       1124
       +
         libxslt,

     

       1081
       1125
        
       }:

     

       1082
       1126
        
       

     

       1083
       1127
        
       buildPythonPackage rec {

     
···

       1128
       1172
        
       therefore we have to set `LDFLAGS` and `CFLAGS`.

     

       1129
       1173
        
       

     

       1130
       1174
        
       ```nix

     

       1131
       1131
       -
       { lib

     

       1132
       1132
       -
       , buildPythonPackage

     

       1133
       1133
       -
       , fetchPypi

     

       1175
       1175
       +
       {

     

       1176
       1176
       +
         lib,

     

       1177
       1177
       +
         buildPythonPackage,

     

       1178
       1178
       +
         fetchPypi,

     

       1134
       1179
        
       

     

       1135
       1135
       -
       # build dependencies

     

       1136
       1136
       -
       , setuptools

     

       1180
       1180
       +
         # build dependencies

     

       1181
       1181
       +
         setuptools,

     

       1137
       1182
        
       

     

       1138
       1138
       -
       # dependencies

     

       1139
       1139
       -
       , fftw

     

       1140
       1140
       -
       , fftwFloat

     

       1141
       1141
       -
       , fftwLongDouble

     

       1142
       1142
       -
       , numpy

     

       1143
       1143
       -
       , scipy

     

       1183
       1183
       +
         # dependencies

     

       1184
       1184
       +
         fftw,

     

       1185
       1185
       +
         fftwFloat,

     

       1186
       1186
       +
         fftwLongDouble,

     

       1187
       1187
       +
         numpy,

     

       1188
       1188
       +
         scipy,

     

       1144
       1189
        
       }:

     

       1145
       1190
        
       

     

       1146
       1191
        
       buildPythonPackage rec {

     
···

       1182
       1227
        
           changelog = "https://github.com/pyFFTW/pyFFTW/releases/tag/v${version}";

     

       1183
       1228
        
           description = "Pythonic wrapper around FFTW, the FFT library, presenting a unified interface for all the supported transforms";

     

       1184
       1229
        
           homepage = "http://hgomersall.github.com/pyFFTW";

     

       1185
       1185
       -
           license = with lib.licenses; [ bsd2 bsd3 ];

     

       1230
       1230
       +
           license = with lib.licenses; [

     

       1231
       1231
       +
             bsd2

     

       1232
       1232
       +
             bsd3

     

       1233
       1233
       +
           ];

     

       1186
       1234
        
         };

     

       1187
       1235
        
       }

     

       1188
       1236
        
       ```

     
···

       1360
       1408
        
       

     

       1361
       1409
        
       ```nix

     

       1362
       1410
        
       {

     

       1363
       1363
       -
         disabledTests = [

     

       1364
       1364
       -
           # touches network

     

       1365
       1365
       -
           "download"

     

       1366
       1366
       -
           "update"

     

       1367
       1367
       -
         ] ++ lib.optionals (pythonAtLeast "3.8") [

     

       1368
       1368
       -
           # broken due to python3.8 async changes

     

       1369
       1369
       -
           "async"

     

       1370
       1370
       -
         ] ++ lib.optionals stdenv.buildPlatform.isDarwin [

     

       1371
       1371
       -
           # can fail when building with other packages

     

       1372
       1372
       -
           "socket"

     

       1373
       1373
       -
         ];

     

       1411
       1411
       +
         disabledTests =

     

       1412
       1412
       +
           [

     

       1413
       1413
       +
             # touches network

     

       1414
       1414
       +
             "download"

     

       1415
       1415
       +
             "update"

     

       1416
       1416
       +
           ]

     

       1417
       1417
       +
           ++ lib.optionals (pythonAtLeast "3.8") [

     

       1418
       1418
       +
             # broken due to python3.8 async changes

     

       1419
       1419
       +
             "async"

     

       1420
       1420
       +
           ]

     

       1421
       1421
       +
           ++ lib.optionals stdenv.buildPlatform.isDarwin [

     

       1422
       1422
       +
             # can fail when building with other packages

     

       1423
       1423
       +
             "socket"

     

       1424
       1424
       +
           ];

     

       1374
       1425
        
       }

     

       1375
       1426
        
       ```

     

       1376
       1427
        
       

     
···

       1495
       1546
        
         ];

     

       1496
       1547
        
       

     

       1497
       1548
        
         unittestFlags = [

     

       1498
       1498
       -
           "-s" "tests" "-v"

     

       1549
       1549
       +
           "-s"

     

       1550
       1550
       +
           "tests"

     

       1551
       1551
       +
           "-v"

     

       1499
       1552
        
         ];

     

       1500
       1553
        
       }

     

       1501
       1554
        
       ```

     
···

       1576
       1629
        
       We first create a function that builds `toolz` in `~/path/to/toolz/release.nix`

     

       1577
       1630
        
       

     

       1578
       1631
        
       ```nix

     

       1579
       1579
       -
       { lib

     

       1580
       1580
       -
       , buildPythonPackage

     

       1581
       1581
       -
       , fetchPypi

     

       1582
       1582
       -
       , setuptools

     

       1632
       1632
       +
       {

     

       1633
       1633
       +
         lib,

     

       1634
       1634
       +
         buildPythonPackage,

     

       1635
       1635
       +
         fetchPypi,

     

       1636
       1636
       +
         setuptools,

     

       1583
       1637
        
       }:

     

       1584
       1638
        
       

     

       1585
       1639
        
       buildPythonPackage rec {

     
···

       1609
       1663
        
       `callPackage` in the definition of our environment

     

       1610
       1664
        
       

     

       1611
       1665
        
       ```nix

     

       1612
       1612
       -
       with import <nixpkgs> {};

     

       1666
       1666
       +
       with import <nixpkgs> { };

     

       1613
       1667
        
       

     

       1614
       1614
       -
       ( let

     

       1668
       1668
       +
       (

     

       1669
       1669
       +
         let

     

       1615
       1670
        
           toolz = callPackage /path/to/toolz/release.nix {

     

       1616
       1671
        
             buildPythonPackage = python3Packages.buildPythonPackage;

     

       1617
       1672
        
           };

     

       1618
       1618
       -
         in python3.withPackages (ps: [

     

       1673
       1673
       +
         in

     

       1674
       1674
       +
         python3.withPackages (ps: [

     

       1619
       1675
        
           ps.numpy

     

       1620
       1676
        
           toolz

     

       1621
       1677
        
         ])

     
···

       1643
       1699
        
       example we rename the `pandas` package and build it.

     

       1644
       1700
        
       

     

       1645
       1701
        
       ```nix

     

       1646
       1646
       -
       with import <nixpkgs> {};

     

       1702
       1702
       +
       with import <nixpkgs> { };

     

       1647
       1703
        
       

     

       1648
       1648
       -
       (let

     

       1649
       1649
       -
         python = let

     

       1650
       1650
       -
           packageOverrides = self: super: {

     

       1651
       1651
       -
             pandas = super.pandas.overridePythonAttrs(old: {name="foo";});

     

       1652
       1652
       -
           };

     

       1653
       1653
       -
         in pkgs.python310.override {

     

       1654
       1654
       -
           inherit packageOverrides;

     

       1655
       1655
       -
         };

     

       1704
       1704
       +
       (

     

       1705
       1705
       +
         let

     

       1706
       1706
       +
           python =

     

       1707
       1707
       +
             let

     

       1708
       1708
       +
               packageOverrides = self: super: {

     

       1709
       1709
       +
                 pandas = super.pandas.overridePythonAttrs (old: {

     

       1710
       1710
       +
                   name = "foo";

     

       1711
       1711
       +
                 });

     

       1712
       1712
       +
               };

     

       1713
       1713
       +
             in

     

       1714
       1714
       +
             pkgs.python310.override {

     

       1715
       1715
       +
               inherit packageOverrides;

     

       1716
       1716
       +
             };

     

       1656
       1717
        
       

     

       1657
       1657
       -
       in python.withPackages (ps: [

     

       1658
       1658
       -
         ps.pandas

     

       1659
       1659
       -
       ])).env

     

       1718
       1718
       +
         in

     

       1719
       1719
       +
         python.withPackages (ps: [

     

       1720
       1720
       +
           ps.pandas

     

       1721
       1721
       +
         ])

     

       1722
       1722
       +
       ).env

     

       1660
       1723
        
       ```

     

       1661
       1724
        
       

     

       1662
       1725
        
       Using `nix-build` on this expression will build an environment that contains the

     
···

       1670
       1733
        
       the updated `scipy` version.

     

       1671
       1734
        
       

     

       1672
       1735
        
       ```nix

     

       1673
       1673
       -
       with import <nixpkgs> {};

     

       1736
       1736
       +
       with import <nixpkgs> { };

     

       1674
       1737
        
       

     

       1675
       1675
       -
       ( let

     

       1738
       1738
       +
       (

     

       1739
       1739
       +
         let

     

       1676
       1740
        
           packageOverrides = self: super: {

     

       1677
       1741
        
             scipy = super.scipy_0_17;

     

       1678
       1742
        
           };

     

       1679
       1679
       -
         in (pkgs.python310.override {

     

       1743
       1743
       +
         in

     

       1744
       1744
       +
         (pkgs.python310.override {

     

       1680
       1745
        
           inherit packageOverrides;

     

       1681
       1681
       -
         }).withPackages (ps: [

     

       1682
       1682
       -
           ps.blaze

     

       1683
       1683
       -
         ])

     

       1746
       1746
       +
         }).withPackages

     

       1747
       1747
       +
           (ps: [

     

       1748
       1748
       +
             ps.blaze

     

       1749
       1749
       +
           ])

     

       1684
       1750
        
       ).env

     

       1685
       1751
        
       ```

     

       1686
       1752
        
       

     
···

       1692
       1758
        
       

     

       1693
       1759
        
       ```nix

     

       1694
       1760
        
       let

     

       1695
       1695
       -
         pkgs = import <nixpkgs> {};

     

       1696
       1696
       -
         newpkgs = import pkgs.path { overlays = [ (self: super: {

     

       1697
       1697
       -
           python310 = let

     

       1698
       1698
       -
             packageOverrides = python-self: python-super: {

     

       1699
       1699
       -
               numpy = python-super.numpy_1_18;

     

       1700
       1700
       -
             };

     

       1701
       1701
       -
           in super.python310.override {inherit packageOverrides;};

     

       1702
       1702
       -
         } ) ]; };

     

       1703
       1703
       -
       in newpkgs.inkscape

     

       1761
       1761
       +
         pkgs = import <nixpkgs> { };

     

       1762
       1762
       +
         newpkgs = import pkgs.path {

     

       1763
       1763
       +
           overlays = [

     

       1764
       1764
       +
             (self: super: {

     

       1765
       1765
       +
               python310 =

     

       1766
       1766
       +
                 let

     

       1767
       1767
       +
                   packageOverrides = python-self: python-super: {

     

       1768
       1768
       +
                     numpy = python-super.numpy_1_18;

     

       1769
       1769
       +
                   };

     

       1770
       1770
       +
                 in

     

       1771
       1771
       +
                 super.python310.override { inherit packageOverrides; };

     

       1772
       1772
       +
             })

     

       1773
       1773
       +
           ];

     

       1774
       1774
       +
         };

     

       1775
       1775
       +
       in

     

       1776
       1776
       +
       newpkgs.inkscape

     

       1704
       1777
        
       ```

     

       1705
       1778
        
       

     

       1706
       1779
        
       ### `python setup.py bdist_wheel` cannot create .whl {#python-setup.py-bdist_wheel-cannot-create-.whl}

     
···

       1790
       1863
        
       

     

       1791
       1864
        
       let

     

       1792
       1865
        
         pythonPackages = python3Packages;

     

       1793
       1793
       -
       in pkgs.mkShell rec {

     

       1866
       1866
       +
       in

     

       1867
       1867
       +
       pkgs.mkShell rec {

     

       1794
       1868
        
         name = "impurePythonEnv";

     

       1795
       1869
        
         venvDir = "./.venv";

     

       1796
       1870
        
         buildInputs = [

     
···

       1845
       1919
        
       let

     

       1846
       1920
        
         venvDir = "./.venv";

     

       1847
       1921
        
         pythonPackages = python3Packages;

     

       1848
       1848
       -
       in pkgs.mkShell rec {

     

       1922
       1922
       +
       in

     

       1923
       1923
       +
       pkgs.mkShell rec {

     

       1849
       1924
        
         name = "impurePythonEnv";

     

       1850
       1925
        
         buildInputs = [

     

       1851
       1926
        
           pythonPackages.python

     
···

       1957
       2032
        
       ```nix

     

       1958
       2033
        
       final: prev: {

     

       1959
       2034
        
         pythonPackagesExtensions = prev.pythonPackagesExtensions ++ [

     

       1960
       1960
       -
           (

     

       1961
       1961
       -
             python-final: python-prev: {

     

       1962
       1962
       -
               foo = python-prev.foo.overridePythonAttrs (oldAttrs: {

     

       1963
       1963
       -
                 # ...

     

       1964
       1964
       -
               });

     

       1965
       1965
       -
             }

     

       1966
       1966
       -
           )

     

       2035
       2035
       +
           (python-final: python-prev: {

     

       2036
       2036
       +
             foo = python-prev.foo.overridePythonAttrs (oldAttrs: {

     

       2037
       2037
       +
               # ...

     

       2038
       2038
       +
             });

     

       2039
       2039
       +
           })

     

       1967
       2040
        
         ];

     

       1968
       2041
        
       }

     

       1969
       2042
        
       ```

     
···

       1989
       2062
        
       

     

       1990
       2063
        
       ```nix

     

       1991
       2064
        
       let

     

       1992
       1992
       -
         pkgs = import ./. {};

     

       2065
       2065
       +
         pkgs = import ./. { };

     

       1993
       2066
        
         mypython = pkgs.python3.override {

     

       1994
       2067
        
           enableOptimizations = true;

     

       1995
       2068
        
           reproducibleBuild = false;

     

       1996
       2069
        
           self = mypython;

     

       1997
       2070
        
         };

     

       1998
       1998
       -
       in mypython

     

       2071
       2071
       +
       in

     

       2072
       2072
       +
       mypython

     

       1999
       2073
        
       ```

     

       2000
       2074
        
       

     

       2001
       2075
        
       ### How to add optional dependencies? {#python-optional-dependencies}

+6 -2

doc/languages-frameworks/qt.section.md

···

       64
       64
        
       The `makeWrapper` arguments required for Qt are also exposed in the environment as `$qtWrapperArgs`.

     

       65
       65
        
       

     

       66
       66
        
       ```nix

     

       67
       67
       -
       { stdenv, lib, wrapQtAppsHook }:

     

       67
       67
       +
       {

     

       68
       68
       +
         stdenv,

     

       69
       69
       +
         lib,

     

       70
       70
       +
         wrapQtAppsHook,

     

       71
       71
       +
       }:

     

       68
       72
        
       

     

       69
       73
        
       stdenv.mkDerivation {

     

       70
       74
        
         # ...

     

       71
       75
        
         nativeBuildInputs = [ wrapQtAppsHook ];

     

       72
       76
        
         dontWrapQtApps = true;

     

       73
       77
        
         preFixup = ''

     

       74
       74
       -
             wrapQtApp "$out/bin/myapp" --prefix PATH : /path/to/bin

     

       78
       78
       +
           wrapQtApp "$out/bin/myapp" --prefix PATH : /path/to/bin

     

       75
       79
        
         '';

     

       76
       80
        
       }

     

       77
       81
        
       ```

+34 -22

doc/languages-frameworks/r.section.md

···

       7
       7
        
       

     

       8
       8
        
       ```nix

     

       9
       9
        
       {

     

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

     

       10
       10
       +
         packageOverrides =

     

       11
       11
       +
           super:

     

       12
       12
       +
           let

     

       13
       13
       +
             self = super.pkgs;

     

       14
       14
       +
           in

     

       11
       15
        
           {

     

       12
       16
        
       

     

       13
       13
       -
               rEnv = super.rWrapper.override {

     

       14
       14
       -
                   packages = with self.rPackages; [

     

       15
       15
       -
                       devtools

     

       16
       16
       -
                       ggplot2

     

       17
       17
       -
                       reshape2

     

       18
       18
       -
                       yaml

     

       19
       19
       -
                       optparse

     

       20
       20
       -
                       ];

     

       21
       21
       -
               };

     

       17
       17
       +
             rEnv = super.rWrapper.override {

     

       18
       18
       +
               packages = with self.rPackages; [

     

       19
       19
       +
                 devtools

     

       20
       20
       +
                 ggplot2

     

       21
       21
       +
                 reshape2

     

       22
       22
       +
                 yaml

     

       23
       23
       +
                 optparse

     

       24
       24
       +
               ];

     

       25
       25
       +
             };

     

       22
       26
        
           };

     

       23
       27
        
       }

     

       24
       28
        
       ```

     
···

       33
       37
        
       file like so:

     

       34
       38
        
       

     

       35
       39
        
       ```nix

     

       36
       36
       -
       with import <nixpkgs> {};

     

       40
       40
       +
       with import <nixpkgs> { };

     

       37
       41
        
       {

     

       38
       42
        
         myProject = stdenv.mkDerivation {

     

       39
       43
        
           name = "myProject";

     
···

       60
       64
        
       

     

       61
       65
        
       ```nix

     

       62
       66
        
       {

     

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

     

       67
       67
       +
         packageOverrides =

     

       68
       68
       +
           super:

     

       69
       69
       +
           let

     

       70
       70
       +
             self = super.pkgs;

     

       71
       71
       +
           in

     

       64
       72
        
           {

     

       65
       73
        
       

     

       66
       66
       -
               rstudioEnv = super.rstudioWrapper.override {

     

       67
       67
       -
                   packages = with self.rPackages; [

     

       68
       68
       -
                       dplyr

     

       69
       69
       -
                       ggplot2

     

       70
       70
       -
                       reshape2

     

       71
       71
       -
                       ];

     

       72
       72
       -
               };

     

       74
       74
       +
             rstudioEnv = super.rstudioWrapper.override {

     

       75
       75
       +
               packages = with self.rPackages; [

     

       76
       76
       +
                 dplyr

     

       77
       77
       +
                 ggplot2

     

       78
       78
       +
                 reshape2

     

       79
       79
       +
               ];

     

       80
       80
       +
             };

     

       73
       81
        
           };

     

       74
       82
        
       }

     

       75
       83
        
       ```

     
···

       81
       89
        
       modify any configuration files:

     

       82
       90
        
       

     

       83
       91
        
       ```nix

     

       84
       84
       -
       { pkgs ? import <nixpkgs> {}

     

       92
       92
       +
       {

     

       93
       93
       +
         pkgs ? import <nixpkgs> { },

     

       85
       94
        
       }:

     

       86
       95
        
       

     

       87
       96
        
       pkgs.rstudioWrapper.override {

     

       88
       88
       -
         packages = with pkgs.rPackages; [ dplyr ggplot2 reshape2 ];

     

       97
       97
       +
         packages = with pkgs.rPackages; [

     

       98
       98
       +
           dplyr

     

       99
       99
       +
           ggplot2

     

       100
       100
       +
           reshape2

     

       101
       101
       +
         ];

     

       89
       102
        
       }

     

       90
       90
       -
       

     

       91
       103
        
       ```

     

       92
       104
        
       

     

       93
       105
        
       Executing `nix-shell` will then drop you into an environment equivalent to the

+59 -16

doc/languages-frameworks/ruby.section.md

···

       36
       36
        
       Say we want to have Ruby, `nokogori`, and `pry`. Consider a `shell.nix` file with:

     

       37
       37
        
       

     

       38
       38
        
       ```nix

     

       39
       39
       -
       with import <nixpkgs> {};

     

       40
       40
       -
       ruby.withPackages (ps: with ps; [ nokogiri pry ])

     

       39
       39
       +
       with import <nixpkgs> { };

     

       40
       40
       +
       ruby.withPackages (

     

       41
       41
       +
         ps: with ps; [

     

       42
       42
       +
           nokogiri

     

       43
       43
       +
           pry

     

       44
       44
       +
         ]

     

       45
       45
       +
       )

     

       41
       46
        
       ```

     

       42
       47
        
       

     

       43
       48
        
       What's happening here?

     
···

       107
       112
        
           name = "gems-for-some-project";

     

       108
       113
        
           gemdir = ./.;

     

       109
       114
        
         };

     

       110
       110
       -
       in mkShell { packages = [ gems gems.wrappedRuby ]; }

     

       115
       115
       +
       in

     

       116
       116
       +
       mkShell {

     

       117
       117
       +
         packages = [

     

       118
       118
       +
           gems

     

       119
       119
       +
           gems.wrappedRuby

     

       120
       120
       +
         ];

     

       121
       121
       +
       }

     

       111
       122
        
       ```

     

       112
       123
        
       

     

       113
       124
        
       With this file in your directory, you can run `nix-shell` to build and use the gems. The important parts here are `bundlerEnv` and `wrappedRuby`.

     
···

       118
       129
        
       

     

       119
       130
        
       ```nix

     

       120
       131
        
       # ...

     

       121
       121
       -
       mkShell { buildInputs = [ gems (lowPrio gems.wrappedRuby) ]; }

     

       132
       132
       +
       mkShell {

     

       133
       133
       +
         buildInputs = [

     

       134
       134
       +
           gems

     

       135
       135
       +
           (lowPrio gems.wrappedRuby)

     

       136
       136
       +
         ];

     

       137
       137
       +
       }

     

       122
       138
        
       ```

     

       123
       139
        
       

     

       124
       140
        
       Sometimes a Gemfile references other files. Such as `.ruby-version` or vendored gems. When copying the Gemfile to the nix store we need to copy those files alongside. This can be done using `extraConfigPaths`. For example:

     
···

       148
       164
        
       Here's the `ruby` one:

     

       149
       165
        
       

     

       150
       166
        
       ```nix

     

       151
       151
       -
       { pg_version ? "10", pkgs ? import <nixpkgs> { } }:

     

       167
       167
       +
       {

     

       168
       168
       +
         pg_version ? "10",

     

       169
       169
       +
         pkgs ? import <nixpkgs> { },

     

       170
       170
       +
       }:

     

       152
       171
        
       let

     

       153
       172
        
         myRuby = pkgs.ruby.override {

     

       154
       173
        
           defaultGemConfig = pkgs.defaultGemConfig // {

     

       155
       174
        
             pg = attrs: {

     

       156
       156
       -
               buildFlags =

     

       157
       157
       -
               [ "--with-pg-config=${pkgs."postgresql_${pg_version}".pg_config}/bin/pg_config" ];

     

       175
       175
       +
               buildFlags = [ "--with-pg-config=${pkgs."postgresql_${pg_version}".pg_config}/bin/pg_config" ];

     

       158
       176
        
             };

     

       159
       177
        
           };

     

       160
       178
        
         };

     

       161
       161
       -
       in myRuby.withPackages (ps: with ps; [ pg ])

     

       179
       179
       +
       in

     

       180
       180
       +
       myRuby.withPackages (ps: with ps; [ pg ])

     

       162
       181
        
       ```

     

       163
       182
        
       

     

       164
       183
        
       And an example with `bundlerEnv`:

     

       165
       184
        
       

     

       166
       185
        
       ```nix

     

       167
       167
       -
       { pg_version ? "10", pkgs ? import <nixpkgs> { } }:

     

       186
       186
       +
       {

     

       187
       187
       +
         pg_version ? "10",

     

       188
       188
       +
         pkgs ? import <nixpkgs> { },

     

       189
       189
       +
       }:

     

       168
       190
        
       let

     

       169
       191
        
         gems = pkgs.bundlerEnv {

     

       170
       192
        
           name = "gems-for-some-project";

     

       171
       193
        
           gemdir = ./.;

     

       172
       194
        
           gemConfig = pkgs.defaultGemConfig // {

     

       173
       195
        
             pg = attrs: {

     

       174
       174
       -
               buildFlags =

     

       175
       175
       -
               [ "--with-pg-config=${pkgs."postgresql_${pg_version}".pg_config}/bin/pg_config" ];

     

       196
       196
       +
               buildFlags = [ "--with-pg-config=${pkgs."postgresql_${pg_version}".pg_config}/bin/pg_config" ];

     

       176
       197
        
             };

     

       177
       198
        
           };

     

       178
       199
        
         };

     

       179
       179
       -
       in mkShell { buildInputs = [ gems gems.wrappedRuby ]; }

     

       200
       200
       +
       in

     

       201
       201
       +
       mkShell {

     

       202
       202
       +
         buildInputs = [

     

       203
       203
       +
           gems

     

       204
       204
       +
           gems.wrappedRuby

     

       205
       205
       +
         ];

     

       206
       206
       +
       }

     

       180
       207
        
       ```

     

       181
       208
        
       

     

       182
       209
        
       And finally via overlays:

     

       183
       210
        
       

     

       184
       211
        
       ```nix

     

       185
       185
       -
       { pg_version ? "10" }:

     

       212
       212
       +
       {

     

       213
       213
       +
         pg_version ? "10",

     

       214
       214
       +
       }:

     

       186
       215
        
       let

     

       187
       216
        
         pkgs = import <nixpkgs> {

     

       188
       217
        
           overlays = [

     
···

       197
       226
        
             })

     

       198
       227
        
           ];

     

       199
       228
        
         };

     

       200
       200
       -
       in pkgs.ruby.withPackages (ps: with ps; [ pg ])

     

       229
       229
       +
       in

     

       230
       230
       +
       pkgs.ruby.withPackages (ps: with ps; [ pg ])

     

       201
       231
        
       ```

     

       202
       232
        
       

     

       203
       233
        
       Then we can get whichever postgresql version we desire and the `pg` gem will always reference it correctly:

     
···

       278
       308
        
       Here's another example:

     

       279
       309
        
       

     

       280
       310
        
       ```nix

     

       281
       281
       -
       { lib, bundlerApp, makeWrapper, git, gnutar, gzip }:

     

       311
       311
       +
       {

     

       312
       312
       +
         lib,

     

       313
       313
       +
         bundlerApp,

     

       314
       314
       +
         makeWrapper,

     

       315
       315
       +
         git,

     

       316
       316
       +
         gnutar,

     

       317
       317
       +
         gzip,

     

       318
       318
       +
       }:

     

       282
       319
        
       

     

       283
       320
        
       bundlerApp {

     

       284
       321
        
         pname = "r10k";

     
···

       288
       325
        
         nativeBuildInputs = [ makeWrapper ];

     

       289
       326
        
       

     

       290
       327
        
         postBuild = ''

     

       291
       291
       -
           wrapProgram $out/bin/r10k --prefix PATH : ${lib.makeBinPath [ git gnutar gzip ]}

     

       328
       328
       +
           wrapProgram $out/bin/r10k --prefix PATH : ${

     

       329
       329
       +
             lib.makeBinPath [

     

       330
       330
       +
               git

     

       331
       331
       +
               gnutar

     

       332
       332
       +
               gzip

     

       333
       333
       +
             ]

     

       334
       334
       +
           }

     

       292
       335
        
         '';

     

       293
       336
        
       }

     

       294
       337
        
       ```

+127 -92

doc/languages-frameworks/rust.section.md

···

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

     

       23
       23
        
       

     

       24
       24
        
       ```nix

     

       25
       25
       -
       { lib, fetchFromGitHub, rustPlatform }:

     

       25
       25
       +
       {

     

       26
       26
       +
         lib,

     

       27
       27
       +
         fetchFromGitHub,

     

       28
       28
       +
         rustPlatform,

     

       29
       29
       +
       }:

     

       26
       30
        
       

     

       27
       31
        
       rustPlatform.buildRustPackage rec {

     

       28
       32
        
         pname = "ripgrep";

     
···

       151
       155
        
         pname = "myproject";

     

       152
       156
        
         version = "1.0.0";

     

       153
       157
        
       

     

       154
       154
       -
         cargoLock = let

     

       155
       155
       -
           fixupLockFile = path: f (builtins.readFile path);

     

       156
       156
       -
         in {

     

       157
       157
       -
           lockFileContents = fixupLockFile ./Cargo.lock;

     

       158
       158
       -
         };

     

       158
       158
       +
         cargoLock =

     

       159
       159
       +
           let

     

       160
       160
       +
             fixupLockFile = path: f (builtins.readFile path);

     

       161
       161
       +
           in

     

       162
       162
       +
           {

     

       163
       163
       +
             lockFileContents = fixupLockFile ./Cargo.lock;

     

       164
       164
       +
           };

     

       159
       165
        
       

     

       160
       166
        
         # ...

     

       161
       167
        
       }

     
···

       234
       240
        
         version = "1.0.0";

     

       235
       241
        
       

     

       236
       242
        
         buildNoDefaultFeatures = true;

     

       237
       237
       -
         buildFeatures = [ "color" "net" ];

     

       243
       243
       +
         buildFeatures = [

     

       244
       244
       +
           "color"

     

       245
       245
       +
           "net"

     

       246
       246
       +
         ];

     

       238
       247
        
       

     

       239
       248
        
         # disable network features in tests

     

       240
       249
        
         checkFeatures = [ "color" ];

     
···

       283
       292
        
          import <nixpkgs> {

     

       284
       293
        
            crossSystem = (import <nixpkgs/lib>).systems.examples.armhf-embedded // {

     

       285
       294
        
              rust.rustcTarget = "thumb-crazy";

     

       286
       286
       -
              rust.platform = { foo = ""; bar = ""; };

     

       295
       295
       +
              rust.platform = {

     

       296
       296
       +
                foo = "";

     

       297
       297
       +
                bar = "";

     

       298
       298
       +
              };

     

       287
       299
        
            };

     

       288
       300
        
          }

     

       289
       301
        
          ```

     
···

       310
       322
        
       

     

       311
       323
        
       ```nix

     

       312
       324
        
       rustPlatform.buildRustPackage {

     

       313
       313
       -
         /* ... */

     

       325
       325
       +
         # ...

     

       314
       326
        
         checkType = "debug";

     

       315
       327
        
       }

     

       316
       328
        
       ```

     
···

       353
       365
        
       

     

       354
       366
        
       ```nix

     

       355
       367
        
       rustPlatform.buildRustPackage {

     

       356
       356
       -
         /* ... */

     

       368
       368
       +
         # ...

     

       357
       369
        
         checkFlags = [

     

       358
       370
        
           # reason for disabling test

     

       359
       371
        
           "--skip=example::tests:example_test"

     
···

       370
       382
        
       

     

       371
       383
        
       ```nix

     

       372
       384
        
       rustPlatform.buildRustPackage {

     

       373
       373
       -
         /* ... */

     

       385
       385
       +
         # ...

     

       374
       386
        
         useNextest = true;

     

       375
       387
        
       }

     

       376
       388
        
       ```

     
···

       382
       394
        
       

     

       383
       395
        
       ```nix

     

       384
       396
        
       rustPlatform.buildRustPackage {

     

       385
       385
       -
         /* ... */

     

       397
       397
       +
         # ...

     

       386
       398
        
         dontUseCargoParallelTests = true;

     

       387
       399
        
       }

     

       388
       400
        
       ```

     
···

       394
       406
        
       

     

       395
       407
        
       ```nix

     

       396
       408
        
       rustPlatform.buildRustPackage {

     

       397
       397
       -
         /* ... */

     

       409
       409
       +
         # ...

     

       398
       410
        
         buildType = "debug";

     

       399
       411
        
       }

     

       400
       412
        
       ```

     
···

       548
       560
        
       `sourceRoot` to point the tooling to this directory:

     

       549
       561
        
       

     

       550
       562
        
       ```nix

     

       551
       551
       -
       { fetchFromGitHub

     

       552
       552
       -
       , buildPythonPackage

     

       553
       553
       -
       , cargo

     

       554
       554
       -
       , rustPlatform

     

       555
       555
       -
       , rustc

     

       556
       556
       -
       , setuptools-rust

     

       563
       563
       +
       {

     

       564
       564
       +
         fetchFromGitHub,

     

       565
       565
       +
         buildPythonPackage,

     

       566
       566
       +
         cargo,

     

       567
       567
       +
         rustPlatform,

     

       568
       568
       +
         rustc,

     

       569
       569
       +
         setuptools-rust,

     

       557
       570
        
       }:

     

       558
       571
        
       

     

       559
       572
        
       buildPythonPackage rec {

     
···

       568
       581
        
         };

     

       569
       582
        
       

     

       570
       583
        
         cargoDeps = rustPlatform.fetchCargoVendor {

     

       571
       571
       -
           inherit pname version src sourceRoot;

     

       584
       584
       +
           inherit

     

       585
       585
       +
             pname

     

       586
       586
       +
             version

     

       587
       587
       +
             src

     

       588
       588
       +
             sourceRoot

     

       589
       589
       +
             ;

     

       572
       590
        
           hash = "sha256-RO1m8wEd5Ic2M9q+zFHeCJWhCr4Sv3CEWd08mkxsBec=";

     

       573
       591
        
         };

     

       574
       592
        
       

     
···

       593
       611
        
       path for `fetchCargoVendor`.

     

       594
       612
        
       

     

       595
       613
        
       ```nix

     

       596
       596
       -
       

     

       597
       597
       -
       { buildPythonPackage

     

       598
       598
       -
       , fetchPypi

     

       599
       599
       -
       , rustPlatform

     

       600
       600
       -
       , setuptools-rust

     

       601
       601
       -
       , openssl

     

       614
       614
       +
       {

     

       615
       615
       +
         buildPythonPackage,

     

       616
       616
       +
         fetchPypi,

     

       617
       617
       +
         rustPlatform,

     

       618
       618
       +
         setuptools-rust,

     

       619
       619
       +
         openssl,

     

       602
       620
        
       }:

     

       603
       621
        
       

     

       604
       622
        
       buildPythonPackage rec {

     
···

       632
       650
        
       `maturinBuildHook` is used to perform the build.

     

       633
       651
        
       

     

       634
       652
        
       ```nix

     

       635
       635
       -
       { lib

     

       636
       636
       -
       , buildPythonPackage

     

       637
       637
       -
       , rustPlatform

     

       638
       638
       -
       , fetchFromGitHub

     

       653
       653
       +
       {

     

       654
       654
       +
         lib,

     

       655
       655
       +
         buildPythonPackage,

     

       656
       656
       +
         rustPlatform,

     

       657
       657
       +
         fetchFromGitHub,

     

       639
       658
        
       }:

     

       640
       659
        
       

     

       641
       660
        
       buildPythonPackage rec {

     
···

       655
       674
        
           hash = "sha256-QsPCQhNZKYCAogQriQX6pBYQUDAIUsEdRX/63dAqTzg=";

     

       656
       675
        
         };

     

       657
       676
        
       

     

       658
       658
       -
         nativeBuildInputs = with rustPlatform; [ cargoSetupHook maturinBuildHook ];

     

       677
       677
       +
         nativeBuildInputs = with rustPlatform; [

     

       678
       678
       +
           cargoSetupHook

     

       679
       679
       +
           maturinBuildHook

     

       680
       680
       +
         ];

     

       659
       681
        
       

     

       660
       682
        
         # ...

     

       661
       683
        
       }

     
···

       666
       688
        
       Some projects, especially GNOME applications, are built with the Meson Build System instead of calling Cargo directly. Using `rustPlatform.buildRustPackage` may successfully build the main program, but related files will be missing. Instead, you need to set up Cargo dependencies with `fetchCargoVendor` and `cargoSetupHook` and leave the rest to Meson. `rust` and `cargo` are still needed in `nativeBuildInputs` for Meson to use.

     

       667
       689
        
       

     

       668
       690
        
       ```nix

     

       669
       669
       -
       { lib

     

       670
       670
       -
       , stdenv

     

       671
       671
       -
       , fetchFromGitLab

     

       672
       672
       -
       , meson

     

       673
       673
       -
       , ninja

     

       674
       674
       -
       , pkg-config

     

       675
       675
       -
       , rustPlatform

     

       676
       676
       -
       , rustc

     

       677
       677
       -
       , cargo

     

       678
       678
       -
       , wrapGAppsHook4

     

       679
       679
       -
       , blueprint-compiler

     

       680
       680
       -
       , libadwaita

     

       681
       681
       -
       , libsecret

     

       682
       682
       -
       , tinysparql

     

       691
       691
       +
       {

     

       692
       692
       +
         lib,

     

       693
       693
       +
         stdenv,

     

       694
       694
       +
         fetchFromGitLab,

     

       695
       695
       +
         meson,

     

       696
       696
       +
         ninja,

     

       697
       697
       +
         pkg-config,

     

       698
       698
       +
         rustPlatform,

     

       699
       699
       +
         rustc,

     

       700
       700
       +
         cargo,

     

       701
       701
       +
         wrapGAppsHook4,

     

       702
       702
       +
         blueprint-compiler,

     

       703
       703
       +
         libadwaita,

     

       704
       704
       +
         libsecret,

     

       705
       705
       +
         tinysparql,

     

       683
       706
        
       }:

     

       684
       707
        
       

     

       685
       708
        
       stdenv.mkDerivation rec {

     
···

       744
       767
        
       or build inputs by overriding the hello crate in a separate file.

     

       745
       768
        
       

     

       746
       769
        
       ```nix

     

       747
       747
       -
       with import <nixpkgs> {};

     

       748
       748
       -
       ((import ./hello.nix).hello {}).override {

     

       770
       770
       +
       with import <nixpkgs> { };

     

       771
       771
       +
       ((import ./hello.nix).hello { }).override {

     

       749
       772
        
         crateOverrides = defaultCrateOverrides // {

     

       750
       773
        
           hello = attrs: { buildInputs = [ openssl ]; };

     

       751
       774
        
         };

     
···

       764
       787
        
       patches the derivation:

     

       765
       788
        
       

     

       766
       789
        
       ```nix

     

       767
       767
       -
       with import <nixpkgs> {};

     

       768
       768
       -
       ((import ./hello.nix).hello {}).override {

     

       790
       790
       +
       with import <nixpkgs> { };

     

       791
       791
       +
       ((import ./hello.nix).hello { }).override {

     

       769
       792
        
         crateOverrides = defaultCrateOverrides // {

     

       770
       770
       -
           hello = attrs: lib.optionalAttrs (lib.versionAtLeast attrs.version "1.0")  {

     

       771
       771
       -
             postPatch = ''

     

       772
       772
       -
               substituteInPlace lib/zoneinfo.rs \

     

       773
       773
       -
                 --replace-fail "/usr/share/zoneinfo" "${tzdata}/share/zoneinfo"

     

       774
       774
       -
             '';

     

       775
       775
       -
           };

     

       793
       793
       +
           hello =

     

       794
       794
       +
             attrs:

     

       795
       795
       +
             lib.optionalAttrs (lib.versionAtLeast attrs.version "1.0") {

     

       796
       796
       +
               postPatch = ''

     

       797
       797
       +
                 substituteInPlace lib/zoneinfo.rs \

     

       798
       798
       +
                   --replace-fail "/usr/share/zoneinfo" "${tzdata}/share/zoneinfo"

     

       799
       799
       +
               '';

     

       800
       800
       +
             };

     

       776
       801
        
         };

     

       777
       802
        
       }

     

       778
       803
        
       ```

     
···

       785
       810
        
       crate, we could do:

     

       786
       811
        
       

     

       787
       812
        
       ```nix

     

       788
       788
       -
       with import <nixpkgs> {};

     

       789
       789
       -
       ((import hello.nix).hello {}).override {

     

       813
       813
       +
       with import <nixpkgs> { };

     

       814
       814
       +
       ((import hello.nix).hello { }).override {

     

       790
       815
        
         crateOverrides = defaultCrateOverrides // {

     

       791
       791
       -
           libc = attrs: { buildInputs = []; };

     

       816
       816
       +
           libc = attrs: { buildInputs = [ ]; };

     

       792
       817
        
         };

     

       793
       818
        
       }

     

       794
       819
        
       ```

     
···

       801
       826
        
       - The version of `rustc` used to compile the crate:

     

       802
       827
        
       

     

       803
       828
        
         ```nix

     

       804
       804
       -
         (hello {}).override { rust = pkgs.rust; }

     

       829
       829
       +
         (hello { }).override { rust = pkgs.rust; }

     

       805
       830
        
         ```

     

       806
       831
        
       

     

       807
       832
        
       - Whether to build in release mode or debug mode (release mode by

     

       808
       833
        
         default):

     

       809
       834
        
       

     

       810
       835
        
         ```nix

     

       811
       811
       -
         (hello {}).override { release = false; }

     

       836
       836
       +
         (hello { }).override { release = false; }

     

       812
       837
        
         ```

     

       813
       838
        
       

     

       814
       839
        
       - Whether to print the commands sent to `rustc` when building

     

       815
       840
        
         (equivalent to `--verbose` in cargo:

     

       816
       841
        
       

     

       817
       842
        
         ```nix

     

       818
       818
       -
         (hello {}).override { verbose = false; }

     

       843
       843
       +
         (hello { }).override { verbose = false; }

     

       819
       844
        
         ```

     

       820
       845
        
       

     

       821
       846
        
       - Extra arguments to be passed to `rustc`:

     

       822
       847
        
       

     

       823
       848
        
         ```nix

     

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

     

       849
       849
       +
         (hello { }).override { extraRustcOpts = "-Z debuginfo=2"; }

     

       825
       850
        
         ```

     

       826
       851
        
       

     

       827
       852
        
       - Phases, just like in any other derivation, can be specified using

     
···

       833
       858
        
         before running the build script:

     

       834
       859
        
       

     

       835
       860
        
         ```nix

     

       836
       836
       -
         (hello {}).override {

     

       861
       861
       +
         (hello { }).override {

     

       837
       862
        
           preConfigure = ''

     

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

     

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

     

       839
       864
        
           '';

     

       840
       865
        
         }

     

       841
       866
        
         ```

     
···

       856
       881
        
       A typical `shell.nix` might look like:

     

       857
       882
        
       

     

       858
       883
        
       ```nix

     

       859
       859
       -
       with import <nixpkgs> {};

     

       884
       884
       +
       with import <nixpkgs> { };

     

       860
       885
        
       

     

       861
       886
        
       stdenv.mkDerivation {

     

       862
       887
        
         name = "rust-env";

     

       863
       888
        
         nativeBuildInputs = [

     

       864
       864
       -
           rustc cargo

     

       889
       889
       +
           rustc

     

       890
       890
       +
           cargo

     

       865
       891
        
       

     

       866
       892
        
           # Example Build-time Additional Dependencies

     

       867
       893
        
           pkg-config

     
···

       917
       943
        
       ```nix

     

       918
       944
        
       with import <nixpkgs> { };

     

       919
       945
        
       let

     

       920
       920
       -
         fenix = callPackage

     

       921
       921
       -
           (fetchFromGitHub {

     

       922
       922
       -
             owner = "nix-community";

     

       923
       923
       -
             repo = "fenix";

     

       924
       924
       -
             # commit from: 2023-03-03

     

       925
       925
       -
             rev = "e2ea04982b892263c4d939f1cc3bf60a9c4deaa1";

     

       926
       926
       -
             hash = "sha256-AsOim1A8KKtMWIxG+lXh5Q4P2bhOZjoUhFWJ1EuZNNk=";

     

       927
       927
       -
           })

     

       928
       928
       -
           { };

     

       946
       946
       +
         fenix = callPackage (fetchFromGitHub {

     

       947
       947
       +
           owner = "nix-community";

     

       948
       948
       +
           repo = "fenix";

     

       949
       949
       +
           # commit from: 2023-03-03

     

       950
       950
       +
           rev = "e2ea04982b892263c4d939f1cc3bf60a9c4deaa1";

     

       951
       951
       +
           hash = "sha256-AsOim1A8KKtMWIxG+lXh5Q4P2bhOZjoUhFWJ1EuZNNk=";

     

       952
       952
       +
         }) { };

     

       929
       953
        
       in

     

       930
       954
        
       mkShell {

     

       931
       955
        
         name = "rust-env";

     
···

       964
       988
        
       The below snippet demonstrates invoking `buildRustPackage` with a Rust toolchain from oxalica's overlay:

     

       965
       989
        
       

     

       966
       990
        
       ```nix

     

       967
       967
       -
       with import <nixpkgs>

     

       968
       968
       -
       {

     

       991
       991
       +
       with import <nixpkgs> {

     

       969
       992
        
         overlays = [

     

       970
       993
        
           (import (fetchTarball "https://github.com/oxalica/rust-overlay/archive/master.tar.gz"))

     

       971
       994
        
         ];

     
···

       996
       1019
        
         meta = {

     

       997
       1020
        
           description = "Fast line-oriented regex search tool, similar to ag and ack";

     

       998
       1021
        
           homepage = "https://github.com/BurntSushi/ripgrep";

     

       999
       999
       -
           license = with lib.licenses; [ mit unlicense ];

     

       1000
       1000
       -
           maintainers = with lib.maintainers; [];

     

       1022
       1022
       +
           license = with lib.licenses; [

     

       1023
       1023
       +
             mit

     

       1024
       1024
       +
             unlicense

     

       1025
       1025
       +
           ];

     

       1026
       1026
       +
           maintainers = with lib.maintainers; [ ];

     

       1001
       1027
        
         };

     

       1002
       1028
        
       }

     

       1003
       1029
        
       ```

     
···

       1029
       1055
        
       repository:

     

       1030
       1056
        
       

     

       1031
       1057
        
       ```nix

     

       1032
       1032
       -
        (final: prev: /*lib.optionalAttrs prev.stdenv.targetPlatform.isAarch64*/ {

     

       1033
       1033
       -
          rust_1_72 =

     

       1034
       1034
       -
            lib.updateManyAttrsByPath [{

     

       1035
       1035
       -
              path = [ "packages" "stable" ];

     

       1036
       1036
       -
              update = old: old.overrideScope(final: prev: {

     

       1037
       1037
       -
                rustc-unwrapped = prev.rustc-unwrapped.overrideAttrs (_: {

     

       1038
       1038
       -
                  src = lib.cleanSource /git/scratch/rust;

     

       1039
       1039
       -
                  # do *not* put passthru.isReleaseTarball=true here

     

       1040
       1040
       -
                });

     

       1041
       1041
       -
              });

     

       1042
       1042
       -
            }]

     

       1043
       1043
       -
              prev.rust_1_72;

     

       1044
       1044
       -
        })

     

       1058
       1058
       +
       (

     

       1059
       1059
       +
         final: prev: # lib.optionalAttrs prev.stdenv.targetPlatform.isAarch64

     

       1060
       1060
       +
         {

     

       1061
       1061
       +
           rust_1_72 = lib.updateManyAttrsByPath [

     

       1062
       1062
       +
             {

     

       1063
       1063
       +
               path = [

     

       1064
       1064
       +
                 "packages"

     

       1065
       1065
       +
                 "stable"

     

       1066
       1066
       +
               ];

     

       1067
       1067
       +
               update =

     

       1068
       1068
       +
                 old:

     

       1069
       1069
       +
                 old.overrideScope (

     

       1070
       1070
       +
                   final: prev: {

     

       1071
       1071
       +
                     rustc-unwrapped = prev.rustc-unwrapped.overrideAttrs (_: {

     

       1072
       1072
       +
                       src = lib.cleanSource /git/scratch/rust;

     

       1073
       1073
       +
                       # do *not* put passthru.isReleaseTarball=true here

     

       1074
       1074
       +
                     });

     

       1075
       1075
       +
                   }

     

       1076
       1076
       +
                 );

     

       1077
       1077
       +
             }

     

       1078
       1078
       +
           ] prev.rust_1_72;

     

       1079
       1079
       +
         })

     

       1045
       1080
        
       ```

     

       1046
       1081
        
       

     

       1047
       1082
        
       If the problem you're troubleshooting only manifests when

+11 -2

doc/languages-frameworks/swift.section.md

···

       69
       69
        
       expression. The next step is to write that expression:

     

       70
       70
        
       

     

       71
       71
        
       ```nix

     

       72
       72
       -
       { stdenv, swift, swiftpm, swiftpm2nix, fetchFromGitHub }:

     

       72
       72
       +
       {

     

       73
       73
       +
         stdenv,

     

       74
       74
       +
         swift,

     

       75
       75
       +
         swiftpm,

     

       76
       76
       +
         swiftpm2nix,

     

       77
       77
       +
         fetchFromGitHub,

     

       78
       78
       +
       }:

     

       73
       79
        
       

     

       74
       80
        
       let

     

       75
       81
        
         # Pass the generated files to the helper.

     
···

       90
       96
        
         # Including SwiftPM as a nativeBuildInput provides a buildPhase for you.

     

       91
       97
        
         # This by default performs a release build using SwiftPM, essentially:

     

       92
       98
        
         #   swift build -c release

     

       93
       93
       -
         nativeBuildInputs = [ swift swiftpm ];

     

       99
       99
       +
         nativeBuildInputs = [

     

       100
       100
       +
           swift

     

       101
       101
       +
           swiftpm

     

       102
       102
       +
         ];

     

       94
       103
        
       

     

       95
       104
        
         # The helper provides a configure snippet that will prepare all dependencies

     

       96
       105
        
         # in the correct place, where SwiftPM expects them.

+59 -33

doc/languages-frameworks/texlive.section.md

···

       10
       10
        
       

     

       11
       11
        
       - Packages cannot be used directly but must be assembled in an environment. To create or add packages to an environment, use

     

       12
       12
        
         ```nix

     

       13
       13
       -
         texliveSmall.withPackages (ps: with ps; [ collection-langkorean algorithms cm-super ])

     

       13
       13
       +
         texliveSmall.withPackages (

     

       14
       14
       +
           ps: with ps; [

     

       15
       15
       +
             collection-langkorean

     

       16
       16
       +
             algorithms

     

       17
       17
       +
             cm-super

     

       18
       18
       +
           ]

     

       19
       19
       +
         )

     

       14
       20
        
         ```

     

       15
       21
        
         The function `withPackages` can be called multiple times to add more packages.

     

       16
       22
        
       

     
···

       18
       24
        
       

     

       19
       25
        
       - `texlive.withPackages` uses the same logic as `buildEnv`. Only parts of a package are installed in an environment: its 'runtime' files (`tex` output), binaries (`out` output), and support files (`tlpkg` output). Moreover, man and info pages are assembled into separate `man` and `info` outputs. To add only the TeX files of a package, or its documentation (`texdoc` output), just specify the outputs:

     

       20
       26
        
         ```nix

     

       21
       21
       -
         texlive.withPackages (ps: with ps; [

     

       22
       22
       -
           texdoc # recommended package to navigate the documentation

     

       23
       23
       -
           perlPackages.LaTeXML.tex # tex files of LaTeXML, omit binaries

     

       24
       24
       -
           cm-super

     

       25
       25
       -
           cm-super.texdoc # documentation of cm-super

     

       26
       26
       -
         ])

     

       27
       27
       +
         texlive.withPackages (

     

       28
       28
       +
           ps: with ps; [

     

       29
       29
       +
             texdoc # recommended package to navigate the documentation

     

       30
       30
       +
             perlPackages.LaTeXML.tex # tex files of LaTeXML, omit binaries

     

       31
       31
       +
             cm-super

     

       32
       32
       +
             cm-super.texdoc # documentation of cm-super

     

       33
       33
       +
           ]

     

       34
       34
       +
         )

     

       27
       35
        
         ```

     

       28
       36
        
       

     

       29
       37
        
       - All packages distributed by TeX Live, which contains most of CTAN, are available and can be found under `texlive.pkgs`:

     
···

       50
       58
        
       

     

       51
       59
        
         ```nix

     

       52
       60
        
         texlive.combine {

     

       53
       53
       -
           inherit (texlive) scheme-small collection-langkorean algorithms cm-super;

     

       61
       61
       +
           inherit (texlive)

     

       62
       62
       +
             scheme-small

     

       63
       63
       +
             collection-langkorean

     

       64
       64
       +
             algorithms

     

       65
       65
       +
             cm-super

     

       66
       66
       +
             ;

     

       54
       67
        
         }

     

       55
       68
        
         ```

     

       56
       69
        
       

     
···

       61
       74
        
         ```nix

     

       62
       75
        
         texlive.combine {

     

       63
       76
        
           # inherit (texlive) whatever-you-want;

     

       64
       64
       -
           pkgFilter = pkg:

     

       65
       65
       -
             pkg.tlType == "run" || pkg.tlType == "bin" || pkg.hasManpages || pkg.pname == "cm-super";

     

       77
       77
       +
           pkgFilter =

     

       78
       78
       +
             pkg: pkg.tlType == "run" || pkg.tlType == "bin" || pkg.hasManpages || pkg.pname == "cm-super";

     

       66
       79
        
           # elem tlType [ "run" "bin" "doc" "source" ]

     

       67
       80
        
           # there are also other attributes: version, name

     

       68
       81
        
         }

     
···

       114
       127
        
       Here is a (very verbose) example. See also the packages `auctex`, `eukleides`, `mftrace` for more examples.

     

       115
       128
        
       

     

       116
       129
        
       ```nix

     

       117
       117
       -
       with import <nixpkgs> {};

     

       130
       130
       +
       with import <nixpkgs> { };

     

       118
       131
        
       

     

       119
       132
        
       let

     

       120
       133
        
         foiltex = stdenvNoCC.mkDerivation {

     

       121
       134
        
           pname = "latex-foiltex";

     

       122
       135
        
           version = "2.1.4b";

     

       123
       136
        
       

     

       124
       124
       -
           outputs = [ "tex" "texdoc" ];

     

       137
       137
       +
           outputs = [

     

       138
       138
       +
             "tex"

     

       139
       139
       +
             "texdoc"

     

       140
       140
       +
           ];

     

       125
       141
        
           passthru.tlDeps = with texlive; [ latex ];

     

       126
       142
        
       

     

       127
       143
        
           srcs = [

     
···

       146
       162
        
           '';

     

       147
       163
        
       

     

       148
       164
        
           nativeBuildInputs = [

     

       149
       149
       -
             (texliveSmall.withPackages (ps: with ps; [ cm-super hypdoc latexmk ]))

     

       165
       165
       +
             (texliveSmall.withPackages (

     

       166
       166
       +
               ps: with ps; [

     

       167
       167
       +
                 cm-super

     

       168
       168
       +
                 hypdoc

     

       169
       169
       +
                 latexmk

     

       170
       170
       +
               ]

     

       171
       171
       +
             ))

     

       150
       172
        
             # multiple-outputs.sh fails if $out is not defined

     

       151
       173
        
             (writeShellScript "force-tex-output.sh" ''

     

       152
       174
        
               out="''${tex-}"

     
···

       192
       214
        
       

     

       193
       215
        
         latex_with_foiltex = texliveSmall.withPackages (_: [ foiltex ]);

     

       194
       216
        
       in

     

       195
       195
       -
         runCommand "test.pdf" {

     

       217
       217
       +
       runCommand "test.pdf"

     

       218
       218
       +
         {

     

       196
       219
        
           nativeBuildInputs = [ latex_with_foiltex ];

     

       197
       197
       -
         } ''

     

       198
       198
       -
       cat >test.tex <<EOF

     

       199
       199
       -
       \documentclass{foils}

     

       220
       220
       +
         }

     

       221
       221
       +
         ''

     

       222
       222
       +
           cat >test.tex <<EOF

     

       223
       223
       +
           \documentclass{foils}

     

       200
       224
        
       

     

       201
       201
       -
       \title{Presentation title}

     

       202
       202
       -
       \date{}

     

       225
       225
       +
           \title{Presentation title}

     

       226
       226
       +
           \date{}

     

       203
       227
        
       

     

       204
       204
       -
       \begin{document}

     

       205
       205
       -
       \maketitle

     

       206
       206
       -
       \end{document}

     

       207
       207
       -
       EOF

     

       208
       208
       -
         pdflatex test.tex

     

       209
       209
       -
         cp test.pdf $out

     

       210
       210
       -
       ''

     

       228
       228
       +
           \begin{document}

     

       229
       229
       +
           \maketitle

     

       230
       230
       +
           \end{document}

     

       231
       231
       +
           EOF

     

       232
       232
       +
             pdflatex test.tex

     

       233
       233
       +
             cp test.pdf $out

     

       234
       234
       +
         ''

     

       211
       235
        
       ```

     

       212
       236
        
       

     

       213
       237
        
       ## LuaLaTeX font cache {#sec-language-texlive-lualatex-font-cache}

     
···

       215
       239
        
       The font cache for LuaLaTeX is written to `$HOME`.

     

       216
       240
        
       Therefore, it is necessary to set `$HOME` to a writable path, e.g. [before using LuaLaTeX in nix derivations](https://github.com/NixOS/nixpkgs/issues/180639):

     

       217
       241
        
       ```nix

     

       218
       218
       -
       runCommandNoCC "lualatex-hello-world" {

     

       219
       219
       -
         buildInputs = [ texliveFull ];

     

       220
       220
       -
       } ''

     

       221
       221
       -
         mkdir $out

     

       222
       222
       -
         echo '\documentclass{article} \begin{document} Hello world \end{document}' > main.tex

     

       223
       223
       -
         env HOME=$(mktemp -d) lualatex  -interaction=nonstopmode -output-format=pdf -output-directory=$out ./main.tex

     

       224
       224
       -
       ''

     

       242
       242
       +
       runCommandNoCC "lualatex-hello-world"

     

       243
       243
       +
         {

     

       244
       244
       +
           buildInputs = [ texliveFull ];

     

       245
       245
       +
         }

     

       246
       246
       +
         ''

     

       247
       247
       +
           mkdir $out

     

       248
       248
       +
           echo '\documentclass{article} \begin{document} Hello world \end{document}' > main.tex

     

       249
       249
       +
           env HOME=$(mktemp -d) lualatex  -interaction=nonstopmode -output-format=pdf -output-directory=$out ./main.tex

     

       250
       250
       +
         ''

     

       225
       251
        
       ```

     

       226
       252
        
       

     

       227
       253
        
       Additionally, [the cache of a user can diverge from the nix store](https://github.com/NixOS/nixpkgs/issues/278718).

+36 -25

doc/languages-frameworks/vim.section.md

···

       47
       47
        
       vim-full.customize {

     

       48
       48
        
         vimrcConfig.packages.myVimPackage = with pkgs.vimPlugins; {

     

       49
       49
        
           # loaded on launch

     

       50
       50
       -
           start = [ youcompleteme fugitive ];

     

       50
       50
       +
           start = [

     

       51
       51
       +
             youcompleteme

     

       52
       52
       +
             fugitive

     

       53
       53
       +
           ];

     

       51
       54
        
           # manually loadable by calling `:packadd $plugin-name`

     

       52
       55
        
           # however, if a Vim plugin has a dependency that is not explicitly listed in

     

       53
       56
        
           # opt that dependency will always be added to start to avoid confusion.

     

       54
       54
       -
           opt = [ phpCompletion elm-vim ];

     

       57
       57
       +
           opt = [

     

       58
       58
       +
             phpCompletion

     

       59
       59
       +
             elm-vim

     

       60
       60
       +
           ];

     

       55
       61
        
           # To automatically load a plugin when opening a filetype, add vimrc lines like:

     

       56
       62
        
           # autocmd FileType php :packadd phpCompletion

     

       57
       63
        
         };

     
···

       63
       69
        
       

     

       64
       70
        
       ```nix

     

       65
       71
        
       {

     

       66
       66
       -
         packageOverrides = pkgs: with pkgs; {

     

       67
       67
       -
           myVim = vim-full.customize {

     

       68
       68
       -
             # `name` specifies the name of the executable and package

     

       69
       69
       -
             name = "vim-with-plugins";

     

       70
       70
       -
             # add here code from the example section

     

       71
       71
       -
           };

     

       72
       72
       -
           myNeovim = neovim.override {

     

       73
       73
       -
             configure = {

     

       74
       74
       -
             # add code from the example section here

     

       72
       72
       +
         packageOverrides =

     

       73
       73
       +
           pkgs: with pkgs; {

     

       74
       74
       +
             myVim = vim-full.customize {

     

       75
       75
       +
               # `name` specifies the name of the executable and package

     

       76
       76
       +
               name = "vim-with-plugins";

     

       77
       77
       +
               # add here code from the example section

     

       78
       78
       +
             };

     

       79
       79
       +
             myNeovim = neovim.override {

     

       80
       80
       +
               configure = {

     

       81
       81
       +
                 # add code from the example section here

     

       82
       82
       +
               };

     

       75
       83
        
             };

     

       76
       84
        
           };

     

       77
       77
       -
         };

     

       78
       85
        
       }

     

       79
       86
        
       ```

     

       80
       87
        
       

     
···

       100
       107
        
       in

     

       101
       108
        
       {

     

       102
       109
        
         environment.systemPackages = [

     

       103
       103
       -
           (

     

       104
       104
       -
             pkgs.neovim.override {

     

       105
       105
       -
               configure = {

     

       106
       106
       -
                 packages.myPlugins = with pkgs.vimPlugins; {

     

       110
       110
       +
           (pkgs.neovim.override {

     

       111
       111
       +
             configure = {

     

       112
       112
       +
               packages.myPlugins = with pkgs.vimPlugins; {

     

       107
       113
        
                 start = [

     

       108
       114
        
                   vim-go # already packaged plugin

     

       109
       115
        
                   easygrep # custom package

     

       110
       116
        
                 ];

     

       111
       111
       -
                 opt = [];

     

       117
       117
       +
                 opt = [ ];

     

       112
       118
        
               };

     

       113
       119
        
               # ...

     

       114
       120
        
             };

     

       115
       115
       -
            }

     

       116
       116
       -
           )

     

       121
       121
       +
           })

     

       117
       122
        
         ];

     

       118
       123
        
       }

     

       119
       124
        
       ```

     
···

       129
       134
        
       vim-full.customize {

     

       130
       135
        
         vimrcConfig.packages.myVimPackage = with pkgs.vimPlugins; {

     

       131
       136
        
           # loaded on launch

     

       132
       132
       -
           plug.plugins = [ youcompleteme fugitive phpCompletion elm-vim ];

     

       137
       137
       +
           plug.plugins = [

     

       138
       138
       +
             youcompleteme

     

       139
       139
       +
             fugitive

     

       140
       140
       +
             phpCompletion

     

       141
       141
       +
             elm-vim

     

       142
       142
       +
           ];

     

       133
       143
        
         };

     

       134
       144
        
       }

     

       135
       145
        
       ```

     
···

       147
       157
        
       

     

       148
       158
        
       ```nix

     

       149
       159
        
       {

     

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

     

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

     

       160
       160
       +
         deoplete-fish = super.deoplete-fish.overrideAttrs (old: {

     

       161
       161
       +
           dependencies = with super; [

     

       162
       162
       +
             deoplete-nvim

     

       163
       163
       +
             vim-fish

     

       164
       164
       +
           ];

     

       152
       165
        
         });

     

       153
       166
        
       }

     

       154
       167
        
       ```

     
···

       199
       212
        
       

     

       200
       213
        
       ```nix

     

       201
       214
        
       {

     

       202
       202
       -
         myVimPlugins = pkgs.vimPlugins.extend (

     

       203
       203
       -
           (pkgs.callPackage ./generated.nix {})

     

       204
       204
       -
         );

     

       215
       215
       +
         myVimPlugins = pkgs.vimPlugins.extend ((pkgs.callPackage ./generated.nix { }));

     

       205
       216
        
       }

     

       206
       217
        
       ```

     

       207
       218

+43 -37

doc/packages/cataclysm-dda.section.md

···

       48
       48
        
       

     

       49
       49
        
         # Unfortunately, this refers to the package before overriding and

     

       50
       50
        
         # parallel building is still disabled.

     

       51
       51
       -
         badExample = myCDDA.withMods (_: []);

     

       51
       51
       +
         badExample = myCDDA.withMods (_: [ ]);

     

       52
       52
        
       

     

       53
       53
        
         inherit (cataclysmDDA) attachPkgs pkgs wrapCDDA;

     

       54
       54
        
       

     
···

       66
       66
        
       

     

       67
       67
        
       # badExample                     # parallel building disabled

     

       68
       68
        
       # goodExample1.withMods (_: [])  # parallel building enabled

     

       69
       69
       -
       goodExample2.withMods (_: [])    # parallel building enabled

     

       69
       69
       +
       goodExample2.withMods (_: [ ]) # parallel building enabled

     

       70
       70
        
       ```

     

       71
       71
        
       

     

       72
       72
        
       ## Customizing with mods {#customizing-with-mods}

     
···

       75
       75
        
       attribute:

     

       76
       76
        
       

     

       77
       77
        
       ```nix

     

       78
       78
       -
       cataclysm-dda.withMods (mods: with mods; [

     

       79
       79
       -
         tileset.UndeadPeople

     

       80
       80
       -
       ])

     

       78
       78
       +
       cataclysm-dda.withMods (

     

       79
       79
       +
         mods: with mods; [

     

       80
       80
       +
           tileset.UndeadPeople

     

       81
       81
       +
         ]

     

       82
       82
       +
       )

     

       81
       83
        
       ```

     

       82
       84
        
       

     

       83
       85
        
       All mods, soundpacks, and tilesets available in nixpkgs are found in

     
···

       88
       90
        
       

     

       89
       91
        
       ```nix

     

       90
       92
        
       let

     

       91
       91
       -
         customMods = self: super: lib.recursiveUpdate super {

     

       92
       92
       -
           # Modify existing mod

     

       93
       93
       -
           tileset.UndeadPeople = super.tileset.UndeadPeople.overrideAttrs (old: {

     

       94
       94
       -
             # If you like to apply a patch to the tileset for example

     

       95
       95
       -
             patches = [ ./path/to/your.patch ];

     

       96
       96
       -
           });

     

       93
       93
       +
         customMods =

     

       94
       94
       +
           self: super:

     

       95
       95
       +
           lib.recursiveUpdate super {

     

       96
       96
       +
             # Modify existing mod

     

       97
       97
       +
             tileset.UndeadPeople = super.tileset.UndeadPeople.overrideAttrs (old: {

     

       98
       98
       +
               # If you like to apply a patch to the tileset for example

     

       99
       99
       +
               patches = [ ./path/to/your.patch ];

     

       100
       100
       +
             });

     

       97
       101
        
       

     

       98
       98
       -
           # Add another mod

     

       99
       99
       -
           mod.Awesome = cataclysmDDA.buildMod {

     

       100
       100
       -
             modName = "Awesome";

     

       101
       101
       -
             version = "0.x";

     

       102
       102
       -
             src = fetchFromGitHub {

     

       103
       103
       -
               owner = "Someone";

     

       104
       104
       -
               repo = "AwesomeMod";

     

       105
       105
       -
               rev = "...";

     

       106
       106
       -
               hash = "...";

     

       102
       102
       +
             # Add another mod

     

       103
       103
       +
             mod.Awesome = cataclysmDDA.buildMod {

     

       104
       104
       +
               modName = "Awesome";

     

       105
       105
       +
               version = "0.x";

     

       106
       106
       +
               src = fetchFromGitHub {

     

       107
       107
       +
                 owner = "Someone";

     

       108
       108
       +
                 repo = "AwesomeMod";

     

       109
       109
       +
                 rev = "...";

     

       110
       110
       +
                 hash = "...";

     

       111
       111
       +
               };

     

       112
       112
       +
               # Path to be installed in the unpacked source (default: ".")

     

       113
       113
       +
               modRoot = "contents/under/this/path/will/be/installed";

     

       107
       114
        
             };

     

       108
       108
       -
             # Path to be installed in the unpacked source (default: ".")

     

       109
       109
       -
             modRoot = "contents/under/this/path/will/be/installed";

     

       110
       110
       -
           };

     

       111
       115
        
       

     

       112
       112
       -
           # Add another soundpack

     

       113
       113
       -
           soundpack.Fantastic = cataclysmDDA.buildSoundPack {

     

       114
       114
       -
             # ditto

     

       115
       115
       -
           };

     

       116
       116
       +
             # Add another soundpack

     

       117
       117
       +
             soundpack.Fantastic = cataclysmDDA.buildSoundPack {

     

       118
       118
       +
               # ditto

     

       119
       119
       +
             };

     

       116
       120
        
       

     

       117
       117
       -
           # Add another tileset

     

       118
       118
       -
           tileset.SuperDuper = cataclysmDDA.buildTileSet {

     

       119
       119
       -
             # ditto

     

       121
       121
       +
             # Add another tileset

     

       122
       122
       +
             tileset.SuperDuper = cataclysmDDA.buildTileSet {

     

       123
       123
       +
               # ditto

     

       124
       124
       +
             };

     

       120
       125
        
           };

     

       121
       121
       -
         };

     

       122
       126
        
       in

     

       123
       123
       -
       cataclysm-dda.withMods (mods: with mods.extend customMods; [

     

       124
       124
       -
         tileset.UndeadPeople

     

       125
       125
       -
         mod.Awesome

     

       126
       126
       -
         soundpack.Fantastic

     

       127
       127
       -
         tileset.SuperDuper

     

       128
       128
       -
       ])

     

       127
       127
       +
       cataclysm-dda.withMods (

     

       128
       128
       +
         mods: with mods.extend customMods; [

     

       129
       129
       +
           tileset.UndeadPeople

     

       130
       130
       +
           mod.Awesome

     

       131
       131
       +
           soundpack.Fantastic

     

       132
       132
       +
           tileset.SuperDuper

     

       133
       133
       +
         ]

     

       134
       134
       +
       )

     

       129
       135
        
       ```

+2 -1

doc/packages/citrix.section.md

···

       28
       28
        
           ./custom-cert-1.pem

     

       29
       29
        
           ./custom-cert-2.pem # ...

     

       30
       30
        
         ];

     

       31
       31
       -
       in citrix_workspace.override { inherit extraCerts; }

     

       31
       31
       +
       in

     

       32
       32
       +
       citrix_workspace.override { inherit extraCerts; }

     

       32
       33
        
       ```

+72 -58

doc/packages/darwin-builder.section.md

···

       89
       89
        
           darwin.inputs.nixpkgs.follows = "nixpkgs";

     

       90
       90
        
         };

     

       91
       91
        
       

     

       92
       92
       -
         outputs = { self, darwin, nixpkgs, ... }@inputs:

     

       93
       93
       -
         let

     

       92
       92
       +
         outputs =

     

       93
       93
       +
           {

     

       94
       94
       +
             self,

     

       95
       95
       +
             darwin,

     

       96
       96
       +
             nixpkgs,

     

       97
       97
       +
             ...

     

       98
       98
       +
           }@inputs:

     

       99
       99
       +
           let

     

       94
       100
        
       

     

       95
       95
       -
           inherit (darwin.lib) darwinSystem;

     

       96
       96
       -
           system = "aarch64-darwin";

     

       97
       97
       -
           pkgs = nixpkgs.legacyPackages."${system}";

     

       98
       98
       -
           linuxSystem = builtins.replaceStrings [ "darwin" ] [ "linux" ] system;

     

       101
       101
       +
             inherit (darwin.lib) darwinSystem;

     

       102
       102
       +
             system = "aarch64-darwin";

     

       103
       103
       +
             pkgs = nixpkgs.legacyPackages."${system}";

     

       104
       104
       +
             linuxSystem = builtins.replaceStrings [ "darwin" ] [ "linux" ] system;

     

       99
       105
        
       

     

       100
       100
       -
           darwin-builder = nixpkgs.lib.nixosSystem {

     

       101
       101
       -
             system = linuxSystem;

     

       102
       102
       -
             modules = [

     

       103
       103
       -
               "${nixpkgs}/nixos/modules/profiles/nix-builder-vm.nix"

     

       104
       104
       -
               { virtualisation = {

     

       105
       105
       -
                   host.pkgs = pkgs;

     

       106
       106
       -
                   darwin-builder.workingDirectory = "/var/lib/darwin-builder";

     

       107
       107
       -
                   darwin-builder.hostPort = 22;

     

       108
       108
       -
                 };

     

       109
       109
       -
               }

     

       110
       110
       -
             ];

     

       111
       111
       -
           };

     

       112
       112
       -
         in {

     

       113
       113
       -
       

     

       114
       114
       -
           darwinConfigurations = {

     

       115
       115
       -
             machine1 = darwinSystem {

     

       116
       116
       -
               inherit system;

     

       106
       106
       +
             darwin-builder = nixpkgs.lib.nixosSystem {

     

       107
       107
       +
               system = linuxSystem;

     

       117
       108
        
               modules = [

     

       109
       109
       +
                 "${nixpkgs}/nixos/modules/profiles/nix-builder-vm.nix"

     

       118
       110
        
                 {

     

       119
       119
       -
                   nix.distributedBuilds = true;

     

       120
       120
       -
                   nix.buildMachines = [{

     

       121
       121
       -
                     hostName = "localhost";

     

       122
       122
       -
                     sshUser = "builder";

     

       123
       123
       -
                     sshKey = "/etc/nix/builder_ed25519";

     

       124
       124
       -
                     system = linuxSystem;

     

       125
       125
       -
                     maxJobs = 4;

     

       126
       126
       -
                     supportedFeatures = [ "kvm" "benchmark" "big-parallel" ];

     

       127
       127
       -
                   }];

     

       128
       128
       -
       

     

       129
       129
       -
                   launchd.daemons.darwin-builder = {

     

       130
       130
       -
                     command = "${darwin-builder.config.system.build.macos-builder-installer}/bin/create-builder";

     

       131
       131
       -
                     serviceConfig = {

     

       132
       132
       -
                       KeepAlive = true;

     

       133
       133
       -
                       RunAtLoad = true;

     

       134
       134
       -
                       StandardOutPath = "/var/log/darwin-builder.log";

     

       135
       135
       -
                       StandardErrorPath = "/var/log/darwin-builder.log";

     

       136
       136
       -
                     };

     

       111
       111
       +
                   virtualisation = {

     

       112
       112
       +
                     host.pkgs = pkgs;

     

       113
       113
       +
                     darwin-builder.workingDirectory = "/var/lib/darwin-builder";

     

       114
       114
       +
                     darwin-builder.hostPort = 22;

     

       137
       115
        
                   };

     

       138
       116
        
                 }

     

       139
       117
        
               ];

     

       140
       118
        
             };

     

       141
       141
       -
           };

     

       119
       119
       +
           in

     

       120
       120
       +
           {

     

       142
       121
        
       

     

       143
       143
       -
         };

     

       122
       122
       +
             darwinConfigurations = {

     

       123
       123
       +
               machine1 = darwinSystem {

     

       124
       124
       +
                 inherit system;

     

       125
       125
       +
                 modules = [

     

       126
       126
       +
                   {

     

       127
       127
       +
                     nix.distributedBuilds = true;

     

       128
       128
       +
                     nix.buildMachines = [

     

       129
       129
       +
                       {

     

       130
       130
       +
                         hostName = "localhost";

     

       131
       131
       +
                         sshUser = "builder";

     

       132
       132
       +
                         sshKey = "/etc/nix/builder_ed25519";

     

       133
       133
       +
                         system = linuxSystem;

     

       134
       134
       +
                         maxJobs = 4;

     

       135
       135
       +
                         supportedFeatures = [

     

       136
       136
       +
                           "kvm"

     

       137
       137
       +
                           "benchmark"

     

       138
       138
       +
                           "big-parallel"

     

       139
       139
       +
                         ];

     

       140
       140
       +
                       }

     

       141
       141
       +
                     ];

     

       142
       142
       +
       

     

       143
       143
       +
                     launchd.daemons.darwin-builder = {

     

       144
       144
       +
                       command = "${darwin-builder.config.system.build.macos-builder-installer}/bin/create-builder";

     

       145
       145
       +
                       serviceConfig = {

     

       146
       146
       +
                         KeepAlive = true;

     

       147
       147
       +
                         RunAtLoad = true;

     

       148
       148
       +
                         StandardOutPath = "/var/log/darwin-builder.log";

     

       149
       149
       +
                         StandardErrorPath = "/var/log/darwin-builder.log";

     

       150
       150
       +
                       };

     

       151
       151
       +
                     };

     

       152
       152
       +
                   }

     

       153
       153
       +
                 ];

     

       154
       154
       +
               };

     

       155
       155
       +
             };

     

       156
       156
       +
       

     

       157
       157
       +
           };

     

       144
       158
        
       }

     

       145
       159
        
       ```

     

       146
       160
        
       

     
···

       154
       168
        
       in the example below and rebuild.

     

       155
       169
        
       

     

       156
       170
        
       ```nix

     

       157
       157
       -
         {

     

       158
       158
       -
           darwin-builder = nixpkgs.lib.nixosSystem {

     

       159
       159
       -
             system = linuxSystem;

     

       160
       160
       -
             modules = [

     

       161
       161
       -
               "${nixpkgs}/nixos/modules/profiles/nix-builder-vm.nix"

     

       162
       162
       -
               {

     

       163
       163
       -
                 virtualisation.host.pkgs = pkgs;

     

       164
       164
       -
                 virtualisation.darwin-builder.diskSize = 5120;

     

       165
       165
       -
                 virtualisation.darwin-builder.memorySize = 1024;

     

       166
       166
       -
                 virtualisation.darwin-builder.hostPort = 33022;

     

       167
       167
       -
                 virtualisation.darwin-builder.workingDirectory = "/var/lib/darwin-builder";

     

       168
       168
       -
               }

     

       169
       169
       -
             ];

     

       170
       170
       -
           };

     

       171
       171
       -
         }

     

       171
       171
       +
       {

     

       172
       172
       +
         darwin-builder = nixpkgs.lib.nixosSystem {

     

       173
       173
       +
           system = linuxSystem;

     

       174
       174
       +
           modules = [

     

       175
       175
       +
             "${nixpkgs}/nixos/modules/profiles/nix-builder-vm.nix"

     

       176
       176
       +
             {

     

       177
       177
       +
               virtualisation.host.pkgs = pkgs;

     

       178
       178
       +
               virtualisation.darwin-builder.diskSize = 5120;

     

       179
       179
       +
               virtualisation.darwin-builder.memorySize = 1024;

     

       180
       180
       +
               virtualisation.darwin-builder.hostPort = 33022;

     

       181
       181
       +
               virtualisation.darwin-builder.workingDirectory = "/var/lib/darwin-builder";

     

       182
       182
       +
             }

     

       183
       183
       +
           ];

     

       184
       184
       +
         };

     

       185
       185
       +
       }

     

       172
       186
        
       ```

     

       173
       187
        
       

     

       174
       188
        
       You may make any other changes to your VM in this attribute set. For example,

+35 -31

doc/packages/eclipse.section.md

···

       15
       15
        
       ```nix

     

       16
       16
        
       {

     

       17
       17
        
         packageOverrides = pkgs: {

     

       18
       18
       -
           myEclipse = with pkgs.eclipses; eclipseWithPlugins {

     

       19
       19
       -
             eclipse = eclipse-platform;

     

       20
       20
       -
             jvmArgs = [ "-Xmx2048m" ];

     

       21
       21
       -
             plugins = [ plugins.color-theme ];

     

       22
       22
       -
           };

     

       18
       18
       +
           myEclipse =

     

       19
       19
       +
             with pkgs.eclipses;

     

       20
       20
       +
             eclipseWithPlugins {

     

       21
       21
       +
               eclipse = eclipse-platform;

     

       22
       22
       +
               jvmArgs = [ "-Xmx2048m" ];

     

       23
       23
       +
               plugins = [ plugins.color-theme ];

     

       24
       24
       +
             };

     

       23
       25
        
         };

     

       24
       26
        
       }

     

       25
       27
        
       ```

     
···

       37
       39
        
       ```nix

     

       38
       40
        
       {

     

       39
       41
        
         packageOverrides = pkgs: {

     

       40
       40
       -
           myEclipse = with pkgs.eclipses; eclipseWithPlugins {

     

       41
       41
       -
             eclipse = eclipse-platform;

     

       42
       42
       -
             jvmArgs = [ "-Xmx2048m" ];

     

       43
       43
       -
             plugins = [

     

       44
       44
       -
               plugins.color-theme

     

       45
       45
       -
               (plugins.buildEclipsePlugin {

     

       46
       46
       -
                 name = "myplugin1-1.0";

     

       47
       47
       -
                 srcFeature = fetchurl {

     

       48
       48
       -
                   url = "http://…/features/myplugin1.jar";

     

       49
       49
       -
                   hash = "sha256-123…";

     

       50
       50
       -
                 };

     

       51
       51
       -
                 srcPlugin = fetchurl {

     

       52
       52
       -
                   url = "http://…/plugins/myplugin1.jar";

     

       53
       53
       -
                   hash = "sha256-123…";

     

       54
       54
       -
                 };

     

       55
       55
       -
               })

     

       56
       56
       -
               (plugins.buildEclipseUpdateSite {

     

       57
       57
       -
                 name = "myplugin2-1.0";

     

       58
       58
       -
                 src = fetchurl {

     

       59
       59
       -
                   stripRoot = false;

     

       60
       60
       -
                   url = "http://…/myplugin2.zip";

     

       61
       61
       -
                   hash = "sha256-123…";

     

       62
       62
       -
                 };

     

       63
       63
       -
               })

     

       64
       64
       -
             ];

     

       65
       65
       -
           };

     

       42
       42
       +
           myEclipse =

     

       43
       43
       +
             with pkgs.eclipses;

     

       44
       44
       +
             eclipseWithPlugins {

     

       45
       45
       +
               eclipse = eclipse-platform;

     

       46
       46
       +
               jvmArgs = [ "-Xmx2048m" ];

     

       47
       47
       +
               plugins = [

     

       48
       48
       +
                 plugins.color-theme

     

       49
       49
       +
                 (plugins.buildEclipsePlugin {

     

       50
       50
       +
                   name = "myplugin1-1.0";

     

       51
       51
       +
                   srcFeature = fetchurl {

     

       52
       52
       +
                     url = "http://…/features/myplugin1.jar";

     

       53
       53
       +
                     hash = "sha256-123…";

     

       54
       54
       +
                   };

     

       55
       55
       +
                   srcPlugin = fetchurl {

     

       56
       56
       +
                     url = "http://…/plugins/myplugin1.jar";

     

       57
       57
       +
                     hash = "sha256-123…";

     

       58
       58
       +
                   };

     

       59
       59
       +
                 })

     

       60
       60
       +
                 (plugins.buildEclipseUpdateSite {

     

       61
       61
       +
                   name = "myplugin2-1.0";

     

       62
       62
       +
                   src = fetchurl {

     

       63
       63
       +
                     stripRoot = false;

     

       64
       64
       +
                     url = "http://…/myplugin2.zip";

     

       65
       65
       +
                     hash = "sha256-123…";

     

       66
       66
       +
                   };

     

       67
       67
       +
                 })

     

       68
       68
       +
               ];

     

       69
       69
       +
             };

     

       66
       70
        
         };

     

       67
       71
        
       }

     

       68
       72
        
       ```

+85 -76

doc/packages/emacs.section.md

···

       6
       6
        
       

     

       7
       7
        
       ```nix

     

       8
       8
        
       {

     

       9
       9
       -
         packageOverrides = pkgs: with pkgs; {

     

       10
       10
       -
           myEmacs = emacs.pkgs.withPackages (epkgs: (with epkgs.melpaStablePackages; [

     

       11
       11
       -
             company

     

       12
       12
       -
             counsel

     

       13
       13
       -
             flycheck

     

       14
       14
       -
             ivy

     

       15
       15
       -
             magit

     

       16
       16
       -
             projectile

     

       17
       17
       -
             use-package

     

       18
       18
       -
           ]));

     

       19
       19
       -
         };

     

       9
       9
       +
         packageOverrides =

     

       10
       10
       +
           pkgs: with pkgs; {

     

       11
       11
       +
             myEmacs = emacs.pkgs.withPackages (

     

       12
       12
       +
               epkgs:

     

       13
       13
       +
               (with epkgs.melpaStablePackages; [

     

       14
       14
       +
                 company

     

       15
       15
       +
                 counsel

     

       16
       16
       +
                 flycheck

     

       17
       17
       +
                 ivy

     

       18
       18
       +
                 magit

     

       19
       19
       +
                 projectile

     

       20
       20
       +
                 use-package

     

       21
       21
       +
               ])

     

       22
       22
       +
             );

     

       23
       23
       +
           };

     

       20
       24
        
       }

     

       21
       25
        
       ```

     

       22
       26
        
       

     
···

       24
       28
        
       

     

       25
       29
        
       ```nix

     

       26
       30
        
       {

     

       27
       27
       -
         packageOverrides = pkgs: with pkgs; rec {

     

       28
       28
       -
           myEmacsConfig = writeText "default.el" ''

     

       29
       29
       -
             (eval-when-compile

     

       30
       30
       -
               (require 'use-package))

     

       31
       31
       +
         packageOverrides =

     

       32
       32
       +
           pkgs: with pkgs; rec {

     

       33
       33
       +
             myEmacsConfig = writeText "default.el" ''

     

       34
       34
       +
               (eval-when-compile

     

       35
       35
       +
                 (require 'use-package))

     

       31
       36
        
       

     

       32
       32
       -
             ;; load some packages

     

       37
       37
       +
               ;; load some packages

     

       33
       38
        
       

     

       34
       34
       -
             (use-package company

     

       35
       35
       -
               :bind ("<C-tab>" . company-complete)

     

       36
       36
       -
               :diminish company-mode

     

       37
       37
       -
               :commands (company-mode global-company-mode)

     

       38
       38
       -
               :defer 1

     

       39
       39
       -
               :config

     

       40
       40
       -
               (global-company-mode))

     

       39
       39
       +
               (use-package company

     

       40
       40
       +
                 :bind ("<C-tab>" . company-complete)

     

       41
       41
       +
                 :diminish company-mode

     

       42
       42
       +
                 :commands (company-mode global-company-mode)

     

       43
       43
       +
                 :defer 1

     

       44
       44
       +
                 :config

     

       45
       45
       +
                 (global-company-mode))

     

       41
       46
        
       

     

       42
       42
       -
             (use-package counsel

     

       43
       43
       -
               :commands (counsel-descbinds)

     

       44
       44
       -
               :bind (([remap execute-extended-command] . counsel-M-x)

     

       45
       45
       -
                      ("C-x C-f" . counsel-find-file)

     

       46
       46
       -
                      ("C-c g" . counsel-git)

     

       47
       47
       -
                      ("C-c j" . counsel-git-grep)

     

       48
       48
       -
                      ("C-c k" . counsel-ag)

     

       49
       49
       -
                      ("C-x l" . counsel-locate)

     

       50
       50
       -
                      ("M-y" . counsel-yank-pop)))

     

       47
       47
       +
               (use-package counsel

     

       48
       48
       +
                 :commands (counsel-descbinds)

     

       49
       49
       +
                 :bind (([remap execute-extended-command] . counsel-M-x)

     

       50
       50
       +
                        ("C-x C-f" . counsel-find-file)

     

       51
       51
       +
                        ("C-c g" . counsel-git)

     

       52
       52
       +
                        ("C-c j" . counsel-git-grep)

     

       53
       53
       +
                        ("C-c k" . counsel-ag)

     

       54
       54
       +
                        ("C-x l" . counsel-locate)

     

       55
       55
       +
                        ("M-y" . counsel-yank-pop)))

     

       51
       56
        
       

     

       52
       52
       -
             (use-package flycheck

     

       53
       53
       -
               :defer 2

     

       54
       54
       -
               :config (global-flycheck-mode))

     

       57
       57
       +
               (use-package flycheck

     

       58
       58
       +
                 :defer 2

     

       59
       59
       +
                 :config (global-flycheck-mode))

     

       55
       60
        
       

     

       56
       56
       -
             (use-package ivy

     

       57
       57
       -
               :defer 1

     

       58
       58
       -
               :bind (("C-c C-r" . ivy-resume)

     

       59
       59
       -
                      ("C-x C-b" . ivy-switch-buffer)

     

       60
       60
       -
                      :map ivy-minibuffer-map

     

       61
       61
       -
                      ("C-j" . ivy-call))

     

       62
       62
       -
               :diminish ivy-mode

     

       63
       63
       -
               :commands ivy-mode

     

       64
       64
       -
               :config

     

       65
       65
       -
               (ivy-mode 1))

     

       61
       61
       +
               (use-package ivy

     

       62
       62
       +
                 :defer 1

     

       63
       63
       +
                 :bind (("C-c C-r" . ivy-resume)

     

       64
       64
       +
                        ("C-x C-b" . ivy-switch-buffer)

     

       65
       65
       +
                        :map ivy-minibuffer-map

     

       66
       66
       +
                        ("C-j" . ivy-call))

     

       67
       67
       +
                 :diminish ivy-mode

     

       68
       68
       +
                 :commands ivy-mode

     

       69
       69
       +
                 :config

     

       70
       70
       +
                 (ivy-mode 1))

     

       66
       71
        
       

     

       67
       67
       -
             (use-package magit

     

       68
       68
       -
               :defer

     

       69
       69
       -
               :if (executable-find "git")

     

       70
       70
       -
               :bind (("C-x g" . magit-status)

     

       71
       71
       -
                      ("C-x G" . magit-dispatch-popup))

     

       72
       72
       -
               :init

     

       73
       73
       -
               (setq magit-completing-read-function 'ivy-completing-read))

     

       72
       72
       +
               (use-package magit

     

       73
       73
       +
                 :defer

     

       74
       74
       +
                 :if (executable-find "git")

     

       75
       75
       +
                 :bind (("C-x g" . magit-status)

     

       76
       76
       +
                        ("C-x G" . magit-dispatch-popup))

     

       77
       77
       +
                 :init

     

       78
       78
       +
                 (setq magit-completing-read-function 'ivy-completing-read))

     

       74
       79
        
       

     

       75
       75
       -
             (use-package projectile

     

       76
       76
       -
               :commands projectile-mode

     

       77
       77
       -
               :bind-keymap ("C-c p" . projectile-command-map)

     

       78
       78
       -
               :defer 5

     

       79
       79
       -
               :config

     

       80
       80
       -
               (projectile-global-mode))

     

       81
       81
       -
           '';

     

       80
       80
       +
               (use-package projectile

     

       81
       81
       +
                 :commands projectile-mode

     

       82
       82
       +
                 :bind-keymap ("C-c p" . projectile-command-map)

     

       83
       83
       +
                 :defer 5

     

       84
       84
       +
                 :config

     

       85
       85
       +
                 (projectile-global-mode))

     

       86
       86
       +
             '';

     

       82
       87
        
       

     

       83
       83
       -
           myEmacs = emacs.pkgs.withPackages (epkgs: (with epkgs.melpaStablePackages; [

     

       84
       84
       -
             (runCommand "default.el" {} ''

     

       85
       85
       -
                mkdir -p $out/share/emacs/site-lisp

     

       86
       86
       -
                cp ${myEmacsConfig} $out/share/emacs/site-lisp/default.el

     

       87
       87
       -
              '')

     

       88
       88
       -
             company

     

       89
       89
       -
             counsel

     

       90
       90
       -
             flycheck

     

       91
       91
       -
             ivy

     

       92
       92
       -
             magit

     

       93
       93
       -
             projectile

     

       94
       94
       -
             use-package

     

       95
       95
       -
           ]));

     

       96
       96
       -
         };

     

       88
       88
       +
             myEmacs = emacs.pkgs.withPackages (

     

       89
       89
       +
               epkgs:

     

       90
       90
       +
               (with epkgs.melpaStablePackages; [

     

       91
       91
       +
                 (runCommand "default.el" { } ''

     

       92
       92
       +
                   mkdir -p $out/share/emacs/site-lisp

     

       93
       93
       +
                   cp ${myEmacsConfig} $out/share/emacs/site-lisp/default.el

     

       94
       94
       +
                 '')

     

       95
       95
       +
                 company

     

       96
       96
       +
                 counsel

     

       97
       97
       +
                 flycheck

     

       98
       98
       +
                 ivy

     

       99
       99
       +
                 magit

     

       100
       100
       +
                 projectile

     

       101
       101
       +
                 use-package

     

       102
       102
       +
               ])

     

       103
       103
       +
             );

     

       104
       104
       +
           };

     

       97
       105
        
       }

     

       98
       106
        
       ```

     

       99
       107
        
       

     
···

       108
       116
        
           # ...

     

       109
       117
        
         };

     

       110
       118
        
       in

     

       111
       111
       -
       ((emacsPackagesFor emacs).overrideScope overrides).withPackages

     

       112
       112
       -
         (p: with p; [

     

       119
       119
       +
       ((emacsPackagesFor emacs).overrideScope overrides).withPackages (

     

       120
       120
       +
         p: with p; [

     

       113
       121
        
           # here both these package will use haskell-mode of our own choice

     

       114
       122
        
           ghc-mod

     

       115
       123
        
           dante

     

       116
       116
       -
         ])

     

       124
       124
       +
         ]

     

       125
       125
       +
       )

     

       117
       126
        
       ```

     

       118
       127
        
       }

+6 -3

doc/packages/fish.section.md

···

       42
       42
        
       

     

       43
       43
        
       ```nix

     

       44
       44
        
       wrapFish {

     

       45
       45
       -
         pluginPkgs = with fishPlugins; [ pure foreign-env ];

     

       46
       46
       -
         completionDirs = [];

     

       47
       47
       -
         functionDirs = [];

     

       45
       45
       +
         pluginPkgs = with fishPlugins; [

     

       46
       46
       +
           pure

     

       47
       47
       +
           foreign-env

     

       48
       48
       +
         ];

     

       49
       49
       +
         completionDirs = [ ];

     

       50
       50
       +
         functionDirs = [ ];

     

       48
       51
        
         confDirs = [ "/path/to/some/fish/init/dir/" ];

     

       49
       52
        
       }

     

       50
       53
        
       ```

+10 -3

doc/packages/ibus.section.md

···

       9
       9
        
       On NixOS, you need to explicitly enable `ibus` with given engines before customizing your desktop to use `typing-booster`. This can be achieved using the `ibus` module:

     

       10
       10
        
       

     

       11
       11
        
       ```nix

     

       12
       12
       -
       { pkgs, ... }: {

     

       12
       12
       +
       { pkgs, ... }:

     

       13
       13
       +
       {

     

       13
       14
        
         i18n.inputMethod = {

     

       14
       15
        
           enable = true;

     

       15
       16
        
           type = "ibus";

     
···

       23
       24
        
       The IBus engine is based on `hunspell` to support completion in many languages. By default, the dictionaries `de-de`, `en-us`, `fr-moderne` `es-es`, `it-it`, `sv-se` and `sv-fi` are in use. To add another dictionary, the package can be overridden like this:

     

       24
       25
        
       

     

       25
       26
        
       ```nix

     

       26
       26
       -
       ibus-engines.typing-booster.override { langs = [ "de-at" "en-gb" ]; }

     

       27
       27
       +
       ibus-engines.typing-booster.override {

     

       28
       28
       +
         langs = [

     

       29
       29
       +
           "de-at"

     

       30
       30
       +
           "en-gb"

     

       31
       31
       +
         ];

     

       32
       32
       +
       }

     

       27
       33
        
       ```

     

       28
       34
        
       

     

       29
       35
        
       _Note: each language passed to `langs` must be an attribute name in `pkgs.hunspellDicts`._

     
···

       35
       41
        
       On NixOS, it can be installed using the following expression:

     

       36
       42
        
       

     

       37
       43
        
       ```nix

     

       38
       38
       -
       { pkgs, ... }: {

     

       44
       44
       +
       { pkgs, ... }:

     

       45
       45
       +
       {

     

       39
       46
        
         fonts.packages = with pkgs; [ noto-fonts-color-emoji ];

     

       40
       47
        
       }

     

       41
       48
        
       ```

+1 -1

doc/packages/krita.section.md

···

       23
       23
        
       

     

       24
       24
        
       ```nix

     

       25
       25
        
       (pkgs.krita.override (old: {

     

       26
       26
       -
           binaryPlugins = old.binaryPlugins ++ [ your-plugin ];

     

       26
       26
       +
         binaryPlugins = old.binaryPlugins ++ [ your-plugin ];

     

       27
       27
        
       }))

     

       28
       28
        
       ```

     

       29
       29

+9 -5

doc/packages/python-tree-sitter.section.md

···

       7
       7
        
       For example, to experiment with the Rust grammar, you can create a shell environment with the following configuration:

     

       8
       8
        
       

     

       9
       9
        
       ```nix

     

       10
       10
       -
       { pkgs ? <nixpkgs> {} }:

     

       10
       10
       +
       {

     

       11
       11
       +
         pkgs ? <nixpkgs> { },

     

       12
       12
       +
       }:

     

       11
       13
        
       

     

       12
       14
        
       pkgs.mkShell {

     

       13
       15
        
         name = "py-tree-sitter-dev-shell";

     

       14
       16
        
       

     

       15
       17
        
         buildInputs = with pkgs; [

     

       16
       16
       -
           (python3.withPackages (ps: with ps; [

     

       17
       17
       -
             tree-sitter

     

       18
       18
       -
             tree-sitter-grammars.tree-sitter-rust

     

       19
       19
       -
           ]))

     

       18
       18
       +
           (python3.withPackages (

     

       19
       19
       +
             ps: with ps; [

     

       20
       20
       +
               tree-sitter

     

       21
       21
       +
               tree-sitter-grammars.tree-sitter-rust

     

       22
       22
       +
             ]

     

       23
       23
       +
           ))

     

       20
       24
        
         ];

     

       21
       25
        
       }

     

       22
       26
        
       ```

+24 -12

doc/packages/urxvt.section.md

···

       8
       8
        
       

     

       9
       9
        
       ```nix

     

       10
       10
        
       rxvt-unicode.override {

     

       11
       11
       -
         configure = { availablePlugins, ... }: {

     

       12
       12
       -
           plugins = with availablePlugins; [ perls resize-font vtwheel ];

     

       13
       13
       -
         };

     

       11
       11
       +
         configure =

     

       12
       12
       +
           { availablePlugins, ... }:

     

       13
       13
       +
           {

     

       14
       14
       +
             plugins = with availablePlugins; [

     

       15
       15
       +
               perls

     

       16
       16
       +
               resize-font

     

       17
       17
       +
               vtwheel

     

       18
       18
       +
             ];

     

       19
       19
       +
           };

     

       14
       20
        
       }

     

       15
       21
        
       ```

     

       16
       22
        
       

     
···

       20
       26
        
       

     

       21
       27
        
       ```nix

     

       22
       28
        
       rxvt-unicode.override {

     

       23
       23
       -
         configure = { availablePlugins, ... }: {

     

       24
       24
       -
           plugins = (builtins.attrValues availablePlugins) ++ [ custom-plugin ];

     

       25
       25
       -
         };

     

       29
       29
       +
         configure =

     

       30
       30
       +
           { availablePlugins, ... }:

     

       31
       31
       +
           {

     

       32
       32
       +
             plugins = (builtins.attrValues availablePlugins) ++ [ custom-plugin ];

     

       33
       33
       +
           };

     

       26
       34
        
       }

     

       27
       35
        
       ```

     

       28
       36
        
       

     
···

       40
       48
        
       

     

       41
       49
        
       ```nix

     

       42
       50
        
       rxvt-unicode.override {

     

       43
       43
       -
         configure = { availablePlugins, ... }: {

     

       44
       44
       -
           pluginsDeps = [ xsel ];

     

       45
       45
       -
         };

     

       51
       51
       +
         configure =

     

       52
       52
       +
           { availablePlugins, ... }:

     

       53
       53
       +
           {

     

       54
       54
       +
             pluginsDeps = [ xsel ];

     

       55
       55
       +
           };

     

       46
       56
        
       }

     

       47
       57
        
       ```

     

       48
       58
        
       

     
···

       50
       60
        
       

     

       51
       61
        
       ```nix

     

       52
       62
        
       rxvt-unicode.override {

     

       53
       53
       -
         configure = { availablePlugins, ... }: {

     

       54
       54
       -
           perlDeps = with perlPackages; [ AnyEvent ];

     

       55
       55
       -
         };

     

       63
       63
       +
         configure =

     

       64
       64
       +
           { availablePlugins, ... }:

     

       65
       65
       +
           {

     

       66
       66
       +
             perlDeps = with perlPackages; [ AnyEvent ];

     

       67
       67
       +
           };

     

       56
       68
        
       }

     

       57
       69
        
       ```

     

       58
       70

+63 -27

doc/packages/weechat.section.md

···

       3
       3
        
       WeeChat can be configured to include your choice of plugins, reducing its closure size from the default configuration which includes all available plugins. To make use of this functionality, install an expression that overrides its configuration, such as:

     

       4
       4
        
       

     

       5
       5
        
       ```nix

     

       6
       6
       -
       weechat.override {configure = ({availablePlugins, ...}: {

     

       7
       7
       -
           plugins = with availablePlugins; [ python perl ];

     

       8
       8
       -
         });

     

       6
       6
       +
       weechat.override {

     

       7
       7
       +
         configure = (

     

       8
       8
       +
           { availablePlugins, ... }:

     

       9
       9
       +
           {

     

       10
       10
       +
             plugins = with availablePlugins; [

     

       11
       11
       +
               python

     

       12
       12
       +
               perl

     

       13
       13
       +
             ];

     

       14
       14
       +
           }

     

       15
       15
       +
         );

     

       9
       16
        
       }

     

       10
       17
        
       ```

     

       11
       18
        
       

     
···

       16
       23
        
       The Python and Perl plugins allows the addition of extra libraries. For instance, the `inotify.py` script in `weechat-scripts` requires D-Bus or libnotify, and the `fish.py` script requires `pycrypto`. To use these scripts, use the plugin's `withPackages` attribute:

     

       17
       24
        
       

     

       18
       25
        
       ```nix

     

       19
       19
       -
       weechat.override { configure = {availablePlugins, ...}: {

     

       20
       20
       -
           plugins = with availablePlugins; [

     

       21
       21
       -
                   (python.withPackages (ps: with ps; [ pycrypto python-dbus ]))

     

       22
       22
       -
               ];

     

       26
       26
       +
       weechat.override {

     

       27
       27
       +
         configure =

     

       28
       28
       +
           { availablePlugins, ... }:

     

       29
       29
       +
           {

     

       30
       30
       +
             plugins = with availablePlugins; [

     

       31
       31
       +
               (python.withPackages (

     

       32
       32
       +
                 ps: with ps; [

     

       33
       33
       +
                   pycrypto

     

       34
       34
       +
                   python-dbus

     

       35
       35
       +
                 ]

     

       36
       36
       +
               ))

     

       37
       37
       +
             ];

     

       23
       38
        
           };

     

       24
       39
        
       }

     

       25
       40
        
       ```

     
···

       27
       42
        
       In order to also keep all default plugins installed, it is possible to use the following method:

     

       28
       43
        
       

     

       29
       44
        
       ```nix

     

       30
       30
       -
       weechat.override { configure = { availablePlugins, ... }: {

     

       31
       31
       -
         plugins = builtins.attrValues (availablePlugins // {

     

       32
       32
       -
           python = availablePlugins.python.withPackages (ps: with ps; [ pycrypto python-dbus ]);

     

       33
       33
       -
         });

     

       34
       34
       -
       }; }

     

       45
       45
       +
       weechat.override {

     

       46
       46
       +
         configure =

     

       47
       47
       +
           { availablePlugins, ... }:

     

       48
       48
       +
           {

     

       49
       49
       +
             plugins = builtins.attrValues (

     

       50
       50
       +
               availablePlugins

     

       51
       51
       +
               // {

     

       52
       52
       +
                 python = availablePlugins.python.withPackages (

     

       53
       53
       +
                   ps: with ps; [

     

       54
       54
       +
                     pycrypto

     

       55
       55
       +
                     python-dbus

     

       56
       56
       +
                   ]

     

       57
       57
       +
                 );

     

       58
       58
       +
               }

     

       59
       59
       +
             );

     

       60
       60
       +
           };

     

       61
       61
       +
       }

     

       35
       62
        
       ```

     

       36
       63
        
       

     

       37
       64
        
       WeeChat allows to set defaults on startup using the `--run-command`. The `configure` method can be used to pass commands to the program:

     

       38
       65
        
       

     

       39
       66
        
       ```nix

     

       40
       67
        
       weechat.override {

     

       41
       41
       -
         configure = { availablePlugins, ... }: {

     

       42
       42
       -
           init = ''

     

       43
       43
       -
             /set foo bar

     

       44
       44
       -
             /server add libera irc.libera.chat

     

       45
       45
       -
           '';

     

       46
       46
       -
         };

     

       68
       68
       +
         configure =

     

       69
       69
       +
           { availablePlugins, ... }:

     

       70
       70
       +
           {

     

       71
       71
       +
             init = ''

     

       72
       72
       +
               /set foo bar

     

       73
       73
       +
               /server add libera irc.libera.chat

     

       74
       74
       +
             '';

     

       75
       75
       +
           };

     

       47
       76
        
       }

     

       48
       77
        
       ```

     

       49
       78
        
       

     
···

       53
       82
        
       

     

       54
       83
        
       ```nix

     

       55
       84
        
       weechat.override {

     

       56
       56
       -
         configure = { availablePlugins, ... }: {

     

       57
       57
       -
           scripts = with pkgs.weechatScripts; [

     

       58
       58
       -
             weechat-xmpp weechat-matrix-bridge wee-slack

     

       59
       59
       -
           ];

     

       60
       60
       -
           init = ''

     

       61
       61
       -
             /set plugins.var.python.jabber.key "val"

     

       62
       62
       -
           '';

     

       63
       63
       -
         };

     

       85
       85
       +
         configure =

     

       86
       86
       +
           { availablePlugins, ... }:

     

       87
       87
       +
           {

     

       88
       88
       +
             scripts = with pkgs.weechatScripts; [

     

       89
       89
       +
               weechat-xmpp

     

       90
       90
       +
               weechat-matrix-bridge

     

       91
       91
       +
               wee-slack

     

       92
       92
       +
             ];

     

       93
       93
       +
             init = ''

     

       94
       94
       +
               /set plugins.var.python.jabber.key "val"

     

       95
       95
       +
             '';

     

       96
       96
       +
           };

     

       64
       97
        
       }

     

       65
       98
        
       ```

     

       66
       99
        
       

     
···

       75
       108
        
           url = "https://scripts.tld/your-scripts.tar.gz";

     

       76
       109
        
           hash = "...";

     

       77
       110
        
         };

     

       78
       78
       -
         passthru.scripts = [ "foo.py" "bar.lua" ];

     

       111
       111
       +
         passthru.scripts = [

     

       112
       112
       +
           "foo.py"

     

       113
       113
       +
           "bar.lua"

     

       114
       114
       +
         ];

     

       79
       115
        
         installPhase = ''

     

       80
       116
        
           mkdir $out/share

     

       81
       117
        
           cp foo.py $out/share

+14 -6

doc/stdenv/cross-compilation.chapter.md

···

       15
       15
        
       In Nixpkgs, these three platforms are defined as attribute sets under the names `buildPlatform`, `hostPlatform`, and `targetPlatform`. They are always defined as attributes in the standard environment. That means one can access them like:

     

       16
       16
        
       

     

       17
       17
        
       ```nix

     

       18
       18
       -
       { stdenv, fooDep, barDep, ... }: {

     

       18
       18
       +
       {

     

       19
       19
       +
         stdenv,

     

       20
       20
       +
         fooDep,

     

       21
       21
       +
         barDep,

     

       22
       22
       +
         ...

     

       23
       23
       +
       }:

     

       24
       24
       +
       {

     

       19
       25
        
         # ...stdenv.buildPlatform...

     

       20
       26
        
       }

     

       21
       27
        
       ```

     
···

       169
       175
        
       

     

       170
       176
        
       ```nix

     

       171
       177
        
       {

     

       172
       172
       -
         nativeBuildInputs = [

     

       173
       173
       -
           meson

     

       174
       174
       -
         ] ++ lib.optionals (!stdenv.buildPlatform.canExecute stdenv.hostPlatform) [

     

       175
       175
       -
           mesonEmulatorHook

     

       176
       176
       -
         ];

     

       178
       178
       +
         nativeBuildInputs =

     

       179
       179
       +
           [

     

       180
       180
       +
             meson

     

       181
       181
       +
           ]

     

       182
       182
       +
           ++ lib.optionals (!stdenv.buildPlatform.canExecute stdenv.hostPlatform) [

     

       183
       183
       +
             mesonEmulatorHook

     

       184
       184
       +
           ];

     

       177
       185
        
       }

     

       178
       186
        
       ```

     

       179
       187

+7 -2

doc/stdenv/meta.chapter.md

···

       145
       145
        
       ```nix

     

       146
       146
        
       {

     

       147
       147
        
         meta.platforms = lib.platforms.linux;

     

       148
       148
       -
         meta.hydraPlatforms = [];

     

       148
       148
       +
         meta.hydraPlatforms = [ ];

     

       149
       149
        
       }

     

       150
       150
        
       ```

     

       151
       151
        
       

     
···

       169
       169
        
       

     

       170
       170
        
         ```nix

     

       171
       171
        
         {

     

       172
       172
       -
           meta.broken = lib.all (map (p: p.meta.broken) [ glibc musl ]);

     

       172
       172
       +
           meta.broken = lib.all (

     

       173
       173
       +
             map (p: p.meta.broken) [

     

       174
       174
       +
               glibc

     

       175
       175
       +
               musl

     

       176
       176
       +
             ]

     

       177
       177
       +
           );

     

       173
       178
        
         }

     

       174
       179
        
         ```

     

       175
       180

+6 -1

doc/stdenv/multiple-output.chapter.md

···

       31
       31
        
       

     

       32
       32
        
       ```nix

     

       33
       33
        
       {

     

       34
       34
       -
         outputs = [ "bin" "dev" "out" "doc" ];

     

       34
       34
       +
         outputs = [

     

       35
       35
       +
           "bin"

     

       36
       36
       +
           "dev"

     

       37
       37
       +
           "out"

     

       38
       38
       +
           "doc"

     

       39
       39
       +
         ];

     

       35
       40
        
       }

     

       36
       41
        
       ```

     

       37
       42

+3 -1

doc/stdenv/passthru.chapter.md

···

       18
       18
        
       let

     

       19
       19
        
         hello = stdenv.mkDerivation {

     

       20
       20
        
           pname = "hello";

     

       21
       21
       -
           src = fetchGit { /* ... */ };

     

       21
       21
       +
           src = fetchGit {

     

       22
       22
       +
             # ...

     

       23
       23
       +
           };

     

       22
       24
        
       

     

       23
       25
        
           passthru = {

     

       24
       26
        
             foo = "bar";

+47 -27

doc/stdenv/stdenv.chapter.md

···

       37
       37
        
         pname = "libfoo";

     

       38
       38
        
         version = "1.2.3";

     

       39
       39
        
         # ...

     

       40
       40
       -
         buildInputs = [libbar perl ncurses];

     

       40
       40
       +
         buildInputs = [

     

       41
       41
       +
           libbar

     

       42
       42
       +
           perl

     

       43
       43
       +
           ncurses

     

       44
       44
       +
         ];

     

       41
       45
        
       }

     

       42
       46
        
       ```

     

       43
       47
        
       

     
···

       217
       221
        
           hash = "sha256-viwrS9lnaU8sTGuzK/+L/PlMM/xRRtgVuK5pixVeDEw=";

     

       218
       222
        
         };

     

       219
       223
        
       

     

       220
       220
       -
         nativeBuildInputs = [ makeWrapper pkg-config ];

     

       224
       224
       +
         nativeBuildInputs = [

     

       225
       225
       +
           makeWrapper

     

       226
       226
       +
           pkg-config

     

       227
       227
       +
         ];

     

       221
       228
        
         buildInputs = [ libseccomp ];

     

       222
       229
        
       

     

       223
       230
        
         postInstall = ''

     
···

       227
       234
        
             --replace-fail "cp " "cp --no-preserve=mode "

     

       228
       235
        
       

     

       229
       236
        
           wrapProgram $out/bin/solo5-virtio-mkimage \

     

       230
       230
       -
             --prefix PATH : ${lib.makeBinPath [ dosfstools mtools parted syslinux ]}

     

       237
       237
       +
             --prefix PATH : ${

     

       238
       238
       +
               lib.makeBinPath [

     

       239
       239
       +
                 dosfstools

     

       240
       240
       +
                 mtools

     

       241
       241
       +
                 parted

     

       242
       242
       +
                 syslinux

     

       243
       243
       +
               ]

     

       244
       244
       +
             }

     

       231
       245
        
         '';

     

       232
       246
        
       

     

       233
       247
        
         doCheck = true;

     

       234
       234
       -
         nativeCheckInputs = [ util-linux qemu ];

     

       235
       235
       -
         checkPhase = '' [elided] '';

     

       248
       248
       +
         nativeCheckInputs = [

     

       249
       249
       +
           util-linux

     

       250
       250
       +
           qemu

     

       251
       251
       +
         ];

     

       252
       252
       +
         checkPhase = ''[elided] '';

     

       236
       253
        
       }

     

       237
       254
        
       ```

     

       238
       255
        
       

     
···

       272
       289
        
       # A propagated dependency

     

       273
       290
        
       

     

       274
       291
        
       ```nix

     

       275
       275
       -
       with import <nixpkgs> {};

     

       292
       292
       +
       with import <nixpkgs> { };

     

       276
       293
        
       let

     

       277
       294
        
         bar = stdenv.mkDerivation {

     

       278
       295
        
           name = "bar";

     
···

       442
       459
        
       mkDerivation (finalAttrs: {

     

       443
       460
        
         pname = "hello";

     

       444
       461
        
         withFeature = true;

     

       445
       445
       -
         configureFlags =

     

       446
       446
       -
           lib.optionals finalAttrs.withFeature ["--with-feature"];

     

       462
       462
       +
         configureFlags = lib.optionals finalAttrs.withFeature [ "--with-feature" ];

     

       447
       463
        
       })

     

       448
       464
        
       ```

     

       449
       465
        
       

     
···

       460
       476
        
       

     

       461
       477
        
       ```nix

     

       462
       478
        
       # `pkg` is the _original_ definition (for illustration purposes)

     

       463
       463
       -
       let pkg =

     

       464
       464
       -
         mkDerivation (finalAttrs: {

     

       479
       479
       +
       let

     

       480
       480
       +
         pkg = mkDerivation (finalAttrs: {

     

       465
       481
        
           # ...

     

       466
       482
        
       

     

       467
       483
        
           # An example attribute

     

       468
       468
       -
           packages = [];

     

       484
       484
       +
           packages = [ ];

     

       469
       485
        
       

     

       470
       486
        
           # `passthru.tests` is a commonly defined attribute.

     

       471
       487
        
           passthru.tests.simple = f finalAttrs.finalPackage;

     

       472
       488
        
       

     

       473
       489
        
           # An example of an attribute containing a function

     

       474
       474
       -
           passthru.appendPackages = packages':

     

       475
       475
       -
             finalAttrs.finalPackage.overrideAttrs (newSelf: super: {

     

       476
       476
       -
               packages = super.packages ++ packages';

     

       477
       477
       -
             });

     

       490
       490
       +
           passthru.appendPackages =

     

       491
       491
       +
             packages':

     

       492
       492
       +
             finalAttrs.finalPackage.overrideAttrs (

     

       493
       493
       +
               newSelf: super: {

     

       494
       494
       +
                 packages = super.packages ++ packages';

     

       495
       495
       +
               }

     

       496
       496
       +
             );

     

       478
       497
        
       

     

       479
       498
        
           # For illustration purposes; referenced as

     

       480
       499
        
           # `(pkg.overrideAttrs(x)).finalAttrs` etc in the text below.

     

       481
       500
        
           passthru.finalAttrs = finalAttrs;

     

       482
       501
        
           passthru.original = pkg;

     

       483
       502
        
         });

     

       484
       484
       -
       in pkg

     

       503
       503
       +
       in

     

       504
       504
       +
       pkg

     

       485
       505
        
       ```

     

       486
       506
        
       

     

       487
       507
        
       Unlike the `pkg` binding in the above example, the `finalAttrs` parameter always references the final attributes. For instance `(pkg.overrideAttrs(x)).finalAttrs.finalPackage` is identical to `pkg.overrideAttrs(x)`, whereas `(pkg.overrideAttrs(x)).original` is the same as the original `pkg`.

     
···

       955
       975
        
       ```nix

     

       956
       976
        
       let

     

       957
       977
        
         pkgs = import ./. {

     

       958
       958
       -
           config = {};

     

       978
       978
       +
           config = { };

     

       959
       979
        
           overlays = [

     

       960
       980
        
             (final: prev: {

     

       961
       981
        
               ncurses = prev.ncurses.overrideAttrs { separateDebugInfo = true; };

     
···

       974
       994
        
           ];

     

       975
       995
        
         };

     

       976
       996
        
       in

     

       977
       977
       -
         pkgs.mkShell {

     

       997
       997
       +
       pkgs.mkShell {

     

       978
       998
        
       

     

       979
       979
       -
           NIX_DEBUG_INFO_DIRS = "${pkgs.lib.getLib myDebugInfoDirs}/lib/debug";

     

       999
       999
       +
         NIX_DEBUG_INFO_DIRS = "${pkgs.lib.getLib myDebugInfoDirs}/lib/debug";

     

       980
       1000
        
       

     

       981
       981
       -
           packages = [

     

       982
       982
       -
             pkgs.gdb

     

       983
       983
       -
             pkgs.socat

     

       984
       984
       -
           ];

     

       1001
       1001
       +
         packages = [

     

       1002
       1002
       +
           pkgs.gdb

     

       1003
       1003
       +
           pkgs.socat

     

       1004
       1004
       +
         ];

     

       985
       1005
        
       

     

       986
       986
       -
           shellHook = ''

     

       987
       987
       -
             ${pkgs.lib.getBin pkgs.gdb}/bin/gdb ${pkgs.lib.getBin pkgs.socat}/bin/socat

     

       988
       988
       -
           '';

     

       989
       989
       -
         }

     

       1006
       1006
       +
         shellHook = ''

     

       1007
       1007
       +
           ${pkgs.lib.getBin pkgs.gdb}/bin/gdb ${pkgs.lib.getBin pkgs.socat}/bin/socat

     

       1008
       1008
       +
         '';

     

       1009
       1009
       +
       }

     

       990
       1010
        
       ```

     

       991
       1011
        
       

     

       992
       1012
        
       This setup works as follows:

+166 -121

doc/using/configuration.chapter.md

···

       99
       99
        
       

     

       100
       100
        
           ```nix

     

       101
       101
        
           {

     

       102
       102
       -
             allowUnfreePredicate = pkg: builtins.elem (lib.getName pkg) [

     

       103
       103
       -
               "roon-server"

     

       104
       104
       -
               "vscode"

     

       105
       105
       -
             ];

     

       102
       102
       +
             allowUnfreePredicate =

     

       103
       103
       +
               pkg:

     

       104
       104
       +
               builtins.elem (lib.getName pkg) [

     

       105
       105
       +
                 "roon-server"

     

       106
       106
       +
                 "vscode"

     

       107
       107
       +
               ];

     

       106
       108
        
           }

     

       107
       109
        
           ```

     

       108
       110
        
       

     
···

       112
       114
        
       

     

       113
       115
        
           ```nix

     

       114
       116
        
           {

     

       115
       115
       -
             allowlistedLicenses = with lib.licenses; [ amd wtfpl ];

     

       117
       117
       +
             allowlistedLicenses = with lib.licenses; [

     

       118
       118
       +
               amd

     

       119
       119
       +
               wtfpl

     

       120
       120
       +
             ];

     

       116
       121
        
           }

     

       117
       122
        
           ```

     

       118
       123
        
       

     
···

       120
       125
        
       

     

       121
       126
        
           ```nix

     

       122
       127
        
           {

     

       123
       123
       -
             blocklistedLicenses = with lib.licenses; [ agpl3Only gpl3Only ];

     

       128
       128
       +
             blocklistedLicenses = with lib.licenses; [

     

       129
       129
       +
               agpl3Only

     

       130
       130
       +
               gpl3Only

     

       131
       131
       +
             ];

     

       124
       132
        
           }

     

       125
       133
        
           ```

     

       126
       134
        
       

     
···

       158
       166
        
       

     

       159
       167
        
           ```nix

     

       160
       168
        
           {

     

       161
       161
       -
             allowInsecurePredicate = pkg: builtins.elem (lib.getName pkg) [

     

       162
       162
       -
               "ovftool"

     

       163
       163
       -
             ];

     

       169
       169
       +
             allowInsecurePredicate =

     

       170
       170
       +
               pkg:

     

       171
       171
       +
               builtins.elem (lib.getName pkg) [

     

       172
       172
       +
                 "ovftool"

     

       173
       173
       +
               ];

     

       164
       174
        
           }

     

       165
       175
        
           ```

     

       166
       176
        
       

     
···

       173
       183
        
       ```nix

     

       174
       184
        
       {

     

       175
       185
        
         packageOverrides = pkgs: rec {

     

       176
       176
       -
           foo = pkgs.foo.override { /* ... */ };

     

       186
       186
       +
           foo = pkgs.foo.override {

     

       187
       187
       +
             # ...

     

       188
       188
       +
           };

     

       177
       189
        
         };

     

       178
       190
        
       }

     

       179
       191
        
       ```

     
···

       197
       209
        
       

     

       198
       210
        
       ```nix

     

       199
       211
        
       {

     

       200
       200
       -
         packageOverrides = pkgs: with pkgs; {

     

       201
       201
       -
           myPackages = pkgs.buildEnv {

     

       202
       202
       -
             name = "my-packages";

     

       203
       203
       -
             paths = [

     

       204
       204
       -
               aspell

     

       205
       205
       -
               bc

     

       206
       206
       -
               coreutils

     

       207
       207
       -
               gdb

     

       208
       208
       -
               ffmpeg

     

       209
       209
       -
               nix

     

       210
       210
       -
               emscripten

     

       211
       211
       -
               jq

     

       212
       212
       -
               nox

     

       213
       213
       -
               silver-searcher

     

       214
       214
       -
             ];

     

       212
       212
       +
         packageOverrides =

     

       213
       213
       +
           pkgs: with pkgs; {

     

       214
       214
       +
             myPackages = pkgs.buildEnv {

     

       215
       215
       +
               name = "my-packages";

     

       216
       216
       +
               paths = [

     

       217
       217
       +
                 aspell

     

       218
       218
       +
                 bc

     

       219
       219
       +
                 coreutils

     

       220
       220
       +
                 gdb

     

       221
       221
       +
                 ffmpeg

     

       222
       222
       +
                 nix

     

       223
       223
       +
                 emscripten

     

       224
       224
       +
                 jq

     

       225
       225
       +
                 nox

     

       226
       226
       +
                 silver-searcher

     

       227
       227
       +
               ];

     

       228
       228
       +
             };

     

       215
       229
        
           };

     

       216
       216
       -
         };

     

       217
       230
        
       }

     

       218
       231
        
       ```

     

       219
       232
        
       

     
···

       221
       234
        
       

     

       222
       235
        
       ```nix

     

       223
       236
        
       {

     

       224
       224
       -
         packageOverrides = pkgs: with pkgs; {

     

       225
       225
       -
           myPackages = pkgs.buildEnv {

     

       226
       226
       -
             name = "my-packages";

     

       227
       227
       -
             paths = [

     

       228
       228
       -
               aspell

     

       229
       229
       -
               bc

     

       230
       230
       -
               coreutils

     

       231
       231
       -
               gdb

     

       232
       232
       -
               ffmpeg

     

       233
       233
       -
               nix

     

       234
       234
       -
               emscripten

     

       235
       235
       -
               jq

     

       236
       236
       -
               nox

     

       237
       237
       -
               silver-searcher

     

       238
       238
       -
             ];

     

       239
       239
       -
             pathsToLink = [ "/share" "/bin" ];

     

       237
       237
       +
         packageOverrides =

     

       238
       238
       +
           pkgs: with pkgs; {

     

       239
       239
       +
             myPackages = pkgs.buildEnv {

     

       240
       240
       +
               name = "my-packages";

     

       241
       241
       +
               paths = [

     

       242
       242
       +
                 aspell

     

       243
       243
       +
                 bc

     

       244
       244
       +
                 coreutils

     

       245
       245
       +
                 gdb

     

       246
       246
       +
                 ffmpeg

     

       247
       247
       +
                 nix

     

       248
       248
       +
                 emscripten

     

       249
       249
       +
                 jq

     

       250
       250
       +
                 nox

     

       251
       251
       +
                 silver-searcher

     

       252
       252
       +
               ];

     

       253
       253
       +
               pathsToLink = [

     

       254
       254
       +
                 "/share"

     

       255
       255
       +
                 "/bin"

     

       256
       256
       +
               ];

     

       257
       257
       +
             };

     

       240
       258
        
           };

     

       241
       241
       -
         };

     

       242
       259
        
       }

     

       243
       260
        
       ```

     

       244
       261
        
       

     
···

       250
       267
        
       

     

       251
       268
        
       ```nix

     

       252
       269
        
       {

     

       253
       253
       -
         packageOverrides = pkgs: with pkgs; {

     

       254
       254
       -
           myPackages = pkgs.buildEnv {

     

       255
       255
       -
             name = "my-packages";

     

       256
       256
       -
             paths = [

     

       257
       257
       -
               aspell

     

       258
       258
       -
               bc

     

       259
       259
       -
               coreutils

     

       260
       260
       -
               ffmpeg

     

       261
       261
       -
               nix

     

       262
       262
       -
               emscripten

     

       263
       263
       -
               jq

     

       264
       264
       -
               nox

     

       265
       265
       -
               silver-searcher

     

       266
       266
       -
             ];

     

       267
       267
       -
             pathsToLink = [ "/share/man" "/share/doc" "/bin" ];

     

       268
       268
       -
             extraOutputsToInstall = [ "man" "doc" ];

     

       270
       270
       +
         packageOverrides =

     

       271
       271
       +
           pkgs: with pkgs; {

     

       272
       272
       +
             myPackages = pkgs.buildEnv {

     

       273
       273
       +
               name = "my-packages";

     

       274
       274
       +
               paths = [

     

       275
       275
       +
                 aspell

     

       276
       276
       +
                 bc

     

       277
       277
       +
                 coreutils

     

       278
       278
       +
                 ffmpeg

     

       279
       279
       +
                 nix

     

       280
       280
       +
                 emscripten

     

       281
       281
       +
                 jq

     

       282
       282
       +
                 nox

     

       283
       283
       +
                 silver-searcher

     

       284
       284
       +
               ];

     

       285
       285
       +
               pathsToLink = [

     

       286
       286
       +
                 "/share/man"

     

       287
       287
       +
                 "/share/doc"

     

       288
       288
       +
                 "/bin"

     

       289
       289
       +
               ];

     

       290
       290
       +
               extraOutputsToInstall = [

     

       291
       291
       +
                 "man"

     

       292
       292
       +
                 "doc"

     

       293
       293
       +
               ];

     

       294
       294
       +
             };

     

       269
       295
        
           };

     

       270
       270
       -
         };

     

       271
       296
        
       }

     

       272
       297
        
       ```

     

       273
       298
        
       

     
···

       275
       300
        
       

     

       276
       301
        
       ```nix

     

       277
       302
        
       {

     

       278
       278
       -
         packageOverrides = pkgs: with pkgs; rec {

     

       279
       279
       -
           myProfile = writeText "my-profile" ''

     

       280
       280
       -
             export PATH=$HOME/.nix-profile/bin:/nix/var/nix/profiles/default/bin:/sbin:/bin:/usr/sbin:/usr/bin

     

       281
       281
       -
             export MANPATH=$HOME/.nix-profile/share/man:/nix/var/nix/profiles/default/share/man:/usr/share/man

     

       282
       282
       -
           '';

     

       283
       283
       -
           myPackages = pkgs.buildEnv {

     

       284
       284
       -
             name = "my-packages";

     

       285
       285
       -
             paths = [

     

       286
       286
       -
               (runCommand "profile" {} ''

     

       287
       287
       -
                 mkdir -p $out/etc/profile.d

     

       288
       288
       -
                 cp ${myProfile} $out/etc/profile.d/my-profile.sh

     

       289
       289
       -
               '')

     

       290
       290
       -
               aspell

     

       291
       291
       -
               bc

     

       292
       292
       -
               coreutils

     

       293
       293
       -
               ffmpeg

     

       294
       294
       -
               man

     

       295
       295
       -
               nix

     

       296
       296
       -
               emscripten

     

       297
       297
       -
               jq

     

       298
       298
       -
               nox

     

       299
       299
       -
               silver-searcher

     

       300
       300
       -
             ];

     

       301
       301
       -
             pathsToLink = [ "/share/man" "/share/doc" "/bin" "/etc" ];

     

       302
       302
       -
             extraOutputsToInstall = [ "man" "doc" ];

     

       303
       303
       +
         packageOverrides =

     

       304
       304
       +
           pkgs: with pkgs; rec {

     

       305
       305
       +
             myProfile = writeText "my-profile" ''

     

       306
       306
       +
               export PATH=$HOME/.nix-profile/bin:/nix/var/nix/profiles/default/bin:/sbin:/bin:/usr/sbin:/usr/bin

     

       307
       307
       +
               export MANPATH=$HOME/.nix-profile/share/man:/nix/var/nix/profiles/default/share/man:/usr/share/man

     

       308
       308
       +
             '';

     

       309
       309
       +
             myPackages = pkgs.buildEnv {

     

       310
       310
       +
               name = "my-packages";

     

       311
       311
       +
               paths = [

     

       312
       312
       +
                 (runCommand "profile" { } ''

     

       313
       313
       +
                   mkdir -p $out/etc/profile.d

     

       314
       314
       +
                   cp ${myProfile} $out/etc/profile.d/my-profile.sh

     

       315
       315
       +
                 '')

     

       316
       316
       +
                 aspell

     

       317
       317
       +
                 bc

     

       318
       318
       +
                 coreutils

     

       319
       319
       +
                 ffmpeg

     

       320
       320
       +
                 man

     

       321
       321
       +
                 nix

     

       322
       322
       +
                 emscripten

     

       323
       323
       +
                 jq

     

       324
       324
       +
                 nox

     

       325
       325
       +
                 silver-searcher

     

       326
       326
       +
               ];

     

       327
       327
       +
               pathsToLink = [

     

       328
       328
       +
                 "/share/man"

     

       329
       329
       +
                 "/share/doc"

     

       330
       330
       +
                 "/bin"

     

       331
       331
       +
                 "/etc"

     

       332
       332
       +
               ];

     

       333
       333
       +
               extraOutputsToInstall = [

     

       334
       334
       +
                 "man"

     

       335
       335
       +
                 "doc"

     

       336
       336
       +
               ];

     

       337
       337
       +
             };

     

       303
       338
        
           };

     

       304
       304
       -
         };

     

       305
       339
        
       }

     

       306
       340
        
       ```

     

       307
       341
        
       

     
···

       326
       360
        
       

     

       327
       361
        
       ```nix

     

       328
       362
        
       {

     

       329
       329
       -
         packageOverrides = pkgs: with pkgs; rec {

     

       330
       330
       -
           myProfile = writeText "my-profile" ''

     

       331
       331
       -
             export PATH=$HOME/.nix-profile/bin:/nix/var/nix/profiles/default/bin:/sbin:/bin:/usr/sbin:/usr/bin

     

       332
       332
       -
             export MANPATH=$HOME/.nix-profile/share/man:/nix/var/nix/profiles/default/share/man:/usr/share/man

     

       333
       333
       -
             export INFOPATH=$HOME/.nix-profile/share/info:/nix/var/nix/profiles/default/share/info:/usr/share/info

     

       334
       334
       -
           '';

     

       335
       335
       -
           myPackages = pkgs.buildEnv {

     

       336
       336
       -
             name = "my-packages";

     

       337
       337
       -
             paths = [

     

       338
       338
       -
               (runCommand "profile" {} ''

     

       339
       339
       -
                 mkdir -p $out/etc/profile.d

     

       340
       340
       -
                 cp ${myProfile} $out/etc/profile.d/my-profile.sh

     

       341
       341
       -
               '')

     

       342
       342
       -
               aspell

     

       343
       343
       -
               bc

     

       344
       344
       -
               coreutils

     

       345
       345
       -
               ffmpeg

     

       346
       346
       -
               man

     

       347
       347
       -
               nix

     

       348
       348
       -
               emscripten

     

       349
       349
       -
               jq

     

       350
       350
       -
               nox

     

       351
       351
       -
               silver-searcher

     

       352
       352
       -
               texinfoInteractive

     

       353
       353
       -
             ];

     

       354
       354
       -
             pathsToLink = [ "/share/man" "/share/doc" "/share/info" "/bin" "/etc" ];

     

       355
       355
       -
             extraOutputsToInstall = [ "man" "doc" "info" ];

     

       356
       356
       -
             postBuild = ''

     

       357
       357
       -
               if [ -x $out/bin/install-info -a -w $out/share/info ]; then

     

       358
       358
       -
                 shopt -s nullglob

     

       359
       359
       -
                 for i in $out/share/info/*.info $out/share/info/*.info.gz; do

     

       360
       360
       -
                     $out/bin/install-info $i $out/share/info/dir

     

       361
       361
       -
                 done

     

       362
       362
       -
               fi

     

       363
       363
       +
         packageOverrides =

     

       364
       364
       +
           pkgs: with pkgs; rec {

     

       365
       365
       +
             myProfile = writeText "my-profile" ''

     

       366
       366
       +
               export PATH=$HOME/.nix-profile/bin:/nix/var/nix/profiles/default/bin:/sbin:/bin:/usr/sbin:/usr/bin

     

       367
       367
       +
               export MANPATH=$HOME/.nix-profile/share/man:/nix/var/nix/profiles/default/share/man:/usr/share/man

     

       368
       368
       +
               export INFOPATH=$HOME/.nix-profile/share/info:/nix/var/nix/profiles/default/share/info:/usr/share/info

     

       363
       369
        
             '';

     

       370
       370
       +
             myPackages = pkgs.buildEnv {

     

       371
       371
       +
               name = "my-packages";

     

       372
       372
       +
               paths = [

     

       373
       373
       +
                 (runCommand "profile" { } ''

     

       374
       374
       +
                   mkdir -p $out/etc/profile.d

     

       375
       375
       +
                   cp ${myProfile} $out/etc/profile.d/my-profile.sh

     

       376
       376
       +
                 '')

     

       377
       377
       +
                 aspell

     

       378
       378
       +
                 bc

     

       379
       379
       +
                 coreutils

     

       380
       380
       +
                 ffmpeg

     

       381
       381
       +
                 man

     

       382
       382
       +
                 nix

     

       383
       383
       +
                 emscripten

     

       384
       384
       +
                 jq

     

       385
       385
       +
                 nox

     

       386
       386
       +
                 silver-searcher

     

       387
       387
       +
                 texinfoInteractive

     

       388
       388
       +
               ];

     

       389
       389
       +
               pathsToLink = [

     

       390
       390
       +
                 "/share/man"

     

       391
       391
       +
                 "/share/doc"

     

       392
       392
       +
                 "/share/info"

     

       393
       393
       +
                 "/bin"

     

       394
       394
       +
                 "/etc"

     

       395
       395
       +
               ];

     

       396
       396
       +
               extraOutputsToInstall = [

     

       397
       397
       +
                 "man"

     

       398
       398
       +
                 "doc"

     

       399
       399
       +
                 "info"

     

       400
       400
       +
               ];

     

       401
       401
       +
               postBuild = ''

     

       402
       402
       +
                 if [ -x $out/bin/install-info -a -w $out/share/info ]; then

     

       403
       403
       +
                   shopt -s nullglob

     

       404
       404
       +
                   for i in $out/share/info/*.info $out/share/info/*.info.gz; do

     

       405
       405
       +
                       $out/bin/install-info $i $out/share/info/dir

     

       406
       406
       +
                   done

     

       407
       407
       +
                 fi

     

       408
       408
       +
               '';

     

       409
       409
       +
             };

     

       364
       410
        
           };

     

       365
       365
       -
         };

     

       366
       411
        
       }

     

       367
       412
        
       ```

     

       368
       413

+6 -1

doc/using/overlays.chapter.md

···

       136
       136
        
       For BLAS/LAPACK switching to work correctly, all packages must depend on `blas` or `lapack`. This ensures that only one BLAS/LAPACK library is used at one time. There are two versions of BLAS/LAPACK currently in the wild, `LP64` (integer size = 32 bits) and `ILP64` (integer size = 64 bits). The attributes `blas` and `lapack` are `LP64` by default. Their `ILP64` version are provided through the attributes `blas-ilp64` and `lapack-ilp64`. Some software needs special flags or patches to work with `ILP64`. You can check if `ILP64` is used in Nixpkgs with `blas.isILP64` and `lapack.isILP64`. Some software does NOT work with `ILP64`, and derivations need to specify an assertion to prevent this. You can prevent `ILP64` from being used with the following:

     

       137
       137
        
       

     

       138
       138
        
       ```nix

     

       139
       139
       -
       { stdenv, blas, lapack, ... }:

     

       139
       139
       +
       {

     

       140
       140
       +
         stdenv,

     

       141
       141
       +
         blas,

     

       142
       142
       +
         lapack,

     

       143
       143
       +
         ...

     

       144
       144
       +
       }:

     

       140
       145
        
       

     

       141
       146
        
       assert (!blas.isILP64) && (!lapack.isILP64);

     

       142
       147

+32 -12

doc/using/overrides.chapter.md

···

       13
       13
        
       Example usages:

     

       14
       14
        
       

     

       15
       15
        
       ```nix

     

       16
       16
       -
       pkgs.foo.override { arg1 = val1; arg2 = val2; /* ... */ }

     

       16
       16
       +
       pkgs.foo.override {

     

       17
       17
       +
         arg1 = val1;

     

       18
       18
       +
         arg2 = val2; # ...

     

       19
       19
       +
       }

     

       17
       20
        
       ```

     

       18
       21
        
       

     

       19
       22
        
       It's also possible to access the previous arguments.

     

       20
       23
        
       

     

       21
       24
        
       ```nix

     

       22
       22
       -
       pkgs.foo.override (previous: { arg1 = previous.arg1; /* ... */ })

     

       25
       25
       +
       pkgs.foo.override (previous: {

     

       26
       26
       +
         arg1 = previous.arg1; # ...

     

       27
       27
       +
       })

     

       23
       28
        
       ```

     

       24
       29
        
       

     

       25
       30
        
       <!-- TODO: move below programlisting to a new section about extending and overlays and reference it -->

     

       26
       31
        
       

     

       27
       32
        
       ```nix

     

       28
       28
       -
       import pkgs.path { overlays = [ (self: super: {

     

       29
       29
       -
         foo = super.foo.override { barSupport = true ; };

     

       30
       30
       -
         })];}

     

       33
       33
       +
       import pkgs.path {

     

       34
       34
       +
         overlays = [

     

       35
       35
       +
           (self: super: {

     

       36
       36
       +
             foo = super.foo.override { barSupport = true; };

     

       37
       37
       +
           })

     

       38
       38
       +
         ];

     

       39
       39
       +
       }

     

       31
       40
        
       ```

     

       32
       41
        
       

     

       33
       42
        
       ```nix

     

       34
       43
        
       {

     

       35
       44
        
         mypkg = pkgs.callPackage ./mypkg.nix {

     

       36
       36
       -
           mydep = pkgs.mydep.override { /* ... */ };

     

       45
       45
       +
           mydep = pkgs.mydep.override {

     

       46
       46
       +
             # ...

     

       47
       47
       +
           };

     

       37
       48
        
         };

     

       38
       49
        
       }

     

       39
       50
        
       ```

     
···

       55
       66
        
       

     

       56
       67
        
       ```nix

     

       57
       68
        
       {

     

       58
       58
       -
         helloBar = pkgs.hello.overrideAttrs (finalAttrs: previousAttrs: {

     

       59
       59
       -
           pname = previousAttrs.pname + "-bar";

     

       60
       60
       -
         });

     

       69
       69
       +
         helloBar = pkgs.hello.overrideAttrs (

     

       70
       70
       +
           finalAttrs: previousAttrs: {

     

       71
       71
       +
             pname = previousAttrs.pname + "-bar";

     

       72
       72
       +
           }

     

       73
       73
       +
         );

     

       61
       74
        
       }

     

       62
       75
        
       ```

     

       63
       76
        
       

     
···

       107
       120
        
             url = "ftp://alpha.gnu.org/gnu/sed/sed-4.2.2-pre.tar.bz2";

     

       108
       121
        
             hash = "sha256-MxBJRcM2rYzQYwJ5XKxhXTQByvSg5jZc5cSHEZoB2IY=";

     

       109
       122
        
           };

     

       110
       110
       -
           patches = [];

     

       123
       123
       +
           patches = [ ];

     

       111
       124
        
         });

     

       112
       125
        
       }

     

       113
       126
        
       ```

     
···

       128
       141
        
       

     

       129
       142
        
       ```nix

     

       130
       143
        
       {

     

       131
       131
       -
         f = { a, b }: { result = a+b; };

     

       132
       132
       -
         c = lib.makeOverridable f { a = 1; b = 2; };

     

       144
       144
       +
         f =

     

       145
       145
       +
           { a, b }:

     

       146
       146
       +
           {

     

       147
       147
       +
             result = a + b;

     

       148
       148
       +
           };

     

       149
       149
       +
         c = lib.makeOverridable f {

     

       150
       150
       +
           a = 1;

     

       151
       151
       +
           b = 2;

     

       152
       152
       +
         };

     

       133
       153
        
       }

     

       134
       154
        
       ```

     

       135
       155