commit 1a1ad1a17dfbe1b4da3a0bb174c6830ac318a3a7 · pyrox.dev/nixpkgs

+27 -137

lib/customisation.nix

···

       50
       50
        
              }

     

       51
       51
        
              else { }));

     

       52
       52
        
       

     

       53
       53
       -
         # A more powerful version of `makeOverridable` with features similar

     

       54
       54
       -
         # to `makeExtensibleWithInterface`.

     

       55
       55
       -
         makeOverridableWithInterface = interface: f: origArgs: let

     

       56
       56
       -
       

     

       57
       57
       -
           addOverrideFuncs = {val, args, ...}: overridePackage:

     

       58
       58
       -
             (lib.optionalAttrs (builtins.isAttrs val) (val // {

     

       59
       59
       -
               extend = f: overridePackage (_: self: super: {

     

       60
       60
       -
                 val = super.val // f self.val super.val;

     

       61
       61
       -
               });

     

       62
       62
       -
       

     

       63
       63
       -
               overrideDerivation = newArgs: overridePackage (_: self: super: {

     

       64
       64
       -
                 val = lib.overrideDerivation super.val newArgs;

     

       65
       65
       -
               });

     

       66
       66
       -
       

     

       67
       67
       -
               ${if val ? overrideAttrs then "overrideAttrs" else null} = fdrv:

     

       68
       68
       -
                 overridePackage (_: self: super: {

     

       69
       69
       -
                   val = super.val.overrideAttrs fdrv;

     

       70
       70
       -
                 });

     

       71
       71
       -
             })) // (lib.optionalAttrs (builtins.isFunction val) {

     

       72
       72
       -
               __functor = _: val;

     

       73
       73
       -
               extend = throw "extend not yet supported for functors";

     

       74
       74
       -
               overrideDerivation = throw "overrideDerivation not yet supported for functors";

     

       75
       75
       -
             }) // {

     

       76
       76
       -
               inherit overridePackage;

     

       77
       77
       -
       

     

       78
       78
       -
               override = newArgs: overridePackage (_: self: super: {

     

       79
       79
       -
                 args = super.args //

     

       80
       80
       -
                   (if builtins.isFunction newArgs then newArgs super.args else newArgs);

     

       81
       81
       -
               });

     

       82
       82
       -
             };

     

       83
       83
       -
       

     

       84
       84
       -
         in lib.makeExtensibleWithInterface (x: o: interface (addOverrideFuncs x o) o) (output: self: {

     

       85
       85
       -
           args = origArgs;

     

       86
       86
       -
           val = f output self.args self.val;

     

       87
       87
       -
         });

     

       88
       88
       -
       

     

       89
       89
       -
       

     

       90
       90
       -
         /* `makeOverridable` takes a function from attribute set to

     

       91
       91
       -
            attribute set and injects 4 attributes which can be used to

     

       92
       92
       -
            override arguments and return values of the function.

     

       93
       93
       -
       

     

       94
       53
        
       

     

       95
       95
       -
            1. `override` allows you to change what arguments were passed to

     

       96
       96
       -
            the function and acquire the new result.

     

       54
       54
       +
         /* `makeOverridable` takes a function from attribute set to attribute set and

     

       55
       55
       +
            injects `override` attibute which can be used to override arguments of

     

       56
       56
       +
            the function.

     

       97
       57
        
       

     

       98
       58
        
              nix-repl> x = {a, b}: { result = a + b; }

     

       99
       59
        
       

     
···

       105
       65
        
              nix-repl> y.override { a = 10; }

     

       106
       66
        
              { override = «lambda»; overrideDerivation = «lambda»; result = 12; }

     

       107
       67
        
       

     

       108
       108
       -
       

     

       109
       109
       -
            2. `extend` changes the results of the function, giving you a

     

       110
       110
       -
            view of the original result and a view of the eventual final

     

       111
       111
       -
            result. It is meant to do the same thing as

     

       112
       112
       -
            `makeExtensible`. That is, it lets you add to or change the

     

       113
       113
       -
            return value, such that previous extensions are consistent with

     

       114
       114
       -
            the final view, rather than being based on outdated

     

       115
       115
       -
            values. "Outdated" values come from the `super` argument, which

     

       116
       116
       -
            must be used when you are attempting to modify and old value. And

     

       117
       117
       -
            the final values come from the `self` argument, which recursively

     

       118
       118
       -
            refers to what all extensions combined return.

     

       119
       119
       -
       

     

       120
       120
       -
              nix-repl> obj = makeOverridable (args: { }) { }

     

       121
       121
       -
       

     

       122
       122
       -
              nix-repl> obj = obj.extend (self: super: { foo = "foo"; })

     

       123
       123
       -
       

     

       124
       124
       -
              nix-repl> obj.foo

     

       125
       125
       -
              "foo"

     

       126
       126
       -
       

     

       127
       127
       -
              nix-repl> obj = obj.extend (self: super: { foo = super.foo + " + "; bar = "bar"; foobar = self.foo + self.bar; })

     

       128
       128
       -
       

     

       129
       129
       -
              nix-repl> obj

     

       130
       130
       -
              { bar = "bar"; foo = "foo + "; foobar = "foo + bar"; ... } # Excess omitted

     

       131
       131
       -
       

     

       132
       132
       -
       

     

       133
       133
       -
            3. `overrideDerivation`: Please refer to "Nixpkgs Contributors

     

       134
       134
       -
            Guide" section "<pkg>.overrideDerivation" to learn about

     

       135
       135
       -
            `overrideDerivation` and caveats related to its use.

     

       136
       136
       -
       

     

       137
       137
       -
       

     

       138
       138
       -
            4. `overridePackage` is by far the most powerful of the four, as

     

       139
       139
       -
            it exposes a deeper structure. It provides `self` and `super`

     

       140
       140
       -
            views of both the arguments and return value of the function,

     

       141
       141
       -
            allowing you to change both in one override; you can even have

     

       142
       142
       -
            overrides for one based on overrides for the other. It also

     

       143
       143
       -
            provides the `output` view, which is the view of `self` after

     

       144
       144
       -
            passing it through the `makeOverridable` interface and adding all

     

       145
       145
       -
            the `overrideX` functions. `output` is necessary when your

     

       146
       146
       -
            overrides depend on the overridable structure of `output`.

     

       147
       147
       -
       

     

       148
       148
       -
              nix-repl> obj = makeOverridable ({a, b}: {inherit a b;}) {a = 1; b = 3;}

     

       149
       149
       -
       

     

       150
       150
       -
              nix-repl> obj = obj.overridePackage (output: self: super: { args = super.args // {b = self.val.a;}; })

     

       151
       151
       -
       

     

       152
       152
       -
              nix-repl> obj.b

     

       153
       153
       -
              1

     

       154
       154
       -
       

     

       155
       155
       -
              nix-repl> obj = obj.overridePackage (output: self: super: { val = super.val // {a = self.args.a + 10;}; })

     

       156
       156
       -
       

     

       157
       157
       -
              nix-repl> obj.b

     

       158
       158
       -
              11

     

       159
       159
       -
       

     

       68
       68
       +
            Please refer to "Nixpkgs Contributors Guide" section

     

       69
       69
       +
            "<pkg>.overrideDerivation" to learn about `overrideDerivation` and caveats

     

       70
       70
       +
            related to its use.

     

       160
       71
        
         */

     

       161
       161
       -
         makeOverridable = fn: makeOverridableWithInterface (x: _: x) (_: args: _: fn args);

     

       162
       162
       -
       

     

       163
       163
       -
         callPackageCommon = functionArgs: scope: f: args:

     

       72
       72
       +
         makeOverridable = f: origArgs:

     

       164
       73
        
           let

     

       165
       165
       -
             intersect = builtins.intersectAttrs functionArgs;

     

       166
       166
       -
             interface = val: overridePackage: val // {

     

       167
       167
       -
               overrideScope = newScope: overridePackage (_: self: super: {

     

       168
       168
       -
                 scope = super.scope.extend newScope;

     

       169
       169
       -
               });

     

       170
       170
       -
             };

     

       171
       171
       -
           in (makeOverridableWithInterface interface f (intersect scope // args))

     

       172
       172
       -
             .overridePackage (output: self: super: {

     

       173
       173
       -
               inherit scope;

     

       174
       174
       -
               # Don't use super.args because that contains the original scope.

     

       175
       175
       -
               args = intersect self.scope  // args;

     

       176
       176
       -
             });

     

       74
       74
       +
             ff = f origArgs;

     

       75
       75
       +
             overrideWith = newArgs: origArgs // (if builtins.isFunction newArgs then newArgs origArgs else newArgs);

     

       76
       76
       +
           in

     

       77
       77
       +
             if builtins.isAttrs ff then (ff // {

     

       78
       78
       +
               override = newArgs: makeOverridable f (overrideWith newArgs);

     

       79
       79
       +
               overrideDerivation = fdrv:

     

       80
       80
       +
                 makeOverridable (args: overrideDerivation (f args) fdrv) origArgs;

     

       81
       81
       +
               ${if ff ? overrideAttrs then "overrideAttrs" else null} = fdrv:

     

       82
       82
       +
                 makeOverridable (args: (f args).overrideAttrs fdrv) origArgs;

     

       83
       83
       +
             })

     

       84
       84
       +
             else if builtins.isFunction ff then {

     

       85
       85
       +
               override = newArgs: makeOverridable f (overrideWith newArgs);

     

       86
       86
       +
               __functor = self: ff;

     

       87
       87
       +
               overrideDerivation = throw "overrideDerivation not yet supported for functors";

     

       88
       88
       +
             }

     

       89
       89
       +
             else ff;

     

       177
       90
        
       

     

       178
       91
        
       

     

       179
       92
        
         /* Call the package function in the file `fn' with the required

     
···

       196
       109
        
               libfoo = null;

     

       197
       110
        
               enableX11 = true;

     

       198
       111
        
             };

     

       199
       199
       -
       

     

       200
       200
       -
           On top of the additions from `makeOverridable`, an `overrideScope`

     

       201
       201
       -
           function is also added to the result. It is similar to `override`,

     

       202
       202
       -
           except that it provides `self` and `super` views to the

     

       203
       203
       -
           scope. This can't be done in `makeOverridable` because the scope

     

       204
       204
       -
           is filtered to just the arguments needed by the function before

     

       205
       205
       -
           entering `makeOverridable`. It is useful to have a view of the

     

       206
       206
       -
           scope before restriction; for example, to change versions for a

     

       207
       207
       -
           particular dependency.

     

       208
       208
       -
       

     

       209
       209
       -
             foo.overrideScope (self: super: {

     

       210
       210
       -
               llvm = self.llvm_37;

     

       211
       211
       -
             })

     

       212
       212
       -
       

     

       213
       213
       -
           `llvm_37` would not exist in the scope after restriction.

     

       214
       214
       -
       

     

       215
       112
        
         */

     

       216
       113
        
         callPackageWith = autoArgs: fn: args:

     

       217
       217
       -
           let f = if builtins.isFunction fn then fn else import fn;

     

       218
       218
       -
           in callPackageCommon (builtins.functionArgs f) autoArgs (output: x: _: f x) args;

     

       219
       219
       -
       

     

       220
       220
       -
       

     

       221
       221
       -
         # Like `callPackageWith`, but provides the function with a `self`

     

       222
       222
       -
         # view of the output, which has the override functions

     

       223
       223
       -
         # injected. `fn` is called with the new output whenever an override

     

       224
       224
       -
         # or extension is added.

     

       225
       225
       -
         callPackageWithOutputWith = autoArgs: fn: args:

     

       226
       226
       -
           let f = if builtins.isFunction fn then fn else import fn;

     

       227
       227
       -
           in callPackageCommon (builtins.functionArgs f) autoArgs (output: args: _: f args output ) args;

     

       114
       114
       +
           let

     

       115
       115
       +
             f = if builtins.isFunction fn then fn else import fn;

     

       116
       116
       +
             auto = builtins.intersectAttrs (builtins.functionArgs f) autoArgs;

     

       117
       117
       +
           in makeOverridable f (auto // args);

     

       228
       118
        
       

     

       229
       119
        
       

     

       230
       120
        
         /* Like callPackage, but for a function that returns an attribute

+4 -30

lib/fixed-points.nix

···

       72
       72
        
       

     

       73
       73
        
         # Same as `makeExtensible` but the name of the extending attribute is

     

       74
       74
        
         # customized.

     

       75
       75
       -
         makeExtensibleWithCustomName = extenderName: f: makeExtensibleWithInterface

     

       76
       76
       -
           (fixedPoint: extend: fixedPoint // { ${extenderName} = ext: extend (_: ext); })

     

       77
       77
       -
           (_: f);

     

       78
       78
       -
       

     

       79
       79
       -
         # A version of `makeExtensible` that allows the function being fixed

     

       80
       80
       -
         # to return a different interface than the interface returned to the

     

       81
       81
       -
         # user. Along with `self` and `super` views of the internal

     

       82
       82
       -
         # interface, a `self` view of the output interface is also

     

       83
       83
       -
         # provided. `extend` is not added to the output by default. This is

     

       84
       84
       -
         # the job of the interface.

     

       85
       85
       -
         #

     

       86
       86
       -
         #     nix-repl> foo = {a, b}: {c = a + b;}

     

       87
       87
       -
         #

     

       88
       88
       -
         #     nix-repl> interface = {args, val, ...}: extend: val // {inherit extend;}

     

       89
       89
       -
         #

     

       90
       90
       -
         #     nix-repl> obj = makeExtensibleWithInterface interface (output: self: { args = {a = 1; b = 2;}; val = foo self.args; })

     

       91
       91
       -
         #

     

       92
       92
       -
         #     nix-repl> obj.c

     

       93
       93
       -
         #     3

     

       94
       94
       -
         #

     

       95
       95
       -
         #     nix-repl> obj = obj.extend (output: self: super: { args = super.args // { b = output.d; }; })

     

       96
       96
       -
         #

     

       97
       97
       -
         #     nix-repl> obj = obj.extend (output: self: super: { val = super.val // { d = 10; }; })

     

       98
       98
       -
         #

     

       99
       99
       -
         #     nix-repl> { inherit (obj) c d; }

     

       100
       100
       -
         #     { c = 11; d = 10; }

     

       101
       101
       -
         makeExtensibleWithInterface = interface: f: let i = interface

     

       102
       102
       -
           (fix' (f i))

     

       103
       103
       -
           (fext: makeExtensibleWithInterface interface (i': (extends (fext i') (f i'))));

     

       104
       104
       -
         in i;

     

       75
       75
       +
         makeExtensibleWithCustomName = extenderName: rattrs:

     

       76
       76
       +
           fix' rattrs // {

     

       77
       77
       +
             ${extenderName} = f: makeExtensibleWithCustomName extenderName (extends f rattrs);

     

       78
       78
       +
          };

     

       105
       79
        
       }

+6 -1

pkgs/development/beam-modules/default.nix

···

       5
       5
        
       

     

       6
       6
        
         lib = pkgs.callPackage ./lib.nix {};

     

       7
       7
        
       

     

       8
       8
       +
         # FIXME: add support for overrideScope

     

       9
       9
       +
         callPackageWithScope = scope: drv: args: stdenv.lib.callPackageWith scope drv args;

     

       10
       10
       +
         mkScope = scope: pkgs // scope;

     

       11
       11
       +
       

     

       8
       12
        
         packages = self:

     

       9
       13
        
           let

     

       10
       10
       -
             callPackage = stdenv.lib.callPackageWith (pkgs // self);

     

       14
       14
       +
             defaultScope = mkScope self;

     

       15
       15
       +
             callPackage = drv: args: callPackageWithScope defaultScope drv args;

     

       11
       16
        
           in

     

       12
       17
        
             import ./hex-packages.nix {

     

       13
       18
        
               inherit pkgs stdenv callPackage;

+11 -9

pkgs/development/haskell-modules/default.nix

···

       7
       7
        
       , configurationNix ? import ./configuration-nix.nix

     

       8
       8
        
       }:

     

       9
       9
        
       

     

       10
       10
       -
       self: # Provided by `callPackageWithOutput`

     

       11
       11
       -
       

     

       12
       10
        
       let

     

       13
       11
        
       

     

       14
       12
        
         inherit (lib) extends makeExtensible;

     
···

       16
       14
        
       

     

       17
       15
        
         haskellPackages = pkgs.callPackage makePackageSet {

     

       18
       16
        
           package-set = initialPackages;

     

       19
       19
       -
           extensible-self = self;

     

       20
       20
       -
           inherit stdenv haskellLib ghc;

     

       17
       17
       +
           inherit stdenv haskellLib ghc extensible-self;

     

       21
       18
        
         };

     

       22
       19
        
       

     

       23
       20
        
         commonConfiguration = configurationCommon { inherit pkgs haskellLib; };

     

       24
       21
        
         nixConfiguration = configurationNix { inherit pkgs haskellLib; };

     

       25
       22
        
       

     

       26
       26
       -
       in (extends overrides

     

       27
       27
       -
            (extends packageSetConfig

     

       28
       28
       -
              (extends compilerConfig

     

       29
       29
       -
                (extends commonConfiguration

     

       30
       30
       -
                  (extends nixConfiguration haskellPackages))))) self

     

       23
       23
       +
         extensible-self = makeExtensible

     

       24
       24
       +
           (extends overrides

     

       25
       25
       +
             (extends packageSetConfig

     

       26
       26
       +
               (extends compilerConfig

     

       27
       27
       +
                 (extends commonConfiguration

     

       28
       28
       +
                   (extends nixConfiguration haskellPackages)))));

     

       29
       29
       +
       

     

       30
       30
       +
       in

     

       31
       31
       +
       

     

       32
       32
       +
         extensible-self

+32 -2

pkgs/development/haskell-modules/make-package-set.nix

···

       29
       29
        
       

     

       30
       30
        
       let

     

       31
       31
        
       

     

       32
       32
       -
         inherit (stdenv.lib) fix' extends makeOverridable callPackageWith;

     

       32
       32
       +
         inherit (stdenv.lib) fix' extends makeOverridable;

     

       33
       33
        
         inherit (haskellLib) overrideCabal;

     

       34
       34
        
       

     

       35
       35
        
         mkDerivationImpl = pkgs.callPackage ./generic-builder.nix {

     
···

       61
       61
        
       

     

       62
       62
        
         mkDerivation = makeOverridable mkDerivationImpl;

     

       63
       63
        
       

     

       64
       64
       +
         # manualArgs are the arguments that were explictly passed to `callPackage`, like:

     

       65
       65
       +
         #

     

       66
       66
       +
         # callPackage foo { bar = null; };

     

       67
       67
       +
         #

     

       68
       68
       +
         # here `bar` is a manual argument.

     

       69
       69
       +
         callPackageWithScope = scope: fn: manualArgs:

     

       70
       70
       +
           let

     

       71
       71
       +
             # this code is copied from callPackage in lib/customisation.nix

     

       72
       72
       +
             #

     

       73
       73
       +
             # we cannot use `callPackage` here because we want to call `makeOverridable`

     

       74
       74
       +
             # on `drvScope` (we cannot add `overrideScope` after calling `callPackage` because then it is

     

       75
       75
       +
             # lost on `.override`) but determine the auto-args based on `drv` (the problem here

     

       76
       76
       +
             # is that nix has no way to "passthrough" args while preserving the reflection

     

       77
       77
       +
             # info that callPackage uses to determine the arguments).

     

       78
       78
       +
             drv = if builtins.isFunction fn then fn else import fn;

     

       79
       79
       +
             auto = builtins.intersectAttrs (builtins.functionArgs drv) scope;

     

       80
       80
       +
       

     

       81
       81
       +
             # this wraps the `drv` function to add a `overrideScope` function to the result.

     

       82
       82
       +
             drvScope = allArgs: drv allArgs // {

     

       83
       83
       +
               overrideScope = f:

     

       84
       84
       +
                 let newScope = mkScope (fix' (extends f scope.__unfix__));

     

       85
       85
       +
                 # note that we have to be careful here: `allArgs` includes the auto-arguments that

     

       86
       86
       +
                 # weren't manually specified. If we would just pass `allArgs` to the recursive call here,

     

       87
       87
       +
                 # then we wouldn't look up any packages in the scope in the next interation, because it

     

       88
       88
       +
                 # appears as if all arguments were already manually passed, so the scope change would do

     

       89
       89
       +
                 # nothing.

     

       90
       90
       +
                 in callPackageWithScope newScope drv manualArgs;

     

       91
       91
       +
             };

     

       92
       92
       +
           in stdenv.lib.makeOverridable drvScope (auto // manualArgs);

     

       93
       93
       +
       

     

       64
       94
        
         mkScope = scope: pkgs // pkgs.xorg // pkgs.gnome2 // { inherit stdenv; } // scope;

     

       65
       95
        
         defaultScope = mkScope self;

     

       66
       66
       -
         callPackage = drv: args: callPackageWith defaultScope drv args;

     

       96
       96
       +
         callPackage = drv: args: callPackageWithScope defaultScope drv args;

     

       67
       97
        
       

     

       68
       98
        
         withPackages = packages: callPackage ./with-packages-wrapper.nix {

     

       69
       99
        
           inherit (self) llvmPackages;

+10 -1

pkgs/development/idris-modules/default.nix

···

       1
       1
        
       { pkgs, idris, overrides ? (self: super: {}) }: let

     

       2
       2
        
         inherit (pkgs.lib) callPackageWith fix' extends;

     

       3
       3
        
       

     

       4
       4
       +
         /* Taken from haskell-modules/default.nix, should probably abstract this away */

     

       5
       5
       +
         callPackageWithScope = scope: drv: args: (callPackageWith scope drv args) // {

     

       6
       6
       +
           overrideScope = f: callPackageWithScope (mkScope (fix' (extends f scope.__unfix__))) drv args;

     

       7
       7
       +
         };

     

       8
       8
       +
       

     

       9
       9
       +
         mkScope = scope : pkgs // pkgs.xorg // pkgs.gnome2 // scope;

     

       10
       10
       +
       

     

       4
       11
        
         idrisPackages = self: let

     

       5
       5
       -
           callPackage = callPackageWith (pkgs // pkgs.xorg // pkgs.gnome2 // self);

     

       12
       12
       +
           defaultScope = mkScope self;

     

       13
       13
       +
       

     

       14
       14
       +
           callPackage = callPackageWithScope defaultScope;

     

       6
       15
        
       

     

       7
       16
        
           builtins_ = pkgs.lib.mapAttrs self.build-builtin-package {

     

       8
       17
        
             prelude = [];

+3 -1

pkgs/top-level/all-packages.nix

···

       5710
       5710
        
       

     

       5711
       5711
        
         haskell = callPackage ./haskell-packages.nix { };

     

       5712
       5712
        
       

     

       5713
       5713
       -
         haskellPackages = haskell.packages.ghc802.extend (config.haskellPackageOverrides or (self: super: {}));

     

       5713
       5713
       +
         haskellPackages = haskell.packages.ghc802.override {

     

       5714
       5714
       +
           overrides = config.haskellPackageOverrides or (self: super: {});

     

       5715
       5715
       +
         };

     

       5714
       5716
        
       

     

       5715
       5717
        
         inherit (haskellPackages) ghc;

     

       5716
       5718

+20 -21

pkgs/top-level/haskell-packages.nix

···

       1
       1
       -
       { pkgs, lib, stdenv, buildPlatform, targetPlatform }:

     

       1
       1
       +
       { pkgs, lib, newScope, stdenv, buildPlatform, targetPlatform }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         # These are attributes in compiler and packages that don't support integer-simple.

     
···

       23
       23
        
           inherit pkgs;

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
       -
         callPackage = lib.callPackageWith (pkgs // { inherit haskellLib; });

     

       27
       27
       -
         callPackageWithOutput = lib.callPackageWithOutputWith (pkgs // { inherit haskellLib; });

     

       26
       26
       +
         callPackage = newScope { inherit haskellLib; };

     

       28
       27
        
       

     

       29
       28
        
       in rec {

     

       30
       29
        
         lib = haskellLib;

     
···

       122
       121
        
         packages = {

     

       123
       122
        
       

     

       124
       123
        
           # Support for this compiler is broken, because it can't deal with directory-based package databases.

     

       125
       125
       -
           # ghc6104 = callPackageWithOutput ../development/haskell-modules { ghc = compiler.ghc6104; };

     

       126
       126
       -
           ghc6123 = callPackageWithOutput ../development/haskell-modules {

     

       124
       124
       +
           # ghc6104 = callPackage ../development/haskell-modules { ghc = compiler.ghc6104; };

     

       125
       125
       +
           ghc6123 = callPackage ../development/haskell-modules {

     

       127
       126
        
             ghc = compiler.ghc6123;

     

       128
       127
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-6.12.x.nix { };

     

       129
       128
        
           };

     

       130
       130
       -
           ghc704 = callPackageWithOutput ../development/haskell-modules {

     

       129
       129
       +
           ghc704 = callPackage ../development/haskell-modules {

     

       131
       130
        
             ghc = compiler.ghc704;

     

       132
       131
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-7.0.x.nix { };

     

       133
       132
        
           };

     

       134
       134
       -
           ghc722 = callPackageWithOutput ../development/haskell-modules {

     

       133
       133
       +
           ghc722 = callPackage ../development/haskell-modules {

     

       135
       134
        
             ghc = compiler.ghc722;

     

       136
       135
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-7.2.x.nix { };

     

       137
       136
        
           };

     

       138
       138
       -
           ghc742 = callPackageWithOutput ../development/haskell-modules {

     

       137
       137
       +
           ghc742 = callPackage ../development/haskell-modules {

     

       139
       138
        
             ghc = compiler.ghc742;

     

       140
       139
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-7.4.x.nix { };

     

       141
       140
        
           };

     

       142
       142
       -
           ghc763 = callPackageWithOutput ../development/haskell-modules {

     

       141
       141
       +
           ghc763 = callPackage ../development/haskell-modules {

     

       143
       142
        
             ghc = compiler.ghc763;

     

       144
       143
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-7.6.x.nix { };

     

       145
       144
        
           };

     

       146
       146
       -
           ghc783 = callPackageWithOutput ../development/haskell-modules {

     

       145
       145
       +
           ghc783 = callPackage ../development/haskell-modules {

     

       147
       146
        
             ghc = compiler.ghc783;

     

       148
       147
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-7.8.x.nix { };

     

       149
       148
        
           };

     

       150
       150
       -
           ghc784 = callPackageWithOutput ../development/haskell-modules {

     

       149
       149
       +
           ghc784 = callPackage ../development/haskell-modules {

     

       151
       150
        
             ghc = compiler.ghc784;

     

       152
       151
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-7.8.x.nix { };

     

       153
       152
        
           };

     

       154
       154
       -
           ghc7102 = callPackageWithOutput ../development/haskell-modules {

     

       153
       153
       +
           ghc7102 = callPackage ../development/haskell-modules {

     

       155
       154
        
             ghc = compiler.ghc7102;

     

       156
       155
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-7.10.x.nix { };

     

       157
       156
        
           };

     

       158
       158
       -
           ghc7103 = callPackageWithOutput ../development/haskell-modules {

     

       157
       157
       +
           ghc7103 = callPackage ../development/haskell-modules {

     

       159
       158
        
             ghc = compiler.ghc7103;

     

       160
       159
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-7.10.x.nix { };

     

       161
       160
        
           };

     

       162
       162
       -
           ghc802 = callPackageWithOutput ../development/haskell-modules {

     

       161
       161
       +
           ghc802 = callPackage ../development/haskell-modules {

     

       163
       162
        
             ghc = compiler.ghc802;

     

       164
       163
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.0.x.nix { };

     

       165
       164
        
           };

     

       166
       166
       -
           ghc821 = callPackageWithOutput ../development/haskell-modules {

     

       165
       165
       +
           ghc821 = callPackage ../development/haskell-modules {

     

       167
       166
        
             ghc = compiler.ghc821;

     

       168
       167
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.2.x.nix { };

     

       169
       168
        
           };

     

       170
       170
       -
           ghcHEAD = callPackageWithOutput ../development/haskell-modules {

     

       169
       169
       +
           ghcHEAD = callPackage ../development/haskell-modules {

     

       171
       170
        
             ghc = compiler.ghcHEAD;

     

       172
       171
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-head.nix { };

     

       173
       172
        
           };

     

       174
       173
        
           # TODO Support for multiple variants here

     

       175
       175
       -
           ghcCross = callPackageWithOutput ../development/haskell-modules {

     

       174
       174
       +
           ghcCross = callPackage ../development/haskell-modules {

     

       176
       175
        
             ghc = compiler.ghcHEAD.crossCompiler;

     

       177
       176
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-head.nix { };

     

       178
       177
        
           };

     

       179
       179
       -
           ghcCross821 = callPackageWithOutput ../development/haskell-modules {

     

       178
       178
       +
           ghcCross821 = callPackage ../development/haskell-modules {

     

       180
       179
        
             ghc = compiler.ghc821.crossCompiler;

     

       181
       180
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.2.x.nix { };

     

       182
       181
        
           };

     

       183
       183
       -
           ghcjs = callPackageWithOutput ../development/haskell-modules {

     

       182
       182
       +
           ghcjs = callPackage ../development/haskell-modules {

     

       184
       183
        
             ghc = compiler.ghcjs;

     

       185
       184
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-7.10.x.nix { };

     

       186
       185
        
             packageSetConfig = callPackage ../development/haskell-modules/configuration-ghcjs.nix { };

     

       187
       186
        
           };

     

       188
       188
       -
           ghcjsHEAD = callPackageWithOutput ../development/haskell-modules {

     

       187
       187
       +
           ghcjsHEAD = callPackage ../development/haskell-modules {

     

       189
       188
        
             ghc = compiler.ghcjsHEAD;

     

       190
       189
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.0.x.nix { };

     

       191
       190
        
             packageSetConfig = callPackage ../development/haskell-modules/configuration-ghcjs.nix { };

     

       192
       191
        
           };

     

       193
       193
       -
           ghcHaLVM240 = callPackageWithOutput ../development/haskell-modules {

     

       192
       192
       +
           ghcHaLVM240 = callPackage ../development/haskell-modules {

     

       194
       193
        
             ghc = compiler.ghcHaLVM240;

     

       195
       194
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-halvm-2.4.0.nix { };

     

       196
       195
        
           };

-4

pkgs/top-level/splice.nix

···

       80
       80
        
         # `newScope' for sets of packages in `pkgs' (see e.g. `gnome' below).

     

       81
       81
        
         callPackage = pkgs.newScope {};

     

       82
       82
        
       

     

       83
       83
       -
         callPackageWithOutput = pkgs.newScopeWithOutput {};

     

       84
       84
       -
       

     

       85
       83
        
         callPackages = lib.callPackagesWith splicedPackages;

     

       86
       84
        
       

     

       87
       85
        
         newScope = extra: lib.callPackageWith (splicedPackages // extra);

     

       88
       88
       -
       

     

       89
       89
       -
         newScopeWithOutput = extra: lib.callPackageWithOutputWith (splicedPackages // extra);

     

       90
       86
        
       }