commit fae2ff5c035231ea858f9fa6f712e50143db0899 · pyrox.dev/nixpkgs

+2 -2

nixos/doc/manual/development/option-declarations.section.md

···

       124
       124
        
       ```nix

     

       125
       125
        
       lib.mkPackageOption pkgs "GHC" {

     

       126
       126
        
         default = [ "ghc" ];

     

       127
       127
       -
         example = "pkgs.haskell.packages.ghc924.ghc.withPackages (hkgs: [ hkgs.primes ])";

     

       127
       127
       +
         example = "pkgs.haskell.packages.ghc92.ghc.withPackages (hkgs: [ hkgs.primes ])";

     

       128
       128
        
       }

     

       129
       129
        
       # is like

     

       130
       130
        
       lib.mkOption {

     

       131
       131
        
         type = lib.types.package;

     

       132
       132
        
         default = pkgs.ghc;

     

       133
       133
        
         defaultText = lib.literalExpression "pkgs.ghc";

     

       134
       134
       -
         example = lib.literalExpression "pkgs.haskell.packages.ghc924.ghc.withPackages (hkgs: [ hkgs.primes ])";

     

       134
       134
       +
         example = lib.literalExpression "pkgs.haskell.packages.ghc92.ghc.withPackages (hkgs: [ hkgs.primes ])";

     

       135
       135
        
         description = "The GHC package to use.";

     

       136
       136
        
       }

     

       137
       137
        
       ```

+2 -2

nixos/doc/manual/from_md/development/option-declarations.section.xml

···

       189
       189
        
               <programlisting language="bash">

     

       190
       190
        
       lib.mkPackageOption pkgs &quot;GHC&quot; {

     

       191
       191
        
         default = [ &quot;ghc&quot; ];

     

       192
       192
       -
         example = &quot;pkgs.haskell.packages.ghc924.ghc.withPackages (hkgs: [ hkgs.primes ])&quot;;

     

       192
       192
       +
         example = &quot;pkgs.haskell.packages.ghc92.ghc.withPackages (hkgs: [ hkgs.primes ])&quot;;

     

       193
       193
        
       }

     

       194
       194
        
       # is like

     

       195
       195
        
       lib.mkOption {

     

       196
       196
        
         type = lib.types.package;

     

       197
       197
        
         default = pkgs.ghc;

     

       198
       198
        
         defaultText = lib.literalExpression &quot;pkgs.ghc&quot;;

     

       199
       199
       -
         example = lib.literalExpression &quot;pkgs.haskell.packages.ghc924.ghc.withPackages (hkgs: [ hkgs.primes ])&quot;;

     

       199
       199
       +
         example = lib.literalExpression &quot;pkgs.haskell.packages.ghc92.ghc.withPackages (hkgs: [ hkgs.primes ])&quot;;

     

       200
       200
        
         description = &quot;The GHC package to use.&quot;;

     

       201
       201
        
       }

     

       202
       202
        
       </programlisting>

+12

nixos/doc/manual/from_md/release-notes/rl-2111.section.xml

···

       2087
       2087
        
                 <literal>java-packages.compiler</literal>.

     

       2088
       2088
        
               </para>

     

       2089
       2089
        
             </listitem>

     

       2090
       2090
       +
             <listitem>

     

       2091
       2091
       +
               <para>

     

       2092
       2092
       +
                 The sets <literal>haskell.packages</literal> and

     

       2093
       2093
       +
                 <literal>haskell.compiler</literal> now contain for every ghc

     

       2094
       2094
       +
                 version an attribute with the minor version dropped. E.g. for

     

       2095
       2095
       +
                 <literal>ghc8107</literal> there also now exists

     

       2096
       2096
       +
                 <literal>ghc810</literal>. Those attributes point to the same

     

       2097
       2097
       +
                 compilers and packagesets but have the advantage that e.g.

     

       2098
       2098
       +
                 <literal>ghc92</literal> stays stable when we update from

     

       2099
       2099
       +
                 <literal>ghc924</literal> to <literal>ghc925</literal>.

     

       2100
       2100
       +
               </para>

     

       2101
       2101
       +
             </listitem>

     

       2090
       2102
        
           </itemizedlist>

     

       2091
       2103
        
         </section>

     

       2092
       2104
        
       </section>

nixos/doc/manual/release-notes/rl-2111.section.md

···

       573
       573
        
       - hydrus has been upgraded from version `438` to `463`. Since upgrading between releases this old is advised against, be sure to have a backup of your data before upgrading. For details, see [the hydrus manual](https://hydrusnetwork.github.io/hydrus/help/getting_started_installing.html#big_updates).

     

       574
       574
        
       

     

       575
       575
        
       - More jdk and jre versions are now exposed via `java-packages.compiler`.

     

       576
       576
       +
       

     

       577
       577
       +
       - The sets `haskell.packages` and `haskell.compiler` now contain for every ghc version an attribute with the minor version dropped. E.g. for `ghc8107` there also now exists `ghc810`. Those attributes point to the same compilers and packagesets but have the advantage that e.g. `ghc92` stays stable when we update from `ghc924` to `ghc925`.

+1 -1

nixos/modules/services/x11/window-managers/xmonad.nix

···

       46
       46
        
             haskellPackages = mkOption {

     

       47
       47
        
               default = pkgs.haskellPackages;

     

       48
       48
        
               defaultText = literalExpression "pkgs.haskellPackages";

     

       49
       49
       -
               example = literalExpression "pkgs.haskell.packages.ghc8107";

     

       49
       49
       +
               example = literalExpression "pkgs.haskell.packages.ghc810";

     

       50
       50
        
               type = types.attrs;

     

       51
       51
        
               description = lib.mdDoc ''

     

       52
       52
        
                 haskellPackages used to build Xmonad and other packages.

+1 -1

pkgs/development/compilers/elm/default.nix

···

       7
       7
        
       

     

       8
       8
        
         fetchElmDeps = pkgs.callPackage ./fetchElmDeps.nix { };

     

       9
       9
        
       

     

       10
       10
       -
         hsPkgs = self: pkgs.haskell.packages.ghc8107.override {

     

       10
       10
       +
         hsPkgs = self: pkgs.haskell.packages.ghc810.override {

     

       11
       11
        
           overrides = self: super: with pkgs.haskell.lib.compose; with lib;

     

       12
       12
        
           let elmPkgs = rec {

     

       13
       13
        
             elm = overrideCabal (drv: {

+2 -2

pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , stdenv

     

       3
       3
       -
       , supportedGhcVersions ? [ "884" "8107" "902" "924" ]

     

       3
       3
       +
       , supportedGhcVersions ? [ "88" "810" "90" "92" ]

     

       4
       4
        
       , dynamic ? false

     

       5
       5
        
       , haskellPackages

     

       6
       6
        
       , haskell

     
···

       8
       8
        
       #

     

       9
       9
        
       # The recommended way to override this package is

     

       10
       10
        
       #

     

       11
       11
       -
       # pkgs.haskell-language-server.override { supportedGhcVersions = [ "902" ]; }

     

       11
       11
       +
       # pkgs.haskell-language-server.override { supportedGhcVersions = [ "90" ]; }

     

       12
       12
        
       #

     

       13
       13
        
       # for example. Read more about this in the haskell-language-server section of the nixpkgs manual.

     

       14
       14
        
       #

+9 -9

pkgs/top-level/all-packages.nix

···

       9798
       9798
        
         pakcs = callPackage ../development/compilers/pakcs {

     

       9799
       9799
        
           # Doesn't compile with GHC 9.0 due to whitespace syntax changes

     

       9800
       9800
        
           # see also https://github.com/NixOS/nixpkgs/issues/166108

     

       9801
       9801
       -
           haskellPackages = haskell.packages.ghc8107;

     

       9801
       9801
       +
           haskellPackages = haskell.packages.ghc810;

     

       9802
       9802
        
         };

     

       9803
       9803
        
       

     

       9804
       9804
        
         pal = callPackage ../tools/misc/pal { };

     
···

       12714
       12714
        
       

     

       12715
       12715
        
         # To expose more packages for Yi, override the extraPackages arg.

     

       12716
       12716
        
         yi = callPackage ../applications/editors/yi/wrapper.nix {

     

       12717
       12717
       -
           haskellPackages = haskell.packages.ghc8107;

     

       12717
       12717
       +
           haskellPackages = haskell.packages.ghc810;

     

       12718
       12718
        
         };

     

       12719
       12719
        
       

     

       12720
       12720
        
         yj = callPackage ../development/tools/yj { };

     
···

       13894
       13894
        
         haskellPackages = dontRecurseIntoAttrs

     

       13895
       13895
        
           # Prefer native-bignum to avoid linking issues with gmp

     

       13896
       13896
        
           (if stdenv.hostPlatform.isStatic

     

       13897
       13897
       -
              then haskell.packages.native-bignum.ghc902

     

       13898
       13898
       -
              else haskell.packages.ghc902);

     

       13897
       13897
       +
              then haskell.packages.native-bignum.ghc90

     

       13898
       13898
       +
              else haskell.packages.ghc90);

     

       13899
       13899
        
       

     

       13900
       13900
        
         # haskellPackages.ghc is build->host (it exposes the compiler used to build the

     

       13901
       13901
        
         # set, similarly to stdenv.cc), but pkgs.ghc should be host->target to be more

     
···

       13908
       13908
        
         ghc = targetPackages.haskellPackages.ghc or

     

       13909
       13909
        
           # Prefer native-bignum to avoid linking issues with gmp

     

       13910
       13910
        
           (if stdenv.targetPlatform.isStatic

     

       13911
       13911
       -
              then haskell.compiler.native-bignum.ghc902

     

       13912
       13912
       -
              else haskell.compiler.ghc902);

     

       13911
       13911
       +
              then haskell.compiler.native-bignum.ghc90

     

       13912
       13912
       +
              else haskell.compiler.ghc90);

     

       13913
       13913
        
       

     

       13914
       13914
        
         cabal-install = haskell.lib.compose.justStaticExecutables haskellPackages.cabal-install;

     

       13915
       13915
        
       

     
···

       15188
       15188
        
           stdenv = clangStdenv;

     

       15189
       15189
        
         };

     

       15190
       15190
        
       

     

       15191
       15191
       -
         jacinda = haskell.lib.compose.justStaticExecutables haskell.packages.ghc924.jacinda;

     

       15191
       15191
       +
         jacinda = haskell.lib.compose.justStaticExecutables haskell.packages.ghc92.jacinda;

     

       15192
       15192
        
       

     

       15193
       15193
        
         janet = callPackage ../development/interpreters/janet {};

     

       15194
       15194
        
       

     
···

       23031
       23031
        
       

     

       23032
       23032
        
         hashi-ui = callPackage ../servers/hashi-ui {};

     

       23033
       23033
        
       

     

       23034
       23034
       -
         hasura-graphql-engine = haskell.lib.compose.justStaticExecutables haskell.packages.ghc8107.graphql-engine;

     

       23034
       23034
       +
         hasura-graphql-engine = haskell.lib.compose.justStaticExecutables haskell.packages.ghc810.graphql-engine;

     

       23035
       23035
        
       

     

       23036
       23036
        
         hasura-cli = callPackage ../servers/hasura/cli.nix { };

     

       23037
       23037
        
       

     
···

       31422
       31422
        
         # Use GHC 9.0 when this asserts starts to fire

     

       31423
       31423
        
         taffybar = assert haskellPackages.taffybar.version == "3.3.0";

     

       31424
       31424
        
         callPackage ../applications/window-managers/taffybar {

     

       31425
       31425
       -
           inherit (haskell.packages.ghc8107) ghcWithPackages taffybar;

     

       31425
       31425
       +
           inherit (haskell.packages.ghc810) ghcWithPackages taffybar;

     

       31426
       31426
        
         };

     

       31427
       31427
        
       

     

       31428
       31428
        
         tagainijisho = libsForQt5.callPackage ../applications/office/tagainijisho {};

+21 -8

pkgs/top-level/haskell-packages.nix

···

       15
       15
        
           "integer-simple"

     

       16
       16
        
           "native-bignum"

     

       17
       17
        
           "ghc902"

     

       18
       18
       +
           "ghc90"

     

       18
       19
        
           "ghc924"

     

       20
       20
       +
           "ghc92"

     

       19
       21
        
           "ghc942"

     

       22
       22
       +
           "ghc94"

     

       20
       23
        
           "ghcHEAD"

     

       21
       24
        
         ];

     

       22
       25
        
       

     

       23
       26
        
         nativeBignumIncludes = [

     

       24
       24
       -
           "ghc902"

     

       25
       25
       -
           "ghc924"

     

       26
       26
       -
           "ghc942"

     

       27
       27
       +
           "ghc90"

     

       28
       28
       +
           "ghc92"

     

       29
       29
       +
           "ghc94"

     

       27
       30
        
           "ghcHEAD"

     

       28
       31
        
         ];

     

       29
       32
        
       

     
···

       56
       59
        
       

     

       57
       60
        
         package-list = callPackage ../development/haskell-modules/package-list.nix {};

     

       58
       61
        
       

     

       59
       59
       -
         compiler = {

     

       62
       62
       +
         compiler = rec {

     

       60
       63
        
       

     

       61
       64
        
           ghc865Binary = callPackage ../development/compilers/ghc/8.6.5-binary.nix {

     

       62
       65
        
             llvmPackages = pkgs.llvmPackages_6;

     
···

       103
       106
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_7;

     

       104
       107
        
             llvmPackages = pkgs.llvmPackages_7;

     

       105
       108
        
           };

     

       109
       109
       +
           ghc88 = ghc884;

     

       106
       110
        
           ghc8107 = callPackage ../development/compilers/ghc/8.10.7.nix {

     

       107
       111
        
             bootPkgs =

     

       108
       112
        
               # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar

     
···

       123
       127
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       124
       128
        
             llvmPackages = pkgs.llvmPackages_12;

     

       125
       129
        
           };

     

       130
       130
       +
           ghc810 = ghc8107;

     

       126
       131
        
           ghc902 = callPackage ../development/compilers/ghc/9.0.2.nix {

     

       127
       132
        
             bootPkgs =

     

       128
       133
        
               # aarch64 ghc8107Binary exceeds max output size on hydra

     
···

       130
       135
        
               if stdenv.hostPlatform.isAarch then

     

       131
       136
        
                 packages.ghc8107BinaryMinimal

     

       132
       137
        
               else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then

     

       133
       133
       -
                 packages.ghc8107

     

       138
       138
       +
                 packages.ghc810

     

       134
       139
        
               else

     

       135
       140
        
                 packages.ghc8107Binary;

     

       136
       141
        
             inherit (buildPackages.python3Packages) sphinx;

     
···

       138
       143
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       139
       144
        
             llvmPackages = pkgs.llvmPackages_12;

     

       140
       145
        
           };

     

       146
       146
       +
           ghc90 = ghc902;

     

       141
       147
        
           ghc924 = callPackage ../development/compilers/ghc/9.2.4.nix {

     

       142
       148
        
             bootPkgs =

     

       143
       149
        
               # aarch64 ghc8107Binary exceeds max output size on hydra

     

       144
       150
        
               if stdenv.hostPlatform.isAarch then

     

       145
       151
        
                 packages.ghc8107BinaryMinimal

     

       146
       152
        
               else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then

     

       147
       147
       -
                 packages.ghc8107

     

       153
       153
       +
                 packages.ghc810

     

       148
       154
        
               else

     

       149
       155
        
                 packages.ghc8107Binary;

     

       150
       156
        
             inherit (buildPackages.python3Packages) sphinx;

     
···

       155
       161
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       156
       162
        
             llvmPackages = pkgs.llvmPackages_12;

     

       157
       163
        
           };

     

       164
       164
       +
           ghc92 = ghc924;

     

       158
       165
        
           ghc942 = callPackage ../development/compilers/ghc/9.4.2.nix {

     

       159
       166
        
             bootPkgs =

     

       160
       167
        
               # Building with 9.2 is broken due to

     
···

       179
       186
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       180
       187
        
             llvmPackages = pkgs.llvmPackages_12;

     

       181
       188
        
           };

     

       189
       189
       +
           ghc94 = ghc942;

     

       182
       190
        
           ghcHEAD = callPackage ../development/compilers/ghc/head.nix {

     

       183
       191
        
             bootPkgs =

     

       184
       192
        
               if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then

     
···

       197
       205
        
       

     

       198
       206
        
           ghcjs = compiler.ghcjs810;

     

       199
       207
        
           ghcjs810 = callPackage ../development/compilers/ghcjs/8.10 {

     

       200
       200
       -
             bootPkgs = packages.ghc8107;

     

       208
       208
       +
             bootPkgs = packages.ghc810;

     

       201
       209
        
             ghcjsSrcJson = ../development/compilers/ghcjs/8.10/git.json;

     

       202
       210
        
             stage0 = ../development/compilers/ghcjs/8.10/stage0.nix;

     

       203
       211
        
           };

     
···

       227
       235
        
         packageOverrides = self : super : {};

     

       228
       236
        
       

     

       229
       237
        
         # Always get compilers from `buildPackages`

     

       230
       230
       -
         packages = let bh = buildPackages.haskell; in {

     

       238
       238
       +
         packages = let bh = buildPackages.haskell; in rec {

     

       231
       239
        
       

     

       232
       240
        
           ghc865Binary = callPackage ../development/haskell-modules {

     

       233
       241
        
             buildHaskellPackages = bh.packages.ghc865Binary;

     
···

       276
       284
        
             ghc = bh.compiler.ghc884;

     

       277
       285
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.8.x.nix { };

     

       278
       286
        
           };

     

       287
       287
       +
           ghc88 = ghc884;

     

       279
       288
        
           ghc8107 = callPackage ../development/haskell-modules {

     

       280
       289
        
             buildHaskellPackages = bh.packages.ghc8107;

     

       281
       290
        
             ghc = bh.compiler.ghc8107;

     

       282
       291
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };

     

       283
       292
        
           };

     

       293
       293
       +
           ghc810 = ghc8107;

     

       284
       294
        
           ghc902 = callPackage ../development/haskell-modules {

     

       285
       295
        
             buildHaskellPackages = bh.packages.ghc902;

     

       286
       296
        
             ghc = bh.compiler.ghc902;

     

       287
       297
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.0.x.nix { };

     

       288
       298
        
           };

     

       299
       299
       +
           ghc90 = ghc902;

     

       289
       300
        
           ghc924 = callPackage ../development/haskell-modules {

     

       290
       301
        
             buildHaskellPackages = bh.packages.ghc924;

     

       291
       302
        
             ghc = bh.compiler.ghc924;

     

       292
       303
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.2.x.nix { };

     

       293
       304
        
           };

     

       305
       305
       +
           ghc92 = ghc924;

     

       294
       306
        
           ghc942 = callPackage ../development/haskell-modules {

     

       295
       307
        
             buildHaskellPackages = bh.packages.ghc942;

     

       296
       308
        
             ghc = bh.compiler.ghc942;

     

       297
       309
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.4.x.nix { };

     

       298
       310
        
           };

     

       311
       311
       +
           ghc94= ghc942;

     

       299
       312
        
           ghcHEAD = callPackage ../development/haskell-modules {

     

       300
       313
        
             buildHaskellPackages = bh.packages.ghcHEAD;

     

       301
       314
        
             ghc = bh.compiler.ghcHEAD;

+26 -25

pkgs/top-level/release-haskell.nix

···

       49
       49
        
       

     

       50
       50
        
         # list of all compilers to test specific packages on

     

       51
       51
        
         released = with compilerNames; [

     

       52
       52
       -
           ghc884

     

       53
       53
       -
           ghc8107

     

       54
       54
       -
           ghc902

     

       55
       55
       -
           ghc924

     

       52
       52
       +
           ghc88

     

       53
       53
       +
           ghc810

     

       54
       54
       +
           ghc90

     

       55
       55
       +
           ghc92

     

       56
       56
        
         ];

     

       57
       57
        
       

     

       58
       58
        
         # packagePlatforms applied to `haskell.packages.*`

     
···

       287
       287
        
       

     

       288
       288
        
                 # Can't be built with musl, see meta.broken comment in the drv

     

       289
       289
        
                 integer-simple.ghc884 = {};

     

       290
       290
       +
                 integer-simple.ghc88 = {};

     

       290
       291
        
               };

     

       291
       292
        
       

     

       292
       293
        
             # Get some cache going for MUSL-enabled GHC.

     
···

       331
       332
        
                     ;

     

       332
       333
        
                   };

     

       333
       334
        
       

     

       334
       334
       -
                   haskell.packages.native-bignum.ghc924 = {

     

       335
       335
       -
                     inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.native-bignum.ghc924)

     

       335
       335
       +
                   haskell.packages.native-bignum.ghc92 = {

     

       336
       336
       +
                     inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.native-bignum.ghc92)

     

       336
       337
        
                       hello

     

       337
       338
        
                       lens

     

       338
       339
        
                       random

     
···

       365
       366
        
             nix-paths = released;

     

       366
       367
        
             titlecase = released;

     

       367
       368
        
             ghc-api-compat = [

     

       368
       368
       -
               compilerNames.ghc884

     

       369
       369
       -
               compilerNames.ghc8107

     

       370
       370
       -
               compilerNames.ghc902

     

       369
       369
       +
               compilerNames.ghc88

     

       370
       370
       +
               compilerNames.ghc810

     

       371
       371
       +
               compilerNames.ghc90

     

       371
       372
        
             ];

     

       372
       373
        
             ghc-bignum = [

     

       373
       373
       -
               compilerNames.ghc884

     

       374
       374
       -
               compilerNames.ghc8107

     

       374
       374
       +
               compilerNames.ghc88

     

       375
       375
       +
               compilerNames.ghc810

     

       375
       376
        
             ];

     

       376
       377
        
             ghc-lib = released;

     

       377
       378
        
             ghc-lib-parser = released;

     

       378
       379
        
             ghc-lib-parser-ex = released;

     

       379
       380
        
             spectacle = [

     

       380
       380
       -
               compilerNames.ghc8107

     

       381
       381
       +
               compilerNames.ghc810

     

       381
       382
        
             ];

     

       382
       383
        
             weeder = [

     

       383
       383
       -
               compilerNames.ghc8107

     

       384
       384
       -
               compilerNames.ghc902

     

       385
       385
       -
               compilerNames.ghc924

     

       384
       384
       +
               compilerNames.ghc810

     

       385
       385
       +
               compilerNames.ghc90

     

       386
       386
       +
               compilerNames.ghc92

     

       386
       387
        
             ];

     

       387
       388
        
             purescript-cst = [

     

       388
       388
       -
               compilerNames.ghc8107

     

       389
       389
       +
               compilerNames.ghc810

     

       389
       390
        
             ];

     

       390
       391
        
             purescript-ast = [

     

       391
       391
       -
               compilerNames.ghc8107

     

       392
       392
       +
               compilerNames.ghc810

     

       392
       393
        
             ];

     

       393
       394
        
           })

     

       394
       395
        
           {

     
···

       453
       454
        
               constituents = accumulateDerivations [

     

       454
       455
        
                 jobs.pkgsMusl.haskell.compiler.ghc8102Binary

     

       455
       456
        
                 jobs.pkgsMusl.haskell.compiler.ghc8107Binary

     

       456
       456
       -
                 jobs.pkgsMusl.haskell.compiler.ghc884

     

       457
       457
       -
                 jobs.pkgsMusl.haskell.compiler.ghc8107

     

       458
       458
       -
                 jobs.pkgsMusl.haskell.compiler.ghc902

     

       459
       459
       -
                 jobs.pkgsMusl.haskell.compiler.ghc924

     

       457
       457
       +
                 jobs.pkgsMusl.haskell.compiler.ghc88

     

       458
       458
       +
                 jobs.pkgsMusl.haskell.compiler.ghc810

     

       459
       459
       +
                 jobs.pkgsMusl.haskell.compiler.ghc90

     

       460
       460
       +
                 jobs.pkgsMusl.haskell.compiler.ghc92

     

       460
       461
        
                 jobs.pkgsMusl.haskell.compiler.ghcHEAD

     

       461
       461
       -
                 jobs.pkgsMusl.haskell.compiler.integer-simple.ghc8107

     

       462
       462
       -
                 jobs.pkgsMusl.haskell.compiler.native-bignum.ghc902

     

       463
       463
       -
                 jobs.pkgsMusl.haskell.compiler.native-bignum.ghc924

     

       462
       462
       +
                 jobs.pkgsMusl.haskell.compiler.integer-simple.ghc810

     

       463
       463
       +
                 jobs.pkgsMusl.haskell.compiler.native-bignum.ghc90

     

       464
       464
       +
                 jobs.pkgsMusl.haskell.compiler.native-bignum.ghc92

     

       464
       465
        
                 jobs.pkgsMusl.haskell.compiler.native-bignum.ghcHEAD

     

       465
       466
        
               ];

     

       466
       467
        
             };

     
···

       476
       477
        
               };

     

       477
       478
        
               constituents = accumulateDerivations [

     

       478
       479
        
                 jobs.pkgsStatic.haskellPackages

     

       479
       479
       -
                 jobs.pkgsStatic.haskell.packages.native-bignum.ghc924

     

       480
       480
       +
                 jobs.pkgsStatic.haskell.packages.native-bignum.ghc92

     

       480
       481
        
               ];

     

       481
       482
        
             };

     

       482
       483
        
           }