commit 57e15d64c3f675301cfee9fe4e87726691d8c94e · pyrox.dev/nixpkgs

maintainers/maintainer-list.nix

···

       15407
       15407
        
           github = "zuzuleinen";

     

       15408
       15408
        
           githubId = 944919;

     

       15409
       15409
        
         };

     

       15410
       15410
       +
         quasigod-io = {

     

       15411
       15411
       +
           email = "quasigod-io@protonmail.com";

     

       15412
       15412
       +
           name = "Michael Belsanti";

     

       15413
       15413
       +
           github = "quasigod-io";

     

       15414
       15414
       +
           githubId = 62124625;

     

       15415
       15415
       +
         };

     

       15410
       15416
        
       }

maintainers/scripts/haskell/update-stackage.sh

···

       58
       58
        
           -e '/ jailbreak-cabal /d' \

     

       59
       59
        
           -e '/ language-nix /d' \

     

       60
       60
        
           -e '/ cabal-install /d' \

     

       61
       61
       +
           -e '/ lsp /d' \

     

       62
       62
       +
           -e '/ lsp-types /d' \

     

       63
       63
       +
           -e '/ lsp-test /d' \

     

       64
       64
       +
           -e '/ hie-bios /d' \

     

       61
       65
        
           < "${tmpfile_new}" >> $stackage_config

     

       66
       66
       +
       # Explanations:

     

       67
       67
       +
       # cabal2nix, distribution-nixpkgs, jailbreak-cabal, language-nix: These are our packages and we know what we are doing.

     

       68
       68
       +
       # lsp, lsp-types, lsp-test, hie-bios: These are tightly coupled to hls which is not in stackage. They have no rdeps in stackage.

     

       62
       69
        
       

     

       63
       70
        
       if [[ "${1:-}" == "--do-commit" ]]; then

     

       64
       71
        
       git add $stackage_config

+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>

+22

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

···

       1469
       1469
        
                 extent.

     

       1470
       1470
        
               </para>

     

       1471
       1471
        
             </listitem>

     

       1472
       1472
       +
             <listitem>

     

       1473
       1473
       +
               <para>

     

       1474
       1474
       +
                 <literal>pkgs.haskell-language-server</literal> will now by

     

       1475
       1475
       +
                 default be linked dynamically to improve TemplateHaskell

     

       1476
       1476
       +
                 compatibility. To mitigate the increased closure size it will

     

       1477
       1477
       +
                 now by default only support our current default ghc (at the

     

       1478
       1478
       +
                 moment 9.0.2). Add other ghc versions via e.g.

     

       1479
       1479
       +
                 <literal>pkgs.haskell-language-server.override { supportedGhcVersions = [ &quot;90&quot; &quot;92&quot; ]; }</literal>.

     

       1480
       1480
       +
               </para>

     

       1481
       1481
       +
             </listitem>

     

       1472
       1482
        
           </itemizedlist>

     

       1473
       1483
        
         </section>

     

       1474
       1484
        
         <section xml:id="sec-release-21.11-notable-changes">

     
···

       2085
       2095
        
               <para>

     

       2086
       2096
        
                 More jdk and jre versions are now exposed via

     

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

     

       2098
       2098
       +
               </para>

     

       2099
       2099
       +
             </listitem>

     

       2100
       2100
       +
             <listitem>

     

       2101
       2101
       +
               <para>

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       2088
       2110
        
               </para>

     

       2089
       2111
        
             </listitem>

     

       2090
       2112
        
           </itemizedlist>

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

···

       510
       510
        
             </listitem>

     

       511
       511
        
             <listitem>

     

       512
       512
        
               <para>

     

       513
       513
       +
                 The <literal>aws</literal> package has been removed due to

     

       514
       514
       +
                 being abandoned by the upstream. It is recommended to use

     

       515
       515
       +
                 <literal>awscli</literal> or <literal>awscli2</literal>

     

       516
       516
       +
                 instead.

     

       517
       517
       +
               </para>

     

       518
       518
       +
             </listitem>

     

       519
       519
       +
             <listitem>

     

       520
       520
       +
               <para>

     

       513
       521
        
                 The <literal>meta.mainProgram</literal> attribute of packages

     

       514
       522
        
                 in <literal>wineWowPackages</literal> now defaults to

     

       515
       523
        
                 <literal>&quot;wine64&quot;</literal>.

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

···

437
437

- `/usr` will always be included in the initial ramdisk. See the `fileSystems.<name>.neededForBoot` option.

438
438

If any files exist under `/usr` (which is not typical for NixOS), they will be included in the initial ramdisk, increasing its size to a possibly problematic extent.

439
439

440
440
+
- `pkgs.haskell-language-server` will now by default be linked dynamically to improve TemplateHaskell compatibility. To mitigate the increased closure size it will now by default only support our current default ghc (at the moment 9.0.2). Add other ghc versions via e.g. `pkgs.haskell-language-server.override { supportedGhcVersions = [ "90" "92" ]; }`.

441
441
+

440
442

## Other Notable Changes {#sec-release-21.11-notable-changes}

441
443

442
444

···

573
575

- 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
576

575
577

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

578
578
+

579
579
+
- 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`.

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

···

       176
       176
        
         `python3.pkgs.influxgraph` packages, have been removed due to lack of upstream

     

       177
       177
        
         maintenance.

     

       178
       178
        
       

     

       179
       179
       +
       - The `aws` package has been removed due to being abandoned by the upstream. It is recommended to use `awscli` or `awscli2` instead.

     

       180
       180
       +
       

     

       179
       181
        
       - The `meta.mainProgram` attribute of packages in `wineWowPackages` now defaults to `"wine64"`.

     

       180
       182
        
       

     

       181
       183
        
       - The `paperless` module now defaults `PAPERLESS_TIME_ZONE` to your configured system timezone.

+10 -29

nixos/modules/services/web-apps/lemmy.nix

···

       71
       71
        
         };

     

       72
       72
        
       

     

       73
       73
        
         config =

     

       74
       74
       -
           let

     

       75
       75
       -
             localPostgres = (cfg.settings.database.host == "localhost" || cfg.settings.database.host == "/run/postgresql");

     

       76
       76
       -
           in

     

       77
       74
        
           lib.mkIf cfg.enable {

     

       78
       75
        
             services.lemmy.settings = (mapAttrs (name: mkDefault)

     

       79
       76
        
               {

     
···

       100
       97
        
               };

     

       101
       98
        
             });

     

       102
       99
        
       

     

       103
       103
       -
             services.postgresql = mkIf localPostgres {

     

       104
       104
       -
               enable = mkDefault true;

     

       100
       100
       +
             services.postgresql = mkIf cfg.database.createLocally {

     

       101
       101
       +
               enable = true;

     

       102
       102
       +
               ensureDatabases = [ cfg.settings.database.database ];

     

       103
       103
       +
               ensureUsers = [{

     

       104
       104
       +
                 name = cfg.settings.database.user;

     

       105
       105
       +
                 ensurePermissions."DATABASE ${cfg.settings.database.database}" = "ALL PRIVILEGES";

     

       106
       106
       +
               }];

     

       105
       107
        
             };

     

       106
       108
        
       

     

       107
       109
        
             services.pict-rs.enable = true;

     
···

       141
       143
        
             };

     

       142
       144
        
       

     

       143
       145
        
             assertions = [{

     

       144
       144
       -
               assertion = cfg.database.createLocally -> localPostgres;

     

       146
       146
       +
               assertion = cfg.database.createLocally -> cfg.settings.database.host == "localhost" || cfg.settings.database.host == "/run/postgresql";

     

       145
       147
        
               message = "if you want to create the database locally, you need to use a local database";

     

       146
       148
        
             }];

     

       147
       149
        
       

     
···

       162
       164
        
       

     

       163
       165
        
               wantedBy = [ "multi-user.target" ];

     

       164
       166
        
       

     

       165
       165
       -
               after = [ "pict-rs.service" ] ++ lib.optionals cfg.database.createLocally [ "lemmy-postgresql.service" ];

     

       167
       167
       +
               after = [ "pict-rs.service" ] ++ lib.optionals cfg.database.createLocally [ "postgresql.service" ];

     

       166
       168
        
       

     

       167
       167
       -
               requires = lib.optionals cfg.database.createLocally [ "lemmy-postgresql.service" ];

     

       169
       169
       +
               requires = lib.optionals cfg.database.createLocally [ "postgresql.service" ];

     

       168
       170
        
       

     

       169
       171
        
               serviceConfig = {

     

       170
       172
        
                 DynamicUser = true;

     
···

       199
       201
        
                 DynamicUser = true;

     

       200
       202
        
                 WorkingDirectory = "${pkgs.lemmy-ui}";

     

       201
       203
        
                 ExecStart = "${pkgs.nodejs}/bin/node ${pkgs.lemmy-ui}/dist/js/server.js";

     

       202
       202
       -
               };

     

       203
       203
       -
             };

     

       204
       204
       -
       

     

       205
       205
       -
             systemd.services.lemmy-postgresql = mkIf cfg.database.createLocally {

     

       206
       206
       -
               description = "Lemmy postgresql db";

     

       207
       207
       -
               after = [ "postgresql.service" ];

     

       208
       208
       -
               partOf = [ "lemmy.service" ];

     

       209
       209
       -
               script = with cfg.settings.database; ''

     

       210
       210
       -
                 PSQL() {

     

       211
       211
       -
                   ${config.services.postgresql.package}/bin/psql --port=${toString cfg.settings.database.port} "$@"

     

       212
       212
       -
                 }

     

       213
       213
       -
                 # check if the database already exists

     

       214
       214
       -
                 if ! PSQL -lqt | ${pkgs.coreutils}/bin/cut -d \| -f 1 | ${pkgs.gnugrep}/bin/grep -qw ${database} ; then

     

       215
       215
       -
                   PSQL -tAc "CREATE ROLE ${user} WITH LOGIN;"

     

       216
       216
       -
                   PSQL -tAc "CREATE DATABASE ${database} WITH OWNER ${user};"

     

       217
       217
       -
                 fi

     

       218
       218
       -
               '';

     

       219
       219
       -
               serviceConfig = {

     

       220
       220
       -
                 User = config.services.postgresql.superUser;

     

       221
       221
       -
                 Type = "oneshot";

     

       222
       222
       -
                 RemainAfterExit = true;

     

       223
       204
        
               };

     

       224
       205
        
             };

     

       225
       206
        
           };

+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/applications/audio/game-music-emu/default.nix pkgs/development/libraries/audio/game-music-emu/default.nix

···

       8
       8
        
           url = "https://bitbucket.org/mpyne/game-music-emu/downloads/${pname}-${version}.tar.xz";

     

       9
       9
        
           sha256 = "07857vdkak306d9s5g6fhmjyxk7vijzjhkmqb15s7ihfxx9lx8xb";

     

       10
       10
        
         };

     

       11
       11
       -
         cmakeFlags = lib.optionals stdenv.isDarwin [ "-DENABLE_UBSAN=OFF" ];

     

       11
       11
       +
         cmakeFlags = lib.optionals (stdenv.isDarwin || stdenv.hostPlatform.isMusl) [ "-DENABLE_UBSAN=OFF" ];

     

       12
       12
        
         nativeBuildInputs = [ cmake removeReferencesTo ];

     

       13
       13
        
       

     

       14
       14
        
         # It used to reference it, in the past, but thanks to the postFixup hook, now

+2 -2

pkgs/applications/misc/hugo/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "hugo";

     

       5
       5
       -
         version = "0.103.0";

     

       5
       5
       +
         version = "0.103.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "gohugoio";

     

       9
       9
        
           repo = pname;

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-X78wmxEjw2noOjOj3uujXZHsPOSdZJ4KPz4Ia5sOu3I=";

     

       11
       11
       +
           sha256 = "sha256-KSNBbSJROx65WxOd98XLLbbSDL0x4ESEKVIsrZV911k=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         vendorSha256 = "sha256-Y0+D5H7kWi+bacJm1pouYDPHnnSRPatOt6qPfkk92X4=";

+6 -1

pkgs/applications/networking/cluster/k3s/default.nix

···

       22
       22
        
       , zstd

     

       23
       23
        
       , yq-go

     

       24
       24
        
       , nixosTests

     

       25
       25
       +
       , pkgsBuildBuild

     

       25
       26
        
       }:

     

       26
       27
        
       

     

       27
       28
        
       with lib;

     
···

       240
       241
        
       

     

       241
       242
        
           substituteInPlace scripts/package-cli \

     

       242
       243
        
             --replace '"''${GO}" generate' \

     

       243
       243
       -
                       'GOFLAGS="" "''${GO}" generate'

     

       244
       244
       +
                       'GOFLAGS="" \

     

       245
       245
       +
                        GOOS="${pkgsBuildBuild.go.GOOS}" \

     

       246
       246
       +
                        GOARCH="${pkgsBuildBuild.go.GOARCH}" \

     

       247
       247
       +
                        CC="${pkgsBuildBuild.stdenv.cc}/bin/cc" \

     

       248
       248
       +
                        "''${GO}" generate'

     

       244
       249
        
         '';

     

       245
       250
        
       

     

       246
       251
        
         # Important utilities used by the kubelet, see

+3 -3

pkgs/applications/networking/cluster/kubebuilder/default.nix

···

       9
       9
        
       

     

       10
       10
        
       buildGoModule rec {

     

       11
       11
        
         pname = "kubebuilder";

     

       12
       12
       -
         version = "3.6.0";

     

       12
       12
       +
         version = "3.7.0";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "kubernetes-sigs";

     

       16
       16
        
           repo = "kubebuilder";

     

       17
       17
        
           rev = "v${version}";

     

       18
       18
       -
           sha256 = "sha256-WbFY1tBwq0DjJqM5ld7W9GkhPQDsGUQCwEe42XkJlfQ=";

     

       18
       18
       +
           sha256 = "sha256-nLjmz9OakBLTBWdYA6czgtJmCuP96abNwLcLZo+yZ48=";

     

       19
       19
        
         };

     

       20
       20
       -
         vendorSha256 = "sha256-tz0SHAl9SwppjA8s0m4gJOh6rf8F+kRc2HnNMjO+blQ=";

     

       20
       20
       +
         vendorSha256 = "sha256-xljLDwubwr6rZ/ZpW9/WithClaMo88ivlBhWFb0iAvo=";

     

       21
       21
        
       

     

       22
       22
        
         subPackages = ["cmd"];

     

       23
       23

+3 -3

pkgs/applications/networking/cluster/terraform/default.nix

···

       168
       168
        
         mkTerraform = attrs: pluggable (generic attrs);

     

       169
       169
        
       

     

       170
       170
        
         terraform_1 = mkTerraform {

     

       171
       171
       -
           version = "1.2.9";

     

       172
       172
       -
           sha256 = "sha256-Q5AJiFnbHXhIJP06SCJNvuMKGwEJUOsmueCI7QCeQlk=";

     

       173
       173
       -
           vendorSha256 = "sha256-VKJ+aWZYD6N8HDJwUEtgWxoBMGOa27K9ze2RUJvuipc=";

     

       171
       171
       +
           version = "1.3.0";

     

       172
       172
       +
           sha256 = "1bl2d1wzarhglfc2vxg4m080d6z5mm35h3i4vg7n93wj9x3wkkq8";

     

       173
       173
       +
           vendorSha256 = "1kjbrwn6k0fycal8g189pda1w3qyjzfk2qjvm1fyj60dr155gncw";

     

       174
       174
        
           patches = [ ./provider-path-0_15.patch ];

     

       175
       175
        
           passthru = {

     

       176
       176
        
             inherit plugins;

+2 -2

pkgs/applications/networking/mailreaders/thunderbird/packages.nix

···

       39
       39
        
         };

     

       40
       40
        
         thunderbird-102 = (buildMozillaMach rec {

     

       41
       41
        
           pname = "thunderbird";

     

       42
       42
       -
           version = "102.2.2";

     

       42
       42
       +
           version = "102.3.0";

     

       43
       43
        
           application = "comm/mail";

     

       44
       44
        
           applicationName = "Mozilla Thunderbird";

     

       45
       45
        
           binaryName = pname;

     

       46
       46
        
           src = fetchurl {

     

       47
       47
        
             url = "mirror://mozilla/thunderbird/releases/${version}/source/thunderbird-${version}.source.tar.xz";

     

       48
       48
       -
             sha512 = "fe72ddb81d35d4a85b25a6d955a0b0f705aeda2dca0f572efca7ce94041c4ddcead6c690bda8d4bded4c43e12a15669f9608db6debec38d8b5157a914e280db5";

     

       48
       48
       +
             sha512 = "9b9908d9f7b1281df5b2c74a25211973e25d9b780f05b9550c89e5aeb8b39070c517a1a33d0d84a33ed26dbcef99058308b76c056bd4e34987c32f0600e3882e";

     

       49
       49
        
           };

     

       50
       50
        
           extraPatches = [

     

       51
       51
        
             # The file to be patched is different from firefox's `no-buildconfig-ffx90.patch`.

+4 -4

pkgs/data/misc/hackage/pin.json

···

       1
       1
        
       {

     

       2
       2
       -
         "commit": "d921dcbcb495c59ebdd949f1b70c00d0b0dfbc34",

     

       3
       3
       -
         "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/d921dcbcb495c59ebdd949f1b70c00d0b0dfbc34.tar.gz",

     

       4
       4
       -
         "sha256": "1kdb392fhm2jvf3rsznx2gzwqki978bj3dpmpjfjxqadbzz9cl34",

     

       5
       5
       -
         "msg": "Update from Hackage at 2022-09-11T02:31:18Z"

     

       2
       2
       +
         "commit": "e456824564bb5457549a70dc03c7ae00b3dfaec3",

     

       3
       3
       +
         "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/e456824564bb5457549a70dc03c7ae00b3dfaec3.tar.gz",

     

       4
       4
       +
         "sha256": "0kvjhghjhs5b6ldp4yyyy158lqk54aahqqp4n0mm67p7qv09i5xr",

     

       5
       5
       +
         "msg": "Update from Hackage at 2022-09-19T12:29:18Z"

     

       6
       6
        
       }

+21 -33

pkgs/desktops/xfce/panel-plugins/xfce4-windowck-plugin/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, pkg-config, intltool, python3, imagemagick, libwnck, libxfce4ui, xfce4-panel, xfconf, xfce4-dev-tools, xfce, gitUpdater }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , mkXfceDerivation

     

       3
       3
       +
       , imagemagick

     

       4
       4
       +
       , libwnck

     

       5
       5
       +
       , libxfce4ui

     

       6
       6
       +
       , python3

     

       7
       7
       +
       , xfce4-panel

     

       8
       8
       +
       , xfconf

     

       9
       9
       +
       }:

     

       2
       10
        
       

     

       3
       3
       -
       stdenv.mkDerivation rec {

     

       4
       4
       -
         pname  = "xfce4-windowck-plugin";

     

       5
       5
       -
         version = "0.4.10";

     

       6
       6
       -
       

     

       7
       7
       -
         src = fetchFromGitHub {

     

       8
       8
       -
           owner = "invidian";

     

       9
       9
       -
           repo = pname;

     

       10
       10
       -
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-luCQzqWX3Jl2MlBa3vi1q7z1XOhpFxE8PUxscoIyBlA=";

     

       12
       12
       -
         };

     

       13
       13
       -
       

     

       14
       14
       -
         nativeBuildInputs = [

     

       15
       15
       -
           pkg-config

     

       16
       16
       -
           intltool

     

       17
       17
       -
         ];

     

       11
       11
       +
       mkXfceDerivation {

     

       12
       12
       +
         category = "panel-plugins";

     

       13
       13
       +
         pname = "xfce4-windowck-plugin";

     

       14
       14
       +
         version = "0.5.0";

     

       15
       15
       +
         rev-prefix = "v";

     

       16
       16
       +
         odd-unstable = false;

     

       17
       17
       +
         sha256 = "sha256-MhNSgI74VLdoS5yL6nfRrVrPvv7+0P5meO4zQheYFzo=";

     

       18
       18
        
       

     

       19
       19
        
         buildInputs = [

     

       20
       20
       -
           python3

     

       21
       20
        
           imagemagick

     

       22
       21
        
           libwnck

     

       23
       22
        
           libxfce4ui

     

       23
       23
       +
           python3

     

       24
       24
        
           xfce4-panel

     

       25
       25
        
           xfconf

     

       26
       26
       -
           xfce4-dev-tools

     

       27
       26
        
         ];

     

       28
       27
        
       

     

       29
       29
       -
         preConfigure = ''

     

       30
       30
       -
           ./autogen.sh

     

       31
       31
       -
           patchShebangs .

     

       28
       28
       +
         postPatch = ''

     

       29
       29
       +
           patchShebangs themes/windowck{,-dark}/{xfwm4,unity}/generator.py

     

       32
       30
        
         '';

     

       33
       31
        
       

     

       34
       34
       -
         enableParallelBuilding = true;

     

       35
       35
       -
       

     

       36
       36
       -
         passthru.updateScript = gitUpdater {

     

       37
       37
       -
           inherit pname version;

     

       38
       38
       -
           attrPath = "xfce.${pname}";

     

       39
       39
       -
           rev-prefix = "v";

     

       40
       40
       -
         };

     

       41
       41
       -
       

     

       42
       32
        
         meta = with lib; {

     

       43
       43
       -
           homepage = "https://goodies.xfce.org/projects/panel-plugins/xfce4-windowck-plugin";

     

       44
       44
       -
           description = "Xfce plugins which allows to put the maximized window title and buttons on the panel";

     

       45
       45
       -
           license = licenses.gpl2Plus;

     

       46
       46
       -
           platforms = platforms.unix;

     

       33
       33
       +
           description = "Xfce panel plugin for displaying window title and buttons";

     

       34
       34
       +
           license = licenses.gpl3Plus;

     

       47
       35
        
           maintainers = with maintainers; [ ] ++ teams.xfce.members;

     

       48
       36
        
         };

     

       49
       37
        
       }

+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: {

+49 -73

pkgs/development/haskell-modules/configuration-common.nix

···

       817
       817
        
         # requires git at test-time *and* runtime, but we'll just rely on users to

     

       818
       818
        
         # bring their own git at runtime

     

       819
       819
        
         sensei = overrideCabal (drv: {

     

       820
       820
       -
           testHaskellDepends = drv.testHaskellDepends or [] ++ [ self.hspec-meta_2_9_3 ];

     

       820
       820
       +
           testHaskellDepends = drv.testHaskellDepends or [] ++ [ self.hspec-meta_2_10_5 ];

     

       821
       821
        
           testToolDepends = drv.testToolDepends or [] ++ [ pkgs.git ];

     

       822
       822
        
         }) (super.sensei.override {

     

       823
       823
       -
           hspec = self.hspec_2_10_5;

     

       823
       823
       +
           hspec = self.hspec_2_10_6;

     

       824
       824
        
           hspec-wai = super.hspec-wai.override {

     

       825
       825
       -
             hspec = self.hspec_2_10_5;

     

       825
       825
       +
             hspec = self.hspec_2_10_6;

     

       826
       826
        
           };

     

       827
       827
        
         });

     

       828
       828
        
       

     
···

       1010
       1010
        
         # https://github.com/haskell-hvr/hgettext/issues/14

     

       1011
       1011
        
         hgettext = doJailbreak super.hgettext;

     

       1012
       1012
        
       

     

       1013
       1013
       -
         # Generate shell completion.

     

       1014
       1014
       -
         cabal2nix = generateOptparseApplicativeCompletion "cabal2nix" super.cabal2nix;

     

       1015
       1015
       -
       

     

       1016
       1016
       -
         ormolu = generateOptparseApplicativeCompletion "ormolu" super.ormolu;

     

       1017
       1017
       -
       

     

       1018
       1013
        
         stack =

     

       1019
       1014
        
           generateOptparseApplicativeCompletion "stack"

     

       1020
       1020
       -
             (doJailbreak # for Cabal constraint added on hackage

     

       1021
       1021
       -
               (appendPatch

     

       1022
       1022
       -
                 (fetchpatch {

     

       1023
       1023
       -
                   # https://github.com/commercialhaskell/stack/pull/5559

     

       1024
       1024
       -
                   # When removing, also remove doJailbreak.

     

       1025
       1025
       -
                   name = "stack-pull-5559.patch";

     

       1026
       1026
       -
                   url = "https://github.com/hercules-ci/stack/compare/v2.7.5...brandon-leapyear/chinn/cabal-0.patch";

     

       1027
       1027
       -
                   sha256 = "sha256-OXmdGgQ2KSKtQKOK6eePLgvUOTlzac544HQYKJpcjnU=";

     

       1028
       1028
       -
                 })

     

       1015
       1015
       +
             # stack has a bunch of constraints in its .cabal file that don't seem to be necessary

     

       1016
       1016
       +
             (doJailbreak

     

       1029
       1017
        
                 (super.stack.overrideScope (self: super: {

     

       1030
       1030
       -
                   # stack 2.7.5 requires aeson <= 1.6.

     

       1031
       1031
       -
                   aeson = self.aeson_1_5_6_0;

     

       1032
       1032
       -
                 }))

     

       1033
       1033
       -
             ));

     

       1018
       1018
       +
                   # Needs Cabal-3.6

     

       1019
       1019
       +
                   Cabal = self.Cabal_3_6_3_0;

     

       1020
       1020
       +
                 })));

     

       1034
       1021
        
       

     

       1035
       1022
        
         # Too strict version bound on hashable-time.

     

       1036
       1023
        
         # Tests require newer package version.

     
···

       1299
       1286
        
         # upstream: https://github.com/obsidiansystems/which/pull/6

     

       1300
       1287
        
         which = doJailbreak super.which;

     

       1301
       1288
        
       

     

       1302
       1302
       -
         # the test suite attempts to run the binaries built in this package

     

       1303
       1303
       -
         # through $PATH but they aren't in $PATH

     

       1304
       1304
       -
         dhall-lsp-server = dontCheck super.dhall-lsp-server;

     

       1305
       1305
       -
       

     

       1306
       1289
        
         # https://github.com/ocharles/weeder/issues/15

     

       1307
       1290
        
         weeder = doJailbreak super.weeder;

     

       1291
       1291
       +
       

     

       1292
       1292
       +
         # 2022-09-20: We have overridden lsp to not be the stackage version.

     

       1293
       1293
       +
         # dhall-lsp-server needs the older 1.4.0.0 lsp

     

       1294
       1294
       +
         dhall-lsp-server = super.dhall-lsp-server.override {

     

       1295
       1295
       +
           lsp = dontCheck (super.lsp_1_4_0_0.override {

     

       1296
       1296
       +
             lsp-types = super.lsp-types_1_4_0_1;

     

       1297
       1297
       +
           });

     

       1298
       1298
       +
         };

     

       1308
       1299
        
       

     

       1309
       1300
        
         # Requested version bump on upstream https://github.com/obsidiansystems/constraints-extras/issues/32

     

       1310
       1301
        
         constraints-extras = doJailbreak super.constraints-extras;

     
···

       1531
       1522
        
           })

     

       1532
       1523
        
         ] super.binary-strict;

     

       1533
       1524
        
       

     

       1534
       1534
       -
         # 2020-11-19: Checks nearly fixed, but still disabled because of flaky tests:

     

       1535
       1535
       -
         # https://github.com/haskell/haskell-language-server/issues/610

     

       1536
       1536
       -
         # https://github.com/haskell/haskell-language-server/issues/611

     

       1537
       1537
       -
         haskell-language-server = lib.pipe super.haskell-language-server [

     

       1525
       1525
       +
         haskell-language-server = (lib.pipe super.haskell-language-server [

     

       1538
       1526
        
           dontCheck

     

       1539
       1539
       -
           (appendConfigureFlags ["-ftactics"])

     

       1540
       1540
       -
           (overrideCabal (old: {

     

       1541
       1541
       -
             libraryHaskellDepends = old.libraryHaskellDepends ++ [

     

       1542
       1542
       -
               super.hls-tactics-plugin

     

       1543
       1543
       -
             ];

     

       1544
       1544
       -
           }))

     

       1545
       1545
       -
         ];

     

       1527
       1527
       +
           (disableCabalFlag "stan") # Sorry stan is totally unmaintained and terrible to get to run. It only works on ghc 8.8 or 8.10 anyways …

     

       1528
       1528
       +
         ]).overrideScope (lself: lsuper: {

     

       1529
       1529
       +
           ormolu = doJailbreak lself.ormolu_0_5_0_1;

     

       1530
       1530
       +
           fourmolu = doJailbreak lself.fourmolu_0_8_2_0;

     

       1531
       1531
       +
           hlint = enableCabalFlag "ghc-lib" lself.hlint_3_4_1;

     

       1532
       1532
       +
           ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;

     

       1533
       1533
       +
           ghc-lib-parser = lself.ghc-lib-parser_9_2_4_20220729;

     

       1534
       1534
       +
         });

     

       1546
       1535
        
       

     

       1547
       1547
       -
         lsp = assert super.lsp.version == "1.4.0.0"; dontCheck super.lsp;

     

       1536
       1536
       +
         hls-hlint-plugin = super.hls-hlint-plugin.overrideScope (lself: lsuper: {

     

       1537
       1537
       +
           # For "ghc-lib" flag see https://github.com/haskell/haskell-language-server/issues/3185#issuecomment-1250264515

     

       1538
       1538
       +
           hlint = enableCabalFlag "ghc-lib" lself.hlint_3_4_1;

     

       1539
       1539
       +
           ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;

     

       1540
       1540
       +
           ghc-lib-parser = lself.ghc-lib-parser_9_2_4_20220729;

     

       1541
       1541
       +
         });

     

       1542
       1542
       +
       

     

       1543
       1543
       +
         # For -f-auto see cabal.project in haskell-language-server.

     

       1544
       1544
       +
         ghc-lib-parser-ex_9_2_0_4 = disableCabalFlag "auto" (super.ghc-lib-parser-ex_9_2_0_4.override {

     

       1545
       1545
       +
           ghc-lib-parser = self.ghc-lib-parser_9_2_4_20220729;

     

       1546
       1546
       +
         });

     

       1548
       1547
        
       

     

       1549
       1548
        
         # 2021-05-08: Tests fail: https://github.com/haskell/haskell-language-server/issues/1809

     

       1550
       1549
        
         hls-eval-plugin = dontCheck super.hls-eval-plugin;

     
···

       1564
       1563
        
         # 2021-11-20: Testsuite hangs.

     

       1565
       1564
        
         # https://github.com/haskell/haskell-language-server/issues/2375

     

       1566
       1565
        
         hls-pragmas-plugin = dontCheck super.hls-pragmas-plugin;

     

       1566
       1566
       +
       

     

       1567
       1567
       +
         # 2022-09-19: https://github.com/haskell/haskell-language-server/issues/3200

     

       1568
       1568
       +
         hls-refactor-plugin = dontCheck super.hls-refactor-plugin;

     

       1567
       1569
        
       

     

       1568
       1570
        
         # 2021-03-21: Test hangs

     

       1569
       1571
        
         # https://github.com/haskell/haskell-language-server/issues/1562

     
···

       1642
       1644
        
         servant-openapi3 = dontCheck super.servant-openapi3;

     

       1643
       1645
        
       

     

       1644
       1646
        
         # Give hspec 2.10.* correct dependency versions without overrideScope

     

       1645
       1645
       -
         hspec_2_10_5 = doDistribute (super.hspec_2_10_5.override {

     

       1646
       1646
       -
           hspec-discover = self.hspec-discover_2_10_5;

     

       1647
       1647
       -
           hspec-core = self.hspec-core_2_10_5;

     

       1647
       1647
       +
         hspec_2_10_6 = doDistribute (super.hspec_2_10_6.override {

     

       1648
       1648
       +
           hspec-discover = self.hspec-discover_2_10_6;

     

       1649
       1649
       +
           hspec-core = self.hspec-core_2_10_6;

     

       1648
       1650
        
         });

     

       1649
       1649
       -
         hspec-discover_2_10_5 = super.hspec-discover_2_10_5.override {

     

       1650
       1650
       -
           hspec-meta = self.hspec-meta_2_9_3;

     

       1651
       1651
       +
         hspec-discover_2_10_6 = super.hspec-discover_2_10_6.override {

     

       1652
       1652
       +
           hspec-meta = self.hspec-meta_2_10_5;

     

       1651
       1653
        
         };

     

       1652
       1652
       -
         hspec-core_2_10_5 = super.hspec-core_2_10_5.override {

     

       1653
       1653
       -
           hspec-meta = self.hspec-meta_2_9_3;

     

       1654
       1654
       +
         hspec-core_2_10_6 = super.hspec-core_2_10_6.override {

     

       1655
       1655
       +
           hspec-meta = self.hspec-meta_2_10_5;

     

       1654
       1656
        
         };

     

       1655
       1657
        
       

     

       1656
       1658
        
         # Point hspec 2.7.10 to correct dependencies

     
···

       2109
       2111
        
         # https://github.com/plow-technologies/hspec-golden-aeson/issues/17

     

       2110
       2112
        
         hspec-golden-aeson = dontCheck super.hspec-golden-aeson;

     

       2111
       2113
        
       

     

       2112
       2112
       -
         # 2021-11-05: jailBreak the too tight upper bound on haskus-utils-variant

     

       2113
       2113
       -
         ghcup = doJailbreak (super.ghcup.overrideScope (self: super: {

     

       2114
       2114
       -
           Cabal = self.Cabal_3_6_3_0;

     

       2115
       2115
       -
         }));

     

       2116
       2116
       -
       

     

       2117
       2114
        
         # 2022-03-21: Newest stylish-haskell needs ghc-lib-parser-9_2

     

       2118
       2115
        
         stylish-haskell = (super.stylish-haskell.override {

     

       2119
       2119
       -
           ghc-lib-parser = super.ghc-lib-parser_9_2_4_20220729;

     

       2120
       2120
       -
           ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_1_1;

     

       2121
       2121
       -
         });

     

       2122
       2122
       -
       

     

       2123
       2123
       -
         ghc-lib-parser-ex_9_2_1_1 = super.ghc-lib-parser-ex_9_2_1_1.override {

     

       2124
       2124
       -
           ghc-lib-parser = super.ghc-lib-parser_9_2_4_20220729;

     

       2125
       2125
       -
         };

     

       2126
       2126
       -
       

     

       2127
       2127
       -
         ghc-lib-parser-ex_9_2_0_4 = super.ghc-lib-parser-ex_9_2_0_4.override {

     

       2128
       2128
       -
           ghc-lib-parser = super.ghc-lib-parser_9_2_4_20220729;

     

       2129
       2129
       -
         };

     

       2130
       2130
       -
       

     

       2131
       2131
       -
         hlint_3_4_1 = doDistribute (super.hlint_3_4_1.override {

     

       2116
       2116
       +
           ghc-lib-parser = self.ghc-lib-parser_9_2_4_20220729;

     

       2132
       2117
        
           ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;

     

       2133
       2118
        
         });

     

       2134
       2119
        
       

     
···

       2158
       2143
        
       

     

       2159
       2144
        
         # 2021-08-18: streamly-posix was released with hspec 2.8.2, but it works with older versions too.

     

       2160
       2145
        
         streamly-posix = doJailbreak super.streamly-posix;

     

       2161
       2161
       -
       

     

       2162
       2162
       -
         # Not running the "example" test because it requires a binary from lsps test

     

       2163
       2163
       -
         # suite which is not part of the output of lsp.

     

       2164
       2164
       -
         lsp-test = overrideCabal (old: { testTarget = "tests func-test"; }) super.lsp-test;

     

       2165
       2146
        
       

     

       2166
       2147
        
         # 2021-09-14: Tests are flaky.

     

       2167
       2148
        
         hls-splice-plugin = dontCheck super.hls-splice-plugin;

     
···

       2510
       2491
        
         # has been resolved.

     

       2511
       2492
        
         lucid-htmx = doJailbreak super.lucid-htmx;

     

       2512
       2493
        
       

     

       2513
       2513
       -
         lsp_1_5_0_0 = doDistribute (super.lsp_1_5_0_0.override {

     

       2514
       2514
       -
           lsp-types = self.lsp-types_1_5_0_0;

     

       2515
       2515
       -
         });

     

       2516
       2516
       -
       

     

       2517
       2517
       -
         futhark = super.futhark.override {

     

       2518
       2518
       -
           lsp = self.lsp_1_5_0_0;

     

       2519
       2519
       -
         };

     

       2494
       2494
       +
         # 2022-09-20: Restrictive upper bound on lsp

     

       2495
       2495
       +
         futhark = doJailbreak super.futhark;

     

       2520
       2496
        
       

     

       2521
       2497
        
         # Too strict bounds on hspec

     

       2522
       2498
        
         # https://github.com/klapaucius/vector-hashtables/issues/11

+11 -22

pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix

···

       96
       96
        
             executableHaskellDepends = drv.executableToolDepends or [] ++ [ self.repline ];

     

       97
       97
        
           }) super.hnix);

     

       98
       98
        
       

     

       99
       99
       -
         mime-string = disableOptimization super.mime-string;

     

       99
       99
       +
         haskell-language-server = addBuildDepend self.hls-brittany-plugin (super.haskell-language-server.overrideScope (lself: lsuper: {

     

       100
       100
       +
           Cabal = lself.Cabal_3_6_3_0;

     

       101
       101
       +
           aeson = lself.aeson_1_5_6_0;

     

       102
       102
       +
           lsp-types = doJailbreak lsuper.lsp-types; # Checks require aeson >= 2.0

     

       103
       103
       +
         }));

     

       100
       104
        
       

     

       101
       101
       -
         # Older compilers need the latest ghc-lib to build this package.

     

       102
       102
       -
         # Fix build with ghc-lib >= 9.0 and ghc <= 8.10.7

     

       103
       103
       -
         # https://github.com/haskell/haskell-language-server/issues/2728

     

       104
       104
       -
         hls-hlint-plugin = addBuildDepend self.ghc-lib (appendPatch (pkgs.fetchpatch {

     

       105
       105
       -
           name = "hls-hlint-plugin-workaround.patch";

     

       106
       106
       -
           url = "https://github.com/haskell/haskell-language-server/pull/2854.patch";

     

       107
       107
       -
           hash = "sha256-bLGu0OQtXsmMF3rZM+R6k7bsZm4Vgf2r0ert5Wunong=";

     

       108
       108
       -
           stripLen = 2;

     

       109
       109
       -
           includes = ["src/Ide/Plugin/Hlint.hs"];

     

       110
       110
       -
         }) super.hls-hlint-plugin);

     

       105
       105
       +
         hls-brittany-plugin = super.hls-brittany-plugin.overrideScope (lself: lsuper: {

     

       106
       106
       +
           brittany = doJailbreak lself.brittany_0_13_1_2;

     

       107
       107
       +
           aeson = lself.aeson_1_5_6_0;

     

       108
       108
       +
           lsp-types = doJailbreak lsuper.lsp-types; # Checks require aeson >= 2.0

     

       109
       109
       +
         });

     

       111
       110
        
       

     

       112
       112
       -
         haskell-language-server = appendConfigureFlags [

     

       113
       113
       -
             "-f-stylishhaskell"

     

       114
       114
       -
             "-f-brittany"

     

       115
       115
       -
           ]

     

       116
       116
       -
         super.haskell-language-server;

     

       117
       117
       -
       

     

       118
       118
       -
         # has a restrictive lower bound on Cabal

     

       119
       119
       -
         fourmolu = doJailbreak super.fourmolu;

     

       120
       120
       -
       

     

       121
       121
       -
         # ormolu 0.3 requires Cabal == 3.4

     

       122
       122
       -
         ormolu = super.ormolu_0_2_0_0;

     

       111
       111
       +
         mime-string = disableOptimization super.mime-string;

     

       123
       112
        
       

     

       124
       113
        
         # weeder 2.3.0 no longer supports GHC 8.10

     

       125
       114
        
         weeder = doDistribute (doJailbreak self.weeder_2_2_0);

+23 -13

pkgs/development/haskell-modules/configuration-ghc-8.8.x.nix

···

       141
       141
        
       

     

       142
       142
        
         mime-string = disableOptimization super.mime-string;

     

       143
       143
        
       

     

       144
       144
       -
         # Older compilers need the latest ghc-lib to build this package.

     

       145
       145
       -
         hls-hlint-plugin = addBuildDepend self.ghc-lib (overrideCabal (drv: {

     

       146
       146
       -
             # Workaround for https://github.com/haskell/haskell-language-server/issues/2728

     

       147
       147
       -
             postPatch = ''

     

       148
       148
       -
               sed -i 's/(GHC.RealSrcSpan x,/(GHC.RealSrcSpan x Nothing,/' src/Ide/Plugin/Hlint.hs

     

       149
       149
       -
             '';

     

       150
       150
       -
           })

     

       151
       151
       -
            super.hls-hlint-plugin);

     

       144
       144
       +
         haskell-language-server = addBuildDepend self.hls-brittany-plugin (super.haskell-language-server.overrideScope (lself: lsuper: {

     

       145
       145
       +
           ghc-lib-parser = lself.ghc-lib-parser_8_10_7_20220219;

     

       146
       146
       +
           ghc-lib-parser-ex = addBuildDepend lself.ghc-lib-parser lself.ghc-lib-parser-ex_8_10_0_24;

     

       147
       147
       +
           # Pick old ormolu and fourmolu because ghc-lib-parser is not compatible

     

       148
       148
       +
           ormolu = doJailbreak lself.ormolu_0_1_4_1;

     

       149
       149
       +
           fourmolu = doJailbreak lself.fourmolu_0_3_0_0;

     

       150
       150
       +
           hlint = lself.hlint_3_2_8;

     

       151
       151
       +
           aeson = lself.aeson_1_5_6_0;

     

       152
       152
       +
           stylish-haskell = lself.stylish-haskell_0_13_0_0;

     

       153
       153
       +
           lsp-types = doJailbreak lsuper.lsp-types;

     

       154
       154
       +
         }));

     

       152
       155
        
       

     

       153
       153
       -
         haskell-language-server = appendConfigureFlags [

     

       154
       154
       -
             "-f-stylishhaskell"

     

       155
       155
       -
             "-f-brittany"

     

       156
       156
       -
           ]

     

       157
       157
       -
         super.haskell-language-server;

     

       156
       156
       +
         hls-hlint-plugin = super.hls-hlint-plugin.overrideScope (lself: lsuper: {

     

       157
       157
       +
           # For "ghc-lib" flag see https://github.com/haskell/haskell-language-server/issues/3185#issuecomment-1250264515

     

       158
       158
       +
           hlint = lself.hlint_3_2_8;

     

       159
       159
       +
           ghc-lib-parser = lself.ghc-lib-parser_8_10_7_20220219;

     

       160
       160
       +
           ghc-lib-parser-ex = addBuildDepend lself.ghc-lib-parser lself.ghc-lib-parser-ex_8_10_0_24;

     

       161
       161
       +
         });

     

       162
       162
       +
       

     

       163
       163
       +
         hls-brittany-plugin = super.hls-brittany-plugin.overrideScope (lself: lsuper: {

     

       164
       164
       +
           brittany = doJailbreak lself.brittany_0_13_1_2;

     

       165
       165
       +
           aeson = lself.aeson_1_5_6_0;

     

       166
       166
       +
           lsp-types = doJailbreak lsuper.lsp-types;

     

       167
       167
       +
         });

     

       158
       168
        
       

     

       159
       169
        
         # has a restrictive lower bound on Cabal

     

       160
       170
        
         fourmolu = doJailbreak super.fourmolu;

pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix

···

       99
       99
        
           sha256 = "0rgzrq0513nlc1vw7nw4km4bcwn4ivxcgi33jly4a7n3c1r32v1f";

     

       100
       100
        
         }) (doJailbreak super.language-haskell-extract);

     

       101
       101
        
       

     

       102
       102
       +
         haskell-language-server = super.haskell-language-server.overrideScope (lself: lsuper: {

     

       103
       103
       +
           # Needed for modern ormolu and fourmolu.

     

       104
       104
       +
           # Apply this here and not in common, because other ghc versions offer different Cabal versions.

     

       105
       105
       +
           Cabal = lself.Cabal_3_6_3_0;

     

       106
       106
       +
         });

     

       107
       107
       +
       

     

       102
       108
        
         # The test suite depends on ChasingBottoms, which is broken with ghc-9.0.x.

     

       103
       109
        
         unordered-containers = dontCheck super.unordered-containers;

     

       104
       110

+13 -18

pkgs/development/haskell-modules/configuration-ghc-9.2.x.nix

···

       190
       190
        
           revision = null;

     

       191
       191
        
         } super.memory);

     

       192
       192
        
       

     

       193
       193
       -
         # Use hlint from git for GHC 9.2.1 support

     

       194
       194
       -
         hlint = self.hlint_3_4_1;

     

       193
       193
       +
         # For -fghc-lib see cabal.project in haskell-language-server.

     

       194
       194
       +
         stylish-haskell = enableCabalFlag "ghc-lib" super.stylish-haskell;

     

       195
       195
       +
       

     

       196
       196
       +
         # For "ghc-lib" flag see https://github.com/haskell/haskell-language-server/issues/3185#issuecomment-1250264515

     

       197
       197
       +
         hlint = doDistribute (enableCabalFlag "ghc-lib" (super.hlint_3_4_1.override {

     

       198
       198
       +
           ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;

     

       199
       199
       +
         }));

     

       195
       200
        
       

     

       196
       201
        
         # https://github.com/sjakobi/bsb-http-chunked/issues/38

     

       197
       202
        
         bsb-http-chunked = dontCheck super.bsb-http-chunked;

     
···

       201
       206
        
         jacinda = doDistribute super.jacinda;

     

       202
       207
        
         some = doJailbreak super.some;

     

       203
       208
        
       

     

       204
       204
       -
         # 2022-06-05: this is not the latest version of fourmolu because

     

       205
       205
       -
         # hls-fourmolu-plugin 1.0.3.0 doesn‘t support a newer one.

     

       206
       206
       -
         fourmolu = super.fourmolu_0_6_0_0;

     

       207
       207
       -
         # hls-fourmolu-plugin in this version has a to strict upper bound of fourmolu <= 0.5.0.0

     

       208
       208
       -
         hls-fourmolu-plugin = assert super.hls-fourmolu-plugin.version == "1.0.3.0"; doJailbreak super.hls-fourmolu-plugin;

     

       209
       209
       +
         fourmolu = super.fourmolu_0_8_2_0;

     

       209
       210
        
       

     

       210
       210
       -
         hls-ormolu-plugin = assert super.hls-ormolu-plugin.version == "1.0.2.1"; doJailbreak super.hls-ormolu-plugin;

     

       211
       211
        
         implicit-hie-cradle = doJailbreak super.implicit-hie-cradle;

     

       212
       212
        
         # 1.3 introduced support for GHC 9.2.x, so when this assert fails, the jailbreak can be removed

     

       213
       213
        
         hashtables = assert super.hashtables.version == "1.2.4.2"; doJailbreak super.hashtables;

     
···

       215
       215
        
         # 2022-08-01: Tests are broken on ghc 9.2.4: https://github.com/wz1000/HieDb/issues/46

     

       216
       216
        
         hiedb = doJailbreak (dontCheck super.hiedb);

     

       217
       217
        
       

     

       218
       218
       +
         apply-refact = doDistribute super.apply-refact_0_10_0_0;

     

       219
       219
       +
       

     

       218
       220
        
         # 2022-02-05: The following plugins don‘t work yet on ghc9.2.

     

       219
       221
        
         # Compare: https://haskell-language-server.readthedocs.io/en/latest/supported-versions.html

     

       220
       220
       -
         haskell-language-server = overrideCabal (old: {libraryHaskellDepends = builtins.filter (x: x != super.hls-tactics-plugin) old.libraryHaskellDepends;})

     

       221
       221
       -
           (appendConfigureFlags [

     

       222
       222
       -
           "-f-haddockComments"

     

       223
       223
       -
           "-f-retrie"

     

       224
       224
       -
           "-f-splice"

     

       225
       225
       -
           "-f-tactics"

     

       226
       226
       -
         ] (super.haskell-language-server.override {

     

       222
       222
       +
         haskell-language-server = super.haskell-language-server.override {

     

       227
       223
        
           hls-haddock-comments-plugin = null;

     

       228
       228
       -
           hls-hlint-plugin = null;

     

       229
       229
       -
           hls-retrie-plugin = null;

     

       230
       224
        
           hls-splice-plugin = null;

     

       231
       231
       -
         }));

     

       225
       225
       +
           hls-tactics-plugin = null;

     

       226
       226
       +
         };

     

       232
       227
        
       

     

       233
       228
        
         # https://github.com/fpco/inline-c/pull/131

     

       234
       229
        
         inline-c-cpp =

+13

pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml

···

       1245
       1245
        
         - ebnf-bff

     

       1246
       1246
        
         - eccrypto-ed25519-bindings

     

       1247
       1247
        
         - ecma262

     

       1248
       1248
       +
         - ecta-plugin

     

       1248
       1249
        
         - ecu

     

       1249
       1250
        
         - eddie

     

       1250
       1251
        
         - ede

     
···

       1516
       1517
        
         - forbidden-fruit

     

       1517
       1518
        
         - fordo

     

       1518
       1519
        
         - forecast-io

     

       1520
       1520
       +
         - foreign

     

       1519
       1521
        
         - foreign-var

     

       1520
       1522
        
         - forest

     

       1521
       1523
        
         - forest-fire

     
···

       2233
       2235
        
         - HJVM

     

       2234
       2236
        
         - hkd-delta

     

       2235
       2237
        
         - hkd-lens

     

       2238
       2238
       +
         - hkd-records

     

       2236
       2239
        
         - hkt

     

       2237
       2240
        
         - hlbfgsb

     

       2238
       2241
        
         - hleap

     
···

       2250
       2253
        
         - hlongurl

     

       2251
       2254
        
         - hlrdb-core

     

       2252
       2255
        
         - hls-exactprint-utils

     

       2256
       2256
       +
         - hls-selection-range-plugin

     

       2257
       2257
       +
         - hls-stan-plugin

     

       2253
       2258
        
         - hlwm

     

       2254
       2259
        
         - hmarkup

     

       2255
       2260
        
         - hmatrix-banded

     
···

       2275
       2280
        
         - hnn

     

       2276
       2281
        
         - hnop

     

       2277
       2282
        
         - hoauth

     

       2283
       2283
       +
         - hoauth2-tutorial

     

       2278
       2284
        
         - hobbes

     

       2279
       2285
        
         - hobbits

     

       2280
       2286
        
         - hocilib

     
···

       3247
       3253
        
         - mios

     

       3248
       3254
        
         - MIP

     

       3249
       3255
        
         - mismi-s3-core

     

       3256
       3256
       +
         - miso-action-logger

     

       3250
       3257
        
         - miso-examples

     

       3251
       3258
        
         - mit-3qvpPyAi6mH

     

       3252
       3259
        
         - mix-arrows

     
···

       3756
       3763
        
         - Pathfinder

     

       3757
       3764
        
         - pathfindingcore

     

       3758
       3765
        
         - PathTree

     

       3766
       3766
       +
         - patrol

     

       3759
       3767
        
         - patronscraper

     

       3760
       3768
        
         - paypal-adaptive-hoops

     

       3761
       3769
        
         - paypal-api

     
···

       4321
       4329
        
         - reversi

     

       4322
       4330
        
         - ReviewBoard

     

       4323
       4331
        
         - rewrite-inspector

     

       4332
       4332
       +
         - rfc

     

       4324
       4333
        
         - rfc-prelude

     

       4325
       4334
        
         - r-glpk-phonetic-languages-ukrainian-durations

     

       4326
       4335
        
         - rhbzquery

     
···

       4927
       4936
        
         - SVD2HS

     

       4928
       4937
        
         - svfactor

     

       4929
       4938
        
         - svg-builder-fork

     

       4939
       4939
       +
         - svg-icons

     

       4940
       4940
       +
         - SvgIcons

     

       4930
       4941
        
         - svgutils

     

       4931
       4942
        
         - svm-light-utils

     

       4932
       4943
        
         - svm-simple

     
···

       5300
       5311
        
         - type-of-html-static

     

       5301
       5312
        
         - typeparams

     

       5302
       5313
        
         - type-prelude

     

       5314
       5314
       +
         - type-rig

     

       5303
       5315
        
         - types-compat

     

       5304
       5316
        
         - type-settheory

     

       5305
       5317
        
         - type-spine

     
···

       5308
       5320
        
         - typograffiti

     

       5309
       5321
        
         - typson-core

     

       5310
       5322
        
         - tyro

     

       5323
       5323
       +
         - tztime

     

       5311
       5324
        
         - uAgda

     

       5312
       5325
        
         - uberlast

     

       5313
       5326
        
         - ucam-webauth-types

+8 -2

pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml

···

       113
       113
        
         - dhall == 1.29.0                     # required for ats-pkg

     

       114
       114
        
         - dhall == 1.38.1                     # required for spago

     

       115
       115
        
         - doctest == 0.18.*                   # 2021-11-19: closest to stackage version for GHC 9.*

     

       116
       116
       -
         - fourmolu == 0.6.0.0                 # 2022-06-05: Last fourmolu version compatible with hls 1.7/ hls-fourmolu-plugin 1.0.3.0

     

       117
       116
        
         - ghc-api-compat == 8.10.7            # 2022-02-17: preserve for GHC 8.10.7

     

       118
       117
        
         - ghc-api-compat == 8.6               # 2021-09-07: preserve for GHC 8.8.4

     

       119
       118
        
         - ghc-lib == 8.10.7.*                 # 2022-02-17: preserve for GHC 8.10.7

     
···

       121
       120
        
         - ghc-lib-parser == 8.10.7.*          # 2022-02-17: preserve for GHC 8.10.7

     

       122
       121
        
         - ghc-lib-parser == 9.2.*             # 2022-02-17: preserve for GHC 9.2

     

       123
       122
        
         - ghc-lib-parser-ex == 8.10.*         # 2022-02-17: preserve for GHC 8.10.7

     

       124
       124
       -
         - ghc-lib-parser-ex == 9.2.*           # 2022-07-13: preserve for GHC 9.2

     

       123
       123
       +
         - ghc-lib-parser-ex == 9.2.*          # 2022-07-13: preserve for GHC 9.2

     

       125
       124
        
         - ghc-lib-parser-ex >= 9.2.0.3 && < 9.2.1 # 2022-07-13: needed by hlint 3.4.1

     

       126
       125
        
         - haddock == 2.23.*                   # required on GHC < 8.10.x

     

       127
       126
        
         - haddock-api == 2.23.*               # required on GHC < 8.10.x

     
···

       153
       152
        
         - basement < 0.0.15                   # 2022-08-30: last version to support GHC < 8.10

     

       154
       153
        
         - foundation < 0.0.29                 # 2022-08-30: last version to support GHC < 8.10

     

       155
       154
        
         - cabal-install-parsers < 0.5         # 2022-08-31: required by haskell-ci 0.14.3

     

       155
       155
       +
         - lsp == 1.4.0.0                      # 2022-09-18: need for dhall-lsp-server 1.1.2

     

       156
       156
       +
         - lsp-types == 1.4.0.1                # 2022-09-18: need for dhall-lsp-server 1.1.2

     

       157
       157
       +
         - stylish-haskell == 0.13.0.0         # 2022-09-19: needed for hls on ghc 8.8

     

       158
       158
       +
         - brittany == 0.13.1.2                # 2022-09-20: needed for hls on ghc 8.8

     

       159
       159
       +
         - fourmolu == 0.3.0.0                 # 2022-09-21: needed for hls on ghc 8.8

     

       160
       160
       +
         - ormolu == 0.1.4.1                   # 2022-09-21: needed for hls on ghc 8.8

     

       161
       161
       +
         - hlint == 3.2.8                      # 2022-09-21: needed for hls on ghc 8.8

     

       156
       162
        
       

     

       157
       163
        
       package-maintainers:

     

       158
       164
        
         abbradar:

+19 -23

pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml

···

       1
       1
       -
       # Stackage LTS 19.22

     

       1
       1
       +
       # Stackage LTS 19.23

     

       2
       2
        
       # This file is auto-generated by

     

       3
       3
        
       # maintainers/scripts/haskell/update-stackage.sh

     

       4
       4
        
       default-package-overrides:

     
···

       122
       122
        
         - aws-xray-client-persistent ==0.1.0.5

     

       123
       123
        
         - aws-xray-client-wai ==0.1.0.2

     

       124
       124
        
         - backtracking ==0.1.0

     

       125
       125
       -
         - bank-holidays-england ==0.2.0.7

     

       125
       125
       +
         - bank-holidays-england ==0.2.0.8

     

       126
       126
        
         - barbies ==2.0.3.1

     

       127
       127
        
         - barrier ==0.1.1

     

       128
       128
        
         - base16 ==0.3.2.0

     
···

       846
       846
        
         - genvalidity-bytestring ==1.0.0.0

     

       847
       847
        
         - genvalidity-containers ==1.0.0.0

     

       848
       848
        
         - genvalidity-criterion ==1.0.0.0

     

       849
       849
       -
         - genvalidity-hspec ==1.0.0.0

     

       849
       849
       +
         - genvalidity-hspec ==1.0.0.1

     

       850
       850
        
         - genvalidity-hspec-aeson ==1.0.0.0

     

       851
       851
        
         - genvalidity-hspec-binary ==1.0.0.0

     

       852
       852
        
         - genvalidity-hspec-cereal ==1.0.0.0

     
···

       962
       962
        
         - groups ==0.5.3

     

       963
       963
        
         - gtk2hs-buildtools ==0.13.8.3

     

       964
       964
        
         - gtk-sni-tray ==0.1.8.0

     

       965
       965
       -
         - gtk-strut ==0.1.3.0

     

       965
       965
       +
         - gtk-strut ==0.1.3.1

     

       966
       966
        
         - guarded-allocation ==0.0.1

     

       967
       967
        
         - hackage-cli ==0.0.3.6

     

       968
       968
        
         - hackage-db ==2.1.2

     
···

       1002
       1002
        
         - haskell-src-exts-util ==0.2.5

     

       1003
       1003
        
         - haskell-src-meta ==0.8.10

     

       1004
       1004
        
         - haskey-btree ==0.3.0.1

     

       1005
       1005
       -
         - haskintex ==0.8.0.0

     

       1005
       1005
       +
         - haskintex ==0.8.0.1

     

       1006
       1006
        
         - haskoin-core ==0.21.2

     

       1007
       1007
        
         - hasktags ==0.72.0

     

       1008
       1008
        
         - hasql ==1.5.1

     
···

       1048
       1048
        
         - hgeometry-combinatorial ==0.14

     

       1049
       1049
        
         - hid ==0.2.2

     

       1050
       1050
        
         - hidapi ==0.1.8

     

       1051
       1051
       -
         - hie-bios ==0.9.1

     

       1052
       1051
        
         - hi-file-parser ==0.1.3.0

     

       1053
       1052
        
         - higher-leveldb ==0.6.0.0

     

       1054
       1053
        
         - highlighting-kate ==0.6.4

     
···

       1309
       1308
        
         - irc-client ==1.1.2.2

     

       1310
       1309
        
         - irc-conduit ==0.3.0.5

     

       1311
       1310
        
         - irc-ctcp ==0.1.3.1

     

       1312
       1312
       -
         - isbn ==1.1.0.3

     

       1311
       1311
       +
         - isbn ==1.1.0.4

     

       1313
       1312
        
         - islink ==0.1.0.0

     

       1314
       1313
        
         - iso3166-country-codes ==0.20140203.8

     

       1315
       1314
        
         - iso639 ==0.1.0.3

     
···

       1330
       1329
        
         - json-feed ==2.0.0.4

     

       1331
       1330
        
         - jsonifier ==0.2.1.1

     

       1332
       1331
        
         - jsonpath ==0.2.1.0

     

       1333
       1333
       -
         - json-stream ==0.4.4.1

     

       1332
       1332
       +
         - json-stream ==0.4.4.2

     

       1334
       1333
        
         - JuicyPixels ==3.3.7

     

       1335
       1334
        
         - JuicyPixels-blurhash ==0.1.0.3

     

       1336
       1335
        
         - JuicyPixels-extra ==0.5.2

     
···

       1455
       1454
        
         - lpeg ==1.0.3

     

       1456
       1455
        
         - lrucache ==1.2.0.1

     

       1457
       1456
        
         - lrucaching ==0.3.3

     

       1458
       1458
       -
         - lsp ==1.4.0.0

     

       1459
       1459
       -
         - lsp-test ==0.14.0.2

     

       1460
       1460
       -
         - lsp-types ==1.4.0.1

     

       1461
       1457
        
         - lua ==2.1.0

     

       1462
       1458
        
         - lua-arbitrary ==1.0.1

     

       1463
       1459
        
         - lucid ==2.11.1

     
···

       1531
       1527
        
         - mighty-metropolis ==2.0.0

     

       1532
       1528
        
         - mime-mail ==0.5.1

     

       1533
       1529
        
         - mime-mail-ses ==0.4.3

     

       1534
       1534
       -
         - mime-types ==0.1.0.9

     

       1530
       1530
       +
         - mime-types ==0.1.1.0

     

       1535
       1531
        
         - minimal-configuration ==0.1.4

     

       1536
       1532
        
         - minimorph ==0.3.0.1

     

       1537
       1533
        
         - minio-hs ==1.6.0

     
···

       1857
       1853
        
         - polynomials-bernstein ==1.1.2

     

       1858
       1854
        
         - polyparse ==1.13

     

       1859
       1855
        
         - polysemy ==1.6.0.0

     

       1860
       1860
       -
         - polysemy-extra ==0.2.0.0

     

       1856
       1856
       +
         - polysemy-extra ==0.2.1.0

     

       1861
       1857
        
         - polysemy-fs ==0.1.0.0

     

       1862
       1858
        
         - polysemy-fskvstore ==0.1.1.0

     

       1863
       1859
        
         - polysemy-kvstore ==0.1.3.0

     

       1864
       1864
       -
         - polysemy-methodology ==0.2.1.0

     

       1860
       1860
       +
         - polysemy-methodology ==0.2.2.0

     

       1865
       1861
        
         - polysemy-path ==0.2.1.0

     

       1866
       1862
        
         - polysemy-plugin ==0.4.1.1

     

       1867
       1867
       -
         - polysemy-several ==0.1.0.0

     

       1863
       1863
       +
         - polysemy-several ==0.1.1.0

     

       1868
       1864
        
         - polysemy-socket ==0.0.2.0

     

       1869
       1865
        
         - polysemy-uncontrolled ==0.1.1.0

     

       1870
       1866
        
         - polysemy-video ==0.2.0.1

     
···

       1875
       1871
        
         - posix-paths ==0.3.0.0

     

       1876
       1872
        
         - possibly ==1.0.0.0

     

       1877
       1873
        
         - postgres-options ==0.2.0.0

     

       1878
       1878
       -
         - postgresql-binary ==0.12.4.4

     

       1874
       1874
       +
         - postgresql-binary ==0.12.5

     

       1879
       1875
        
         - postgresql-libpq ==0.9.4.3

     

       1880
       1876
        
         - postgresql-libpq-notify ==0.2.0.0

     

       1881
       1877
        
         - postgresql-migration ==0.2.1.3

     
···

       1954
       1950
        
         - pulse-simple ==0.1.14

     

       1955
       1951
        
         - pureMD5 ==2.1.4

     

       1956
       1952
        
         - purescript-bridge ==0.14.0.0

     

       1957
       1957
       -
         - pusher-http-haskell ==2.1.0.11

     

       1953
       1953
       +
         - pusher-http-haskell ==2.1.0.12

     

       1958
       1954
        
         - pvar ==1.0.0.0

     

       1959
       1955
        
         - PyF ==0.10.2.0

     

       1960
       1956
        
         - qchas ==1.1.0.1

     
···

       2119
       2115
        
         - sample-frame ==0.0.3

     

       2120
       2116
        
         - sample-frame-np ==0.0.4.1

     

       2121
       2117
        
         - sampling ==0.3.5

     

       2122
       2122
       -
         - sandwich ==0.1.0.10

     

       2118
       2118
       +
         - sandwich ==0.1.0.11

     

       2123
       2119
        
         - sandwich-quickcheck ==0.1.0.6

     

       2124
       2120
        
         - sandwich-slack ==0.1.0.6

     

       2125
       2121
        
         - say ==0.1.0.1

     
···

       2386
       2382
        
         - swagger2 ==2.8.4

     

       2387
       2383
        
         - swish ==0.10.2.0

     

       2388
       2384
        
         - syb ==0.7.2.1

     

       2389
       2389
       -
         - sydtest-discover ==0.0.0.1

     

       2385
       2385
       +
         - sydtest-discover ==0.0.0.2

     

       2390
       2386
        
         - symbol ==0.2.4

     

       2391
       2387
        
         - symengine ==0.1.2.0

     

       2392
       2388
        
         - symmetry-operations-symbols ==0.0.2.1

     
···

       2638
       2634
        
         - universum ==1.7.3

     

       2639
       2635
        
         - unix-bytestring ==0.3.7.8

     

       2640
       2636
        
         - unix-compat ==0.5.4

     

       2641
       2641
       -
         - unix-time ==0.4.7

     

       2637
       2637
       +
         - unix-time ==0.4.8

     

       2642
       2638
        
         - unliftio ==0.2.22.0

     

       2643
       2639
        
         - unliftio-core ==0.2.0.1

     

       2644
       2640
        
         - unliftio-path ==0.0.2.0

     
···

       2768
       2764
        
         - Win32-notify ==0.3.0.3

     

       2769
       2765
        
         - windns ==0.1.0.1

     

       2770
       2766
        
         - wire-streams ==0.1.1.0

     

       2771
       2771
       -
         - witch ==1.0.0.3

     

       2767
       2767
       +
         - witch ==1.0.0.4

     

       2772
       2768
        
       with-compiler: ghc-9.0.2

     

       2773
       2769
        
         - withdependencies ==0.3.0

     

       2774
       2770
        
         - witherable ==0.4.2

     
···

       2836
       2832
        
         - yaml-unscrambler ==0.1.0.9

     

       2837
       2833
        
         - yarn-lock ==0.6.5

     

       2838
       2834
        
         - yeshql-core ==4.2.0.0

     

       2839
       2839
       -
         - yesod ==1.6.2

     

       2835
       2835
       +
         - yesod ==1.6.2.1

     

       2840
       2836
        
         - yesod-alerts ==0.1.3.0

     

       2841
       2837
        
         - yesod-auth ==1.6.11

     

       2842
       2838
        
         - yesod-auth-basic ==0.1.0.3

     

       2843
       2839
        
         - yesod-auth-hashdb ==1.7.1.7

     

       2844
       2840
        
         - yesod-auth-oauth2 ==0.7.0.2

     

       2845
       2845
       -
         - yesod-bin ==1.6.2.1

     

       2841
       2841
       +
         - yesod-bin ==1.6.2.2

     

       2846
       2842
        
         - yesod-core ==1.6.24.0

     

       2847
       2843
        
         - yesod-eventsource ==1.6.0.1

     

       2848
       2844
        
         - yesod-form ==1.7.0

pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml

···

       940
       940
        
        - claferwiki

     

       941
       941
        
        - clash

     

       942
       942
        
        - classify-frog

     

       943
       943
       +
        - classy-miso

     

       943
       944
        
        - clckwrks

     

       944
       945
        
        - clckwrks-cli

     

       945
       946
        
        - clckwrks-dot-com

     
···

       2068
       2069
        
        - hipbot

     

       2069
       2070
        
        - hipsql-client

     

       2070
       2071
        
        - hipsql-server

     

       2072
       2072
       +
        - hipsql-tx-simple

     

       2071
       2073
        
        - hirt

     

       2072
       2074
        
        - hist-pl

     

       2073
       2075
        
        - hist-pl-dawg

     
···

       2204
       2206
        
        - hunt-searchengine

     

       2205
       2207
        
        - hunt-server

     

       2206
       2208
        
        - hurdle

     

       2209
       2209
       +
        - hurl-xml

     

       2207
       2210
        
        - huzzy

     

       2208
       2211
        
        - hw-all

     

       2209
       2212
        
        - hw-aws-sqs-conduit

     
···

       2680
       2683
        
        - monad-stlike-stm

     

       2681
       2684
        
        - monad-unlift-ref

     

       2682
       2685
        
        - monadiccp-gecode

     

       2686
       2686
       +
        - monadology

     

       2683
       2687
        
        - monarch

     

       2684
       2688
        
        - monetdb-mapi

     

       2685
       2689
        
        - mongrel2-handler

+22 -5

pkgs/development/haskell-modules/configuration-nix.nix

···

       96
       96
        
       

     

       97
       97
        
         # avoid compiling twice by providing executable as a separate output (with small closure size)

     

       98
       98
        
         niv = enableSeparateBinOutput (generateOptparseApplicativeCompletion "niv" super.niv);

     

       99
       99
       -
         ormolu = enableSeparateBinOutput super.ormolu;

     

       100
       99
        
         ghcid = enableSeparateBinOutput super.ghcid;

     

       100
       100
       +
         ormolu = generateOptparseApplicativeCompletion "ormolu" (enableSeparateBinOutput super.ormolu);

     

       101
       101
       +
       

     

       102
       102
       +
         # Generate shell completion.

     

       103
       103
       +
         cabal2nix = generateOptparseApplicativeCompletion "cabal2nix" super.cabal2nix;

     

       101
       104
        
       

     

       102
       105
        
         arbtt = overrideCabal (drv: {

     

       103
       106
        
           # The test suite needs the packages's executables in $PATH to succeed.

     
···

       495
       498
        
           librarySystemDepends = drv.librarySystemDepends or [] ++ [ pkgs.cyrus_sasl.dev ];

     

       496
       499
        
         }) super.LDAP);

     

       497
       500
        
       

     

       501
       501
       +
         # Not running the "example" test because it requires a binary from lsps test

     

       502
       502
       +
         # suite which is not part of the output of lsp.

     

       503
       503
       +
         lsp-test = overrideCabal (old: { testTarget = "tests func-test"; }) super.lsp-test;

     

       504
       504
       +
       

     

       505
       505
       +
         # the test suite attempts to run the binaries built in this package

     

       506
       506
       +
         # through $PATH but they aren't in $PATH

     

       507
       507
       +
         dhall-lsp-server = dontCheck super.dhall-lsp-server;

     

       508
       508
       +
       

     

       498
       509
        
         # Expects z3 to be on path so we replace it with a hard

     

       499
       510
        
         #

     

       500
       511
        
         # The tests expect additional solvers on the path, replace the

     
···

       676
       687
        
       

     

       677
       688
        
         # Tests access homeless-shelter.

     

       678
       689
        
         hie-bios = dontCheck super.hie-bios;

     

       679
       679
       -
         hie-bios_0_5_0 = dontCheck super.hie-bios_0_5_0;

     

       680
       690
        
       

     

       681
       691
        
         # Compiling the readme throws errors and has no purpose in nixpkgs

     

       682
       692
        
         aeson-gadt-th =

     
···

       933
       943
        
         }) super.procex;

     

       934
       944
        
       

     

       935
       945
        
         # Test suite wants to run main executable

     

       936
       936
       -
         fourmolu_0_7_0_1 = overrideCabal (drv: {

     

       946
       946
       +
         fourmolu_0_8_2_0 = overrideCabal (drv: {

     

       937
       947
        
           preCheck = drv.preCheck or "" + ''

     

       938
       948
        
             export PATH="$PWD/dist/build/fourmolu:$PATH"

     

       939
       949
        
           '';

     

       940
       940
       -
         }) super.fourmolu_0_7_0_1;

     

       950
       950
       +
         }) super.fourmolu_0_8_2_0;

     

       941
       951
        
       

     

       942
       952
        
         # Apply a patch which hardcodes the store path of graphviz instead of using

     

       943
       953
        
         # whatever graphviz is in PATH.

     
···

       1035
       1045
        
       

     

       1036
       1046
        
         keid-render-basic = addBuildTool pkgs.glslang super.keid-render-basic;

     

       1037
       1047
        
       

     

       1048
       1048
       +
         # ghcide-bench tests need network

     

       1049
       1049
       +
         ghcide-bench = dontCheck super.ghcide-bench;

     

       1050
       1050
       +
       

     

       1038
       1051
        
       # haskell-language-server plugins all use the same test harness so we give them what we want in this loop.

     

       1039
       1052
        
       } // pkgs.lib.mapAttrs

     

       1040
       1053
        
         (_: overrideCabal (drv: {

     
···

       1051
       1064
        
           hls-fourmolu-plugin

     

       1052
       1065
        
           hls-module-name-plugin

     

       1053
       1066
        
           hls-pragmas-plugin

     

       1054
       1054
       -
           hls-splice-plugin;

     

       1067
       1067
       +
           hls-splice-plugin

     

       1068
       1068
       +
           hls-refactor-plugin

     

       1069
       1069
       +
           hls-code-range-plugin

     

       1070
       1070
       +
           hls-explicit-fixity-plugin;

     

       1055
       1071
        
         # Tests have file permissions expections that don‘t work with the nix store.

     

       1056
       1072
        
         hls-stylish-haskell-plugin = dontCheck super.hls-stylish-haskell-plugin;

     

       1073
       1073
       +
         hls-gadt-plugin = dontCheck super.hls-gadt-plugin;

     

       1057
       1074
        
       

     

       1058
       1075
        
         # Flaky tests

     

       1059
       1076
        
         hls-hlint-plugin = dontCheck super.hls-hlint-plugin;

+1687 -911

pkgs/development/haskell-modules/hackage-packages.nix

···

       1351
       1351
        
            }) {};

     

       1352
       1352
        
       

     

       1353
       1353
        
         "BPS" = callPackage

     

       1354
       1354
       -
           ({ mkDerivation, base, extra, free, mtl, resourcet, STMonadTrans

     

       1355
       1355
       -
            , symbol, template-haskell, TLT, transformers

     

       1354
       1354
       +
           ({ mkDerivation, base, extra, free, MonadRandom, mtl, resourcet

     

       1355
       1355
       +
            , STMonadTrans, symbol, template-haskell, TLT, transformers

     

       1356
       1356
        
            }:

     

       1357
       1357
        
            mkDerivation {

     

       1358
       1358
        
              pname = "BPS";

     

       1359
       1359
       -
              version = "0.1.0.0";

     

       1360
       1360
       -
              sha256 = "0rkrjj42p9ybcifmsmz8717yyf2q3vzwm4y42khxz824vdxa9q2j";

     

       1359
       1359
       +
              version = "0.1.1.0";

     

       1360
       1360
       +
              sha256 = "0c310zldchyqhkqq2nsarqgkkxrqqcq62796mi0svsn9wk65rrf4";

     

       1361
       1361
        
              isLibrary = true;

     

       1362
       1362
        
              isExecutable = true;

     

       1363
       1363
        
              libraryHaskellDepends = [

     
···

       1365
       1365
        
                transformers

     

       1366
       1366
        
              ];

     

       1367
       1367
        
              executableHaskellDepends = [

     

       1368
       1368
       -
                base extra free mtl resourcet STMonadTrans symbol template-haskell

     

       1369
       1369
       -
                transformers

     

       1368
       1368
       +
                base extra free MonadRandom mtl resourcet STMonadTrans symbol

     

       1369
       1369
       +
                template-haskell transformers

     

       1370
       1370
        
              ];

     

       1371
       1371
        
              testHaskellDepends = [

     

       1372
       1372
        
                base extra free mtl resourcet STMonadTrans symbol template-haskell

     
···

       1375
       1375
        
              description = "Translations of classic Truth Maintenance Systems";

     

       1376
       1376
        
              license = lib.licenses.gpl3Only;

     

       1377
       1377
        
              hydraPlatforms = lib.platforms.none;

     

       1378
       1378
       -
              mainProgram = "hbps";

     

       1379
       1378
        
              broken = true;

     

       1380
       1379
        
            }) {};

     

       1381
       1380
        
       

     
···

       10074
       10073
        
              license = lib.licenses.lgpl21Only;

     

       10075
       10074
        
            }) {};

     

       10076
       10075
        
       

     

       10076
       10076
       +
         "HaXml_1_25_11" = callPackage

     

       10077
       10077
       +
           ({ mkDerivation, base, bytestring, containers, directory, filepath

     

       10078
       10078
       +
            , polyparse, pretty, random

     

       10079
       10079
       +
            }:

     

       10080
       10080
       +
            mkDerivation {

     

       10081
       10081
       +
              pname = "HaXml";

     

       10082
       10082
       +
              version = "1.25.11";

     

       10083
       10083
       +
              sha256 = "1l5kmiqvnqzdzz3jyaphy7ckglm6jhn0b10kf47yizv0w496bmjg";

     

       10084
       10084
       +
              isLibrary = true;

     

       10085
       10085
       +
              isExecutable = true;

     

       10086
       10086
       +
              libraryHaskellDepends = [

     

       10087
       10087
       +
                base bytestring containers filepath polyparse pretty random

     

       10088
       10088
       +
              ];

     

       10089
       10089
       +
              executableHaskellDepends = [ base directory polyparse pretty ];

     

       10090
       10090
       +
              description = "Utilities for manipulating XML documents";

     

       10091
       10091
       +
              license = lib.licenses.lgpl21Only;

     

       10092
       10092
       +
              hydraPlatforms = lib.platforms.none;

     

       10093
       10093
       +
            }) {};

     

       10094
       10094
       +
       

     

       10077
       10095
        
         "Hach" = callPackage

     

       10078
       10096
        
           ({ mkDerivation, base, containers, network, old-locale, text, time

     

       10079
       10097
        
            , vty, vty-ui

     
···

       13539
       13557
        
              pname = "MIP";

     

       13540
       13558
        
              version = "0.1.1.0";

     

       13541
       13559
        
              sha256 = "03gzwg0hzgij9hpxxfsrdxx2cknfy9fr9h1w1na04bmzpai1sl40";

     

       13542
       13542
       -
              revision = "1";

     

       13543
       13543
       -
              editedCabalFile = "0jm2g7g4js366i6i21d13f2gng7py4gkb3m64f76rdxbpqfcgfq1";

     

       13560
       13560
       +
              revision = "2";

     

       13561
       13561
       +
              editedCabalFile = "03kjzsyd3sy9iipdnac5ddpkq6v1cfpj0wh00r3yvcjgrk99ycip";

     

       13544
       13562
        
              libraryHaskellDepends = [

     

       13545
       13563
        
                base bytestring bytestring-encoding case-insensitive containers

     

       13546
       13564
        
                data-default-class extended-reals filepath intern lattices

     
···

       14533
       14551
        
           ({ mkDerivation, aeson, ansi-terminal, async, atomic-write, base

     

       14534
       14552
        
            , bytestring, bytestring-lexing, bzlib-conduit, conduit

     

       14535
       14553
        
            , conduit-algorithms, conduit-extra, configurator, containers

     

       14536
       14536
       -
            , convertible, criterion, data-default, deepseq, diagrams-core

     

       14537
       14537
       -
            , diagrams-lib, diagrams-svg, directory, double-conversion

     

       14538
       14538
       -
            , edit-distance, either, errors, exceptions, extra, file-embed

     

       14539
       14539
       -
            , filemanip, filepath, hashable, hashtables, hostname, http-client

     

       14540
       14540
       -
            , http-conduit, HUnit, inline-c, inline-c-cpp, int-interval-map

     

       14541
       14541
       -
            , MissingH, mtl, network, optparse-applicative, parsec, primitive

     

       14542
       14542
       -
            , process, QuickCheck, regex, resourcet, safe, safeio, stm

     

       14543
       14543
       -
            , stm-chans, stm-conduit, strict, tar, tar-conduit, tasty

     

       14544
       14544
       -
            , tasty-hunit, tasty-quickcheck, tasty-th, template-haskell, text

     

       14545
       14545
       -
            , time, transformers, unix, unix-compat, unliftio, unliftio-core

     

       14546
       14546
       -
            , vector, vector-algorithms, yaml, zlib

     

       14554
       14554
       +
            , convertible, criterion, data-default, deepseq, directory

     

       14555
       14555
       +
            , double-conversion, edit-distance, either, errors, exceptions

     

       14556
       14556
       +
            , extra, file-embed, filemanip, filepath, hashable, hashtables

     

       14557
       14557
       +
            , hostname, http-client, http-conduit, HUnit, inline-c

     

       14558
       14558
       +
            , inline-c-cpp, int-interval-map, MissingH, mtl, network

     

       14559
       14559
       +
            , optparse-applicative, parsec, primitive, process, QuickCheck

     

       14560
       14560
       +
            , random-shuffle, regex, resourcet, safe, safeio, stm, stm-chans

     

       14561
       14561
       +
            , stm-conduit, strict, tar, tar-conduit, tasty, tasty-hunit

     

       14562
       14562
       +
            , tasty-quickcheck, tasty-th, template-haskell, text, time

     

       14563
       14563
       +
            , transformers, unix, unix-compat, unliftio, unliftio-core, vector

     

       14564
       14564
       +
            , vector-algorithms, yaml, zlib

     

       14547
       14565
        
            }:

     

       14548
       14566
        
            mkDerivation {

     

       14549
       14567
        
              pname = "NGLess";

     

       14550
       14550
       -
              version = "1.4.2.0";

     

       14551
       14551
       -
              sha256 = "0578rjwi3xwikfaxha8yignr37adykqkbhspxds0c5bzwcw5zywh";

     

       14568
       14568
       +
              version = "1.5.0";

     

       14569
       14569
       +
              sha256 = "0pljyrlpr9r3cl5311dhgxdl8y40szyi4vprn34i3piy0qrldymi";

     

       14552
       14570
        
              isLibrary = true;

     

       14553
       14571
        
              isExecutable = true;

     

       14554
       14572
        
              libraryHaskellDepends = [

     

       14555
       14573
        
                aeson ansi-terminal async atomic-write base bytestring

     

       14556
       14574
        
                bytestring-lexing bzlib-conduit conduit conduit-algorithms

     

       14557
       14575
        
                conduit-extra configurator containers convertible data-default

     

       14558
       14558
       -
                deepseq diagrams-core diagrams-lib diagrams-svg directory

     

       14559
       14559
       -
                double-conversion edit-distance either errors exceptions extra

     

       14560
       14560
       -
                file-embed filemanip filepath hashable hashtables hostname

     

       14561
       14561
       -
                http-client http-conduit inline-c inline-c-cpp int-interval-map

     

       14562
       14562
       -
                MissingH mtl network optparse-applicative parsec primitive process

     

       14563
       14563
       -
                regex resourcet safe safeio stm stm-chans stm-conduit strict tar

     

       14564
       14564
       -
                tar-conduit template-haskell text time transformers unix

     

       14565
       14565
       -
                unix-compat unliftio unliftio-core vector vector-algorithms yaml

     

       14566
       14566
       -
                zlib

     

       14576
       14576
       +
                deepseq directory double-conversion edit-distance either errors

     

       14577
       14577
       +
                exceptions extra file-embed filemanip filepath hashable hashtables

     

       14578
       14578
       +
                hostname http-client http-conduit inline-c inline-c-cpp

     

       14579
       14579
       +
                int-interval-map MissingH mtl network optparse-applicative parsec

     

       14580
       14580
       +
                primitive process random-shuffle regex resourcet safe safeio stm

     

       14581
       14581
       +
                stm-chans stm-conduit strict tar tar-conduit template-haskell text

     

       14582
       14582
       +
                time transformers unix unix-compat unliftio unliftio-core vector

     

       14583
       14583
       +
                vector-algorithms yaml zlib

     

       14567
       14584
        
              ];

     

       14568
       14585
        
              executableHaskellDepends = [

     

       14569
       14586
        
                aeson ansi-terminal async atomic-write base bytestring

     

       14570
       14587
        
                bytestring-lexing bzlib-conduit conduit conduit-algorithms

     

       14571
       14588
        
                conduit-extra configurator containers convertible data-default

     

       14572
       14572
       -
                deepseq diagrams-core diagrams-lib diagrams-svg directory

     

       14573
       14573
       -
                double-conversion edit-distance either errors exceptions extra

     

       14574
       14574
       -
                file-embed filemanip filepath hashable hashtables hostname

     

       14575
       14575
       -
                http-client http-conduit inline-c inline-c-cpp int-interval-map

     

       14576
       14576
       -
                MissingH mtl network optparse-applicative parsec primitive process

     

       14577
       14577
       -
                regex resourcet safe safeio stm stm-chans stm-conduit strict tar

     

       14578
       14578
       -
                tar-conduit template-haskell text time transformers unix

     

       14579
       14579
       -
                unix-compat unliftio unliftio-core vector vector-algorithms yaml

     

       14580
       14580
       -
                zlib

     

       14589
       14589
       +
                deepseq directory double-conversion edit-distance either errors

     

       14590
       14590
       +
                exceptions extra file-embed filemanip filepath hashable hashtables

     

       14591
       14591
       +
                hostname http-client http-conduit inline-c inline-c-cpp

     

       14592
       14592
       +
                int-interval-map MissingH mtl network optparse-applicative parsec

     

       14593
       14593
       +
                primitive process random-shuffle regex resourcet safe safeio stm

     

       14594
       14594
       +
                stm-chans stm-conduit strict tar tar-conduit template-haskell text

     

       14595
       14595
       +
                time transformers unix unix-compat unliftio unliftio-core vector

     

       14596
       14596
       +
                vector-algorithms yaml zlib

     

       14581
       14597
        
              ];

     

       14582
       14598
        
              testHaskellDepends = [

     

       14583
       14599
        
                aeson ansi-terminal async atomic-write base bytestring

     

       14584
       14600
        
                bytestring-lexing bzlib-conduit conduit conduit-algorithms

     

       14585
       14601
        
                conduit-extra configurator containers convertible data-default

     

       14586
       14586
       -
                deepseq diagrams-core diagrams-lib diagrams-svg directory

     

       14587
       14587
       -
                double-conversion edit-distance either errors exceptions extra

     

       14588
       14588
       -
                file-embed filemanip filepath hashable hashtables hostname

     

       14589
       14589
       -
                http-client http-conduit HUnit inline-c inline-c-cpp

     

       14602
       14602
       +
                deepseq directory double-conversion edit-distance either errors

     

       14603
       14603
       +
                exceptions extra file-embed filemanip filepath hashable hashtables

     

       14604
       14604
       +
                hostname http-client http-conduit HUnit inline-c inline-c-cpp

     

       14590
       14605
        
                int-interval-map MissingH mtl network optparse-applicative parsec

     

       14591
       14591
       -
                primitive process QuickCheck regex resourcet safe safeio stm

     

       14592
       14592
       -
                stm-chans stm-conduit strict tar tar-conduit tasty tasty-hunit

     

       14593
       14593
       -
                tasty-quickcheck tasty-th template-haskell text time transformers

     

       14594
       14594
       -
                unix unix-compat unliftio unliftio-core vector vector-algorithms

     

       14595
       14595
       -
                yaml zlib

     

       14606
       14606
       +
                primitive process QuickCheck random-shuffle regex resourcet safe

     

       14607
       14607
       +
                safeio stm stm-chans stm-conduit strict tar tar-conduit tasty

     

       14608
       14608
       +
                tasty-hunit tasty-quickcheck tasty-th template-haskell text time

     

       14609
       14609
       +
                transformers unix unix-compat unliftio unliftio-core vector

     

       14610
       14610
       +
                vector-algorithms yaml zlib

     

       14596
       14611
        
              ];

     

       14597
       14612
        
              benchmarkHaskellDepends = [

     

       14598
       14613
        
                aeson ansi-terminal async atomic-write base bytestring

     

       14599
       14614
        
                bytestring-lexing bzlib-conduit conduit conduit-algorithms

     

       14600
       14615
        
                conduit-extra configurator containers convertible criterion

     

       14601
       14601
       -
                data-default deepseq diagrams-core diagrams-lib diagrams-svg

     

       14602
       14602
       -
                directory double-conversion edit-distance either errors exceptions

     

       14603
       14603
       -
                extra file-embed filemanip filepath hashable hashtables hostname

     

       14604
       14604
       -
                http-client http-conduit HUnit inline-c inline-c-cpp

     

       14605
       14605
       -
                int-interval-map MissingH mtl network optparse-applicative parsec

     

       14606
       14606
       -
                primitive process regex resourcet safe safeio stm stm-chans

     

       14607
       14607
       -
                stm-conduit strict tar tar-conduit template-haskell text time

     

       14608
       14608
       -
                transformers unix unix-compat unliftio unliftio-core vector

     

       14609
       14609
       -
                vector-algorithms yaml zlib

     

       14616
       14616
       +
                data-default deepseq directory double-conversion edit-distance

     

       14617
       14617
       +
                either errors exceptions extra file-embed filemanip filepath

     

       14618
       14618
       +
                hashable hashtables hostname http-client http-conduit HUnit

     

       14619
       14619
       +
                inline-c inline-c-cpp int-interval-map MissingH mtl network

     

       14620
       14620
       +
                optparse-applicative parsec primitive process random-shuffle regex

     

       14621
       14621
       +
                resourcet safe safeio stm stm-chans stm-conduit strict tar

     

       14622
       14622
       +
                tar-conduit template-haskell text time transformers unix

     

       14623
       14623
       +
                unix-compat unliftio unliftio-core vector vector-algorithms yaml

     

       14624
       14624
       +
                zlib

     

       14610
       14625
        
              ];

     

       14611
       14626
        
              description = "NGLess implements ngless, a DSL for processing sequencing data";

     

       14612
       14627
        
              license = lib.licenses.mit;

     
···

       20148
       20163
        
              broken = true;

     

       20149
       20164
        
            }) {};

     

       20150
       20165
        
       

     

       20166
       20166
       +
         "SvgIcons" = callPackage

     

       20167
       20167
       +
           ({ mkDerivation, base, blaze-markup, blaze-svg, directory, text }:

     

       20168
       20168
       +
            mkDerivation {

     

       20169
       20169
       +
              pname = "SvgIcons";

     

       20170
       20170
       +
              version = "0.1.0.0";

     

       20171
       20171
       +
              sha256 = "0vwlzjpcz6ky6x5mycsrqlwdfdzxf7y0z8y7pxwnc0h8f8psalr6";

     

       20172
       20172
       +
              isLibrary = true;

     

       20173
       20173
       +
              isExecutable = true;

     

       20174
       20174
       +
              libraryHaskellDepends = [

     

       20175
       20175
       +
                base blaze-markup blaze-svg directory text

     

       20176
       20176
       +
              ];

     

       20177
       20177
       +
              executableHaskellDepends = [

     

       20178
       20178
       +
                base blaze-markup blaze-svg directory text

     

       20179
       20179
       +
              ];

     

       20180
       20180
       +
              testHaskellDepends = [ base ];

     

       20181
       20181
       +
              description = "Svg Icons and more";

     

       20182
       20182
       +
              license = lib.licenses.bsd3;

     

       20183
       20183
       +
              hydraPlatforms = lib.platforms.none;

     

       20184
       20184
       +
              mainProgram = "SvgIcons-exe";

     

       20185
       20185
       +
              broken = true;

     

       20186
       20186
       +
            }) {};

     

       20187
       20187
       +
       

     

       20151
       20188
        
         "SybWidget" = callPackage

     

       20152
       20189
        
           ({ mkDerivation, base, containers, mtl, syb-with-class

     

       20153
       20190
        
            , template-haskell, TypeCompose

     
···

       22251
       22288
        
            }:

     

       22252
       22289
        
            mkDerivation {

     

       22253
       22290
        
              pname = "X11";

     

       22254
       22254
       -
              version = "1.10.2";

     

       22255
       22255
       -
              sha256 = "1ip207l97s8nw4daxp9s254agk8f0wibpf0prx0n695klqyn8bz1";

     

       22291
       22291
       +
              version = "1.10.3";

     

       22292
       22292
       +
              sha256 = "0hnj2q310a6s0h479hq8jsmywymvxdjxg13zw46mmdndynwd2jnq";

     

       22256
       22293
        
              libraryHaskellDepends = [ base data-default-class ];

     

       22257
       22294
        
              librarySystemDepends = [

     

       22258
       22295
        
                libX11 libXext libXinerama libXrandr libXrender libXScrnSaver

     
···

       25845
       25882
        
            }:

     

       25846
       25883
        
            mkDerivation {

     

       25847
       25884
        
              pname = "aeson-match-qq";

     

       25848
       25848
       -
              version = "1.4.3";

     

       25849
       25849
       -
              sha256 = "0zml908g96x6xqzpa5dv2p46y9rn8kfp10xw6954xabqlba8d0rv";

     

       25885
       25885
       +
              version = "1.5.1";

     

       25886
       25886
       +
              sha256 = "1m2brw8c1i0p32llng904lb893vkjfcqbmljkcx5m7iab0hvpvaw";

     

       25850
       25887
        
              libraryHaskellDepends = [

     

       25851
       25888
        
                aeson attoparsec base bytestring case-insensitive containers either

     

       25852
       25889
        
                haskell-src-meta scientific template-haskell text

     
···

       39793
       39830
        
           ({ mkDerivation, base, containers, hspec, QuickCheck, time }:

     

       39794
       39831
        
            mkDerivation {

     

       39795
       39832
        
              pname = "bank-holidays-england";

     

       39796
       39796
       -
              version = "0.2.0.7";

     

       39797
       39797
       -
              sha256 = "0q24flhiqp50krld6blmnlj8wqf2jvhfdpwrg469n3391p7jgfsc";

     

       39798
       39798
       -
              libraryHaskellDepends = [ base containers time ];

     

       39799
       39799
       -
              testHaskellDepends = [ base containers hspec QuickCheck time ];

     

       39800
       39800
       -
              description = "Calculation of bank holidays in England and Wales";

     

       39801
       39801
       -
              license = lib.licenses.bsd3;

     

       39802
       39802
       -
            }) {};

     

       39803
       39803
       -
       

     

       39804
       39804
       -
         "bank-holidays-england_0_2_0_8" = callPackage

     

       39805
       39805
       -
           ({ mkDerivation, base, containers, hspec, QuickCheck, time }:

     

       39806
       39806
       -
            mkDerivation {

     

       39807
       39807
       -
              pname = "bank-holidays-england";

     

       39808
       39833
        
              version = "0.2.0.8";

     

       39809
       39834
        
              sha256 = "1n2ddf60q2g1yjwq754irxq9nzmx5i2z3r2rnw263bppcldkizkj";

     

       39810
       39835
        
              libraryHaskellDepends = [ base containers time ];

     

       39811
       39836
        
              testHaskellDepends = [ base containers hspec QuickCheck time ];

     

       39812
       39837
        
              description = "Calculation of bank holidays in England and Wales";

     

       39813
       39838
        
              license = lib.licenses.bsd3;

     

       39814
       39814
       -
              hydraPlatforms = lib.platforms.none;

     

       39815
       39839
        
            }) {};

     

       39816
       39840
        
       

     

       39817
       39841
        
         "banwords" = callPackage

     
···

       40103
       40127
        
       

     

       40104
       40128
        
         "base-encoding" = callPackage

     

       40105
       40129
        
           ({ mkDerivation, base, base16-bytestring, base64-bytestring

     

       40106
       40106
       -
            , bytestring, text

     

       40130
       40130
       +
            , bytestring, bytestring-builder, text

     

       40107
       40131
        
            }:

     

       40108
       40132
        
            mkDerivation {

     

       40109
       40133
        
              pname = "base-encoding";

     

       40110
       40110
       -
              version = "0.2.0.0";

     

       40111
       40111
       -
              sha256 = "028b7pbpbnph2k4jzvp9kyn2s7d0zd62panh21digwn4nnc3hbp1";

     

       40134
       40134
       +
              version = "0.3.0.0";

     

       40135
       40135
       +
              sha256 = "1lcqg4wpbry3x165j8rsjbpj1mzd7bl0917hjv0jhvmh5z3wnas8";

     

       40112
       40136
        
              libraryHaskellDepends = [

     

       40113
       40113
       -
                base base16-bytestring base64-bytestring bytestring text

     

       40137
       40137
       +
                base base16-bytestring base64-bytestring bytestring

     

       40138
       40138
       +
                bytestring-builder text

     

       40114
       40139
        
              ];

     

       40115
       40115
       -
              description = "Binary-to-text encodings (e.g. base64)";

     

       40140
       40140
       +
              description = "RFC4648 Binary-to-text encodings (e.g. base64)";

     

       40116
       40141
        
              license = lib.licenses.bsd3;

     

       40117
       40142
        
              hydraPlatforms = lib.platforms.none;

     

       40118
       40143
        
              broken = true;

     
···

       40451
       40476
        
              pname = "base64";

     

       40452
       40477
        
              version = "0.4.2.4";

     

       40453
       40478
        
              sha256 = "119mpqcv1rwkhwm69ga2b4f7hr825fa5wfm1w3i1szmhzh52s2k4";

     

       40454
       40454
       -
              revision = "1";

     

       40455
       40455
       -
              editedCabalFile = "09jja484hzhnjfaz9whridrxsk799gyrg6qnvbpiy8q9c5cybfhi";

     

       40479
       40479
       +
              revision = "2";

     

       40480
       40480
       +
              editedCabalFile = "0cz3zzz9k490w9nfn4hpgdw4zx4w70fwqrwsfx8svcwqssqibqw3";

     

       40456
       40481
        
              libraryHaskellDepends = [

     

       40457
       40482
        
                base bytestring deepseq text text-short

     

       40458
       40483
        
              ];

     
···

       42405
       42430
        
              testToolDepends = [ hspec-discover ];

     

       42406
       42431
        
              description = "Bifunctors";

     

       42407
       42432
        
              license = lib.licenses.bsd3;

     

       42433
       42433
       +
            }) {};

     

       42434
       42434
       +
       

     

       42435
       42435
       +
         "bifunctors_5_5_13" = callPackage

     

       42436
       42436
       +
           ({ mkDerivation, base, base-orphans, comonad, containers, hspec

     

       42437
       42437
       +
            , hspec-discover, QuickCheck, tagged, template-haskell

     

       42438
       42438
       +
            , th-abstraction, transformers, transformers-compat

     

       42439
       42439
       +
            }:

     

       42440
       42440
       +
            mkDerivation {

     

       42441
       42441
       +
              pname = "bifunctors";

     

       42442
       42442
       +
              version = "5.5.13";

     

       42443
       42443
       +
              sha256 = "1myvlzxk9xrm6vf9863wnv8py3ccgfxqxyc0sqxz0v3rwfnjgk16";

     

       42444
       42444
       +
              libraryHaskellDepends = [

     

       42445
       42445
       +
                base base-orphans comonad containers tagged template-haskell

     

       42446
       42446
       +
                th-abstraction transformers

     

       42447
       42447
       +
              ];

     

       42448
       42448
       +
              testHaskellDepends = [

     

       42449
       42449
       +
                base hspec QuickCheck template-haskell transformers

     

       42450
       42450
       +
                transformers-compat

     

       42451
       42451
       +
              ];

     

       42452
       42452
       +
              testToolDepends = [ hspec-discover ];

     

       42453
       42453
       +
              description = "Bifunctors";

     

       42454
       42454
       +
              license = lib.licenses.bsd3;

     

       42455
       42455
       +
              hydraPlatforms = lib.platforms.none;

     

       42408
       42456
        
            }) {};

     

       42409
       42457
        
       

     

       42410
       42458
        
         "bighugethesaurus" = callPackage

     
···

       48575
       48623
        
              broken = true;

     

       48576
       48624
        
            }) {};

     

       48577
       48625
        
       

     

       48626
       48626
       +
         "brittany_0_13_1_2" = callPackage

     

       48627
       48627
       +
           ({ mkDerivation, aeson, base, butcher, bytestring, cmdargs

     

       48628
       48628
       +
            , containers, czipwith, data-tree-print, deepseq, directory, extra

     

       48629
       48629
       +
            , filepath, ghc, ghc-boot-th, ghc-exactprint, ghc-paths, hspec

     

       48630
       48630
       +
            , monad-memo, mtl, multistate, parsec, pretty, random, safe

     

       48631
       48631
       +
            , semigroups, strict, syb, text, transformers, uniplate, unsafe

     

       48632
       48632
       +
            , yaml

     

       48633
       48633
       +
            }:

     

       48634
       48634
       +
            mkDerivation {

     

       48635
       48635
       +
              pname = "brittany";

     

       48636
       48636
       +
              version = "0.13.1.2";

     

       48637
       48637
       +
              sha256 = "1pa8qgsild3zl56sdmbsllka64k05jk2p16ij3bdla4rbfw96z5g";

     

       48638
       48638
       +
              isLibrary = true;

     

       48639
       48639
       +
              isExecutable = true;

     

       48640
       48640
       +
              libraryHaskellDepends = [

     

       48641
       48641
       +
                aeson base butcher bytestring cmdargs containers czipwith

     

       48642
       48642
       +
                data-tree-print deepseq directory extra filepath ghc ghc-boot-th

     

       48643
       48643
       +
                ghc-exactprint ghc-paths monad-memo mtl multistate pretty random

     

       48644
       48644
       +
                safe semigroups strict syb text transformers uniplate unsafe yaml

     

       48645
       48645
       +
              ];

     

       48646
       48646
       +
              executableHaskellDepends = [ base ];

     

       48647
       48647
       +
              testHaskellDepends = [

     

       48648
       48648
       +
                aeson base butcher bytestring cmdargs containers czipwith

     

       48649
       48649
       +
                data-tree-print deepseq directory extra filepath ghc ghc-boot-th

     

       48650
       48650
       +
                ghc-exactprint ghc-paths hspec monad-memo mtl multistate parsec

     

       48651
       48651
       +
                pretty safe semigroups strict syb text transformers uniplate unsafe

     

       48652
       48652
       +
                yaml

     

       48653
       48653
       +
              ];

     

       48654
       48654
       +
              description = "Haskell source code formatter";

     

       48655
       48655
       +
              license = lib.licenses.agpl3Only;

     

       48656
       48656
       +
              hydraPlatforms = lib.platforms.none;

     

       48657
       48657
       +
              mainProgram = "brittany";

     

       48658
       48658
       +
            }) {};

     

       48659
       48659
       +
       

     

       48578
       48660
        
         "brittany" = callPackage

     

       48579
       48661
        
           ({ mkDerivation, aeson, base, butcher, bytestring, cmdargs

     

       48580
       48662
        
            , containers, czipwith, data-tree-print, deepseq, directory, extra

     
···

       51633
       51715
        
           ({ mkDerivation, base, Cabal, QuickCheck }:

     

       51634
       51716
        
            mkDerivation {

     

       51635
       51717
        
              pname = "cabal-detailed-quickcheck";

     

       51636
       51636
       -
              version = "0.1.2.1";

     

       51637
       51637
       -
              sha256 = "0h87l8q3c3pfhkvm0dcxd8q4kzfqzwaqcpn1wbsvcxlyqbn5dqgs";

     

       51718
       51718
       +
              version = "0.1.3.2";

     

       51719
       51719
       +
              sha256 = "0pxl8jf8ak9irln9vkkhb5mrbvq62c9p71gxhwzml1042gbl93x9";

     

       51638
       51720
        
              libraryHaskellDepends = [ base Cabal QuickCheck ];

     

       51639
       51721
        
              description = "QuickCheck for Cabal tests";

     

       51640
       51722
        
              license = lib.licenses.mit;

     
···

       57760
       57842
        
            }:

     

       57761
       57843
        
            mkDerivation {

     

       57762
       57844
        
              pname = "chr-core";

     

       57763
       57763
       -
              version = "0.1.0.4";

     

       57764
       57764
       -
              sha256 = "0kh8md0qw3x3b06lcl6v593dlh8a7m5j6w63j6fbwg2gmk290md9";

     

       57845
       57845
       +
              version = "0.1.1.0";

     

       57846
       57846
       +
              sha256 = "0bxwj0pwwps55705clzxrm58pzpgh249r9gmidr42vm7gh96pw4a";

     

       57765
       57847
        
              libraryHaskellDepends = [

     

       57766
       57848
        
                base chr-data chr-pretty containers hashable logict-state mtl

     

       57767
       57849
        
                pqueue unordered-containers

     
···

       57797
       57879
        
            }:

     

       57798
       57880
        
            mkDerivation {

     

       57799
       57881
        
              pname = "chr-lang";

     

       57800
       57800
       -
              version = "0.1.0.1";

     

       57801
       57801
       -
              sha256 = "0dd4xlk2klnqn6xyfh3b7gcy17z8x1lvyps5f5mypk9ijmrckhdy";

     

       57882
       57882
       +
              version = "0.1.1.0";

     

       57883
       57883
       +
              sha256 = "12bbbadq8da3n9712p0w613alvs65s5rcjmd7nymk3dx1i2syk23";

     

       57802
       57884
        
              isLibrary = true;

     

       57803
       57885
        
              isExecutable = true;

     

       57804
       57886
        
              libraryHaskellDepends = [

     
···

       59372
       59454
        
              testHaskellDepends = [ base miso rfc ];

     

       59373
       59455
        
              description = "Typeclass based support for Miso, the Tasty Web Framework for Haskell";

     

       59374
       59456
        
              license = lib.licenses.bsd3;

     

       59457
       59457
       +
              hydraPlatforms = lib.platforms.none;

     

       59375
       59458
        
              mainProgram = "classy-miso-demo";

     

       59376
       59459
        
            }) {};

     

       59377
       59460
        
       

     
···

       75106
       75189
        
            }:

     

       75107
       75190
        
            mkDerivation {

     

       75108
       75191
        
              pname = "data-sword";

     

       75109
       75109
       -
              version = "0.2.0.2";

     

       75110
       75110
       -
              sha256 = "1m14vxfx5raiy5b6w3602hkqywc0gj4yv38mjbwncbic86g6rgn2";

     

       75192
       75192
       +
              version = "0.2.0.3";

     

       75193
       75193
       +
              sha256 = "1qwvqhg2fdfpl543p96pzgf879qkx29y3z4k15wa3jarx8s619gq";

     

       75111
       75194
        
              libraryHaskellDepends = [

     

       75112
       75195
        
                base data-bword hashable template-haskell

     

       75113
       75196
        
              ];

     
···

       79954
       80037
        
            }:

     

       79955
       80038
        
            mkDerivation {

     

       79956
       80039
        
              pname = "diagrams-canvas";

     

       79957
       79957
       -
              version = "1.4.1";

     

       79958
       79958
       -
              sha256 = "1ihmv42412d8dk3s894zd70xd386wrk9ycxkid19barry1vz5plj";

     

       79959
       79959
       -
              revision = "3";

     

       79960
       79960
       -
              editedCabalFile = "0yajv3bnzhqwr673rch0wd9vhc4kcfdpdw5p5a2x1xbrpzghksac";

     

       80040
       80040
       +
              version = "1.4.1.1";

     

       80041
       80041
       +
              sha256 = "0vhjrmnf2bf4sfyaqhijsx79wah4p2dkg3h79yj9q8l7n90vbfw5";

     

       79961
       80042
        
              libraryHaskellDepends = [

     

       79962
       80043
        
                base blank-canvas cmdargs containers data-default-class

     

       79963
       80044
        
                diagrams-core diagrams-lib lens mtl NumInstances

     
···

       80171
       80252
        
              license = lib.licenses.bsd3;

     

       80172
       80253
        
            }) {};

     

       80173
       80254
        
       

     

       80255
       80255
       +
         "diagrams-lib_1_4_5_2" = callPackage

     

       80256
       80256
       +
           ({ mkDerivation, active, adjunctions, array, base, bytestring

     

       80257
       80257
       +
            , cereal, colour, containers, criterion, data-default-class

     

       80258
       80258
       +
            , deepseq, diagrams-core, diagrams-solve, directory, distributive

     

       80259
       80259
       +
            , dual-tree, exceptions, filepath, fingertree, fsnotify, hashable

     

       80260
       80260
       +
            , intervals, JuicyPixels, lens, linear, monoid-extras, mtl

     

       80261
       80261
       +
            , numeric-extras, optparse-applicative, process, profunctors

     

       80262
       80262
       +
            , QuickCheck, semigroups, tagged, tasty, tasty-hunit

     

       80263
       80263
       +
            , tasty-quickcheck, text, transformers, unordered-containers

     

       80264
       80264
       +
            }:

     

       80265
       80265
       +
            mkDerivation {

     

       80266
       80266
       +
              pname = "diagrams-lib";

     

       80267
       80267
       +
              version = "1.4.5.2";

     

       80268
       80268
       +
              sha256 = "1vx51g9znb4a9bf20pjd9zr98wmh39avk2i06217p0iidcw8whz6";

     

       80269
       80269
       +
              libraryHaskellDepends = [

     

       80270
       80270
       +
                active adjunctions array base bytestring cereal colour containers

     

       80271
       80271
       +
                data-default-class diagrams-core diagrams-solve directory

     

       80272
       80272
       +
                distributive dual-tree exceptions filepath fingertree fsnotify

     

       80273
       80273
       +
                hashable intervals JuicyPixels lens linear monoid-extras mtl

     

       80274
       80274
       +
                optparse-applicative process profunctors semigroups tagged text

     

       80275
       80275
       +
                transformers unordered-containers

     

       80276
       80276
       +
              ];

     

       80277
       80277
       +
              testHaskellDepends = [

     

       80278
       80278
       +
                base deepseq diagrams-solve distributive lens numeric-extras

     

       80279
       80279
       +
                QuickCheck tasty tasty-hunit tasty-quickcheck

     

       80280
       80280
       +
              ];

     

       80281
       80281
       +
              benchmarkHaskellDepends = [ base criterion diagrams-core ];

     

       80282
       80282
       +
              description = "Embedded domain-specific language for declarative graphics";

     

       80283
       80283
       +
              license = lib.licenses.bsd3;

     

       80284
       80284
       +
              hydraPlatforms = lib.platforms.none;

     

       80285
       80285
       +
            }) {};

     

       80286
       80286
       +
       

     

       80174
       80287
        
         "diagrams-pandoc" = callPackage

     

       80175
       80288
        
           ({ mkDerivation, base, diagrams-builder, diagrams-cairo

     

       80176
       80289
        
            , diagrams-core, diagrams-lib, diagrams-svg, directory, filepath

     
···

       85641
       85754
        
           ({ mkDerivation, base, containers, ghc }:

     

       85642
       85755
        
            mkDerivation {

     

       85643
       85756
        
              pname = "driving-classes-plugin";

     

       85644
       85644
       -
              version = "0.1.3.0";

     

       85645
       85645
       -
              sha256 = "126bih4i3gyjdwnmvivz0kzn6viw1nlap9zz076xljgkf8qw3dwn";

     

       85757
       85757
       +
              version = "0.1.4.0";

     

       85758
       85758
       +
              sha256 = "1bmf5ahlnlibiq2ydqni8w6iiw2bps92nzcapr4dmqmvgdq0s9lk";

     

       85646
       85759
        
              libraryHaskellDepends = [ base containers ghc ];

     

       85647
       85760
        
              testHaskellDepends = [ base ];

     

       85648
       85761
        
              description = "Deriving without spelling out \"deriving\"";

     
···

       87610
       87723
        
              mainProgram = "hectare";

     

       87611
       87724
        
            }) {};

     

       87612
       87725
        
       

     

       87726
       87726
       +
         "ecta-plugin" = callPackage

     

       87727
       87727
       +
           ({ mkDerivation, base, containers, ecta, ghc, text }:

     

       87728
       87728
       +
            mkDerivation {

     

       87729
       87729
       +
              pname = "ecta-plugin";

     

       87730
       87730
       +
              version = "0.1.1.3";

     

       87731
       87731
       +
              sha256 = "1rkh4k00k7g583wbhn28by1qjp39ad89k5nzxg9vm8g4p8famf4c";

     

       87732
       87732
       +
              libraryHaskellDepends = [ base containers ecta ghc text ];

     

       87733
       87733
       +
              description = "Hole-Fit Synthesis using ECTAs";

     

       87734
       87734
       +
              license = lib.licenses.mit;

     

       87735
       87735
       +
              hydraPlatforms = lib.platforms.none;

     

       87736
       87736
       +
              broken = true;

     

       87737
       87737
       +
            }) {};

     

       87738
       87738
       +
       

     

       87613
       87739
        
         "ecu" = callPackage

     

       87614
       87740
        
           ({ mkDerivation, base, bytestring, canlib, digest, directory

     

       87615
       87741
        
            , process, vcd

     
···

       88116
       88242
        
           ({ mkDerivation, base, effectful-core, primitive }:

     

       88117
       88243
        
            mkDerivation {

     

       88118
       88244
        
              pname = "effectful-st";

     

       88119
       88119
       -
              version = "0.0.0.0";

     

       88120
       88120
       -
              sha256 = "1afgq935l29ai9dizk0rzcpxlh7nfwzrkhidrlw77cc5lvypjan4";

     

       88245
       88245
       +
              version = "0.0.0.1";

     

       88246
       88246
       +
              sha256 = "0wbf6ilaimiqhggv4dvjrkghdv3ylivj2ncshp8ymfrc7kiw51a0";

     

       88121
       88247
        
              libraryHaskellDepends = [ base effectful-core primitive ];

     

       88122
       88248
        
              description = "`ST`-style mutation for `effectful`";

     

       88123
       88249
        
              license = lib.licenses.cc0;

     
···

       93362
       93488
        
              license = lib.licenses.mit;

     

       93363
       93489
        
            }) {};

     

       93364
       93490
        
       

     

       93491
       93491
       +
         "evm-opcodes_0_1_2" = callPackage

     

       93492
       93492
       +
           ({ mkDerivation, base, bytestring, cereal, containers, data-dword

     

       93493
       93493
       +
            , hedgehog, hspec, tasty, tasty-bench, tasty-discover

     

       93494
       93494
       +
            , tasty-hedgehog, tasty-hspec, text

     

       93495
       93495
       +
            }:

     

       93496
       93496
       +
            mkDerivation {

     

       93497
       93497
       +
              pname = "evm-opcodes";

     

       93498
       93498
       +
              version = "0.1.2";

     

       93499
       93499
       +
              sha256 = "0p7gb3k64jsjscfxf2cd34igkm9j8q0rq3irfh1x4jdryvck2jch";

     

       93500
       93500
       +
              libraryHaskellDepends = [

     

       93501
       93501
       +
                base bytestring cereal containers data-dword text

     

       93502
       93502
       +
              ];

     

       93503
       93503
       +
              testHaskellDepends = [

     

       93504
       93504
       +
                base bytestring cereal containers data-dword hedgehog hspec tasty

     

       93505
       93505
       +
                tasty-discover tasty-hedgehog tasty-hspec text

     

       93506
       93506
       +
              ];

     

       93507
       93507
       +
              testToolDepends = [ tasty-discover ];

     

       93508
       93508
       +
              benchmarkHaskellDepends = [

     

       93509
       93509
       +
                base bytestring cereal containers data-dword tasty-bench text

     

       93510
       93510
       +
              ];

     

       93511
       93511
       +
              description = "Opcode types for Ethereum Virtual Machine (EVM)";

     

       93512
       93512
       +
              license = lib.licenses.mit;

     

       93513
       93513
       +
              hydraPlatforms = lib.platforms.none;

     

       93514
       93514
       +
            }) {};

     

       93515
       93515
       +
       

     

       93365
       93516
        
         "evoke" = callPackage

     

       93366
       93517
        
           ({ mkDerivation, aeson, base, ghc, HUnit, insert-ordered-containers

     

       93367
       93518
        
            , lens, QuickCheck, swagger2, text

     
···

       94433
       94584
        
              ];

     

       94434
       94585
        
              description = "Predicates that can explain themselves";

     

       94435
       94586
        
              license = lib.licenses.bsd3;

     

       94587
       94587
       +
            }) {};

     

       94588
       94588
       +
       

     

       94589
       94589
       +
         "explainable-predicates_0_1_2_3" = callPackage

     

       94590
       94590
       +
           ({ mkDerivation, array, base, doctest-exitcode-stdio, doctest-lib

     

       94591
       94591
       +
            , hspec, HUnit, mono-traversable, QuickCheck, regex-tdfa, syb

     

       94592
       94592
       +
            , template-haskell

     

       94593
       94593
       +
            }:

     

       94594
       94594
       +
            mkDerivation {

     

       94595
       94595
       +
              pname = "explainable-predicates";

     

       94596
       94596
       +
              version = "0.1.2.3";

     

       94597
       94597
       +
              sha256 = "1ch86wb7bz9ydvrbdd2arskaj5pdc2x9vby4pbvnwv1r4d8n40la";

     

       94598
       94598
       +
              libraryHaskellDepends = [

     

       94599
       94599
       +
                array base HUnit mono-traversable QuickCheck regex-tdfa syb

     

       94600
       94600
       +
                template-haskell

     

       94601
       94601
       +
              ];

     

       94602
       94602
       +
              testHaskellDepends = [

     

       94603
       94603
       +
                base doctest-exitcode-stdio doctest-lib hspec

     

       94604
       94604
       +
              ];

     

       94605
       94605
       +
              description = "Predicates that can explain themselves";

     

       94606
       94606
       +
              license = lib.licenses.bsd3;

     

       94607
       94607
       +
              hydraPlatforms = lib.platforms.none;

     

       94436
       94608
        
            }) {};

     

       94437
       94609
        
       

     

       94438
       94610
        
         "explicit-constraint-lens" = callPackage

     
···

       96030
       96202
        
              pname = "fastparser";

     

       96031
       96203
        
              version = "0.5.0";

     

       96032
       96204
        
              sha256 = "0pxd2f6f0a6kckqmkkafh9zx11x75x1zx1z90snzj3j8s4jcfg4y";

     

       96205
       96205
       +
              revision = "1";

     

       96206
       96206
       +
              editedCabalFile = "0h64i8z71h0hfdc89bpqqamjn733mxshmlpapa4gvlnbzylm3cwr";

     

       96033
       96207
        
              libraryHaskellDepends = [

     

       96034
       96208
        
                base bytestring bytestring-lexing containers kan-extensions

     

       96035
       96209
        
                microlens thyme transformers vector-space

     
···

       101291
       101465
        
              broken = true;

     

       101292
       101466
        
            }) {};

     

       101293
       101467
        
       

     

       101468
       101468
       +
         "foreign" = callPackage

     

       101469
       101469
       +
           ({ mkDerivation, base, bytestring, ghc-prim, hspec, hspec-discover

     

       101470
       101470
       +
            , primitive, primitive-unlifted, QuickCheck, quickcheck-instances

     

       101471
       101471
       +
            }:

     

       101472
       101472
       +
            mkDerivation {

     

       101473
       101473
       +
              pname = "foreign";

     

       101474
       101474
       +
              version = "0.1.1.0";

     

       101475
       101475
       +
              sha256 = "0r9lag2d7hki1ciah4hzf4gdsxdlskjzkcafp6h99ifhb63m55i3";

     

       101476
       101476
       +
              libraryHaskellDepends = [

     

       101477
       101477
       +
                base bytestring ghc-prim primitive primitive-unlifted

     

       101478
       101478
       +
              ];

     

       101479
       101479
       +
              testHaskellDepends = [

     

       101480
       101480
       +
                base hspec QuickCheck quickcheck-instances

     

       101481
       101481
       +
              ];

     

       101482
       101482
       +
              testToolDepends = [ hspec-discover ];

     

       101483
       101483
       +
              description = "A collection of helpers for ffi";

     

       101484
       101484
       +
              license = lib.licenses.bsd3;

     

       101485
       101485
       +
              hydraPlatforms = lib.platforms.none;

     

       101486
       101486
       +
              broken = true;

     

       101487
       101487
       +
            }) {};

     

       101488
       101488
       +
       

     

       101294
       101489
        
         "foreign-storable-asymmetric" = callPackage

     

       101295
       101490
        
           ({ mkDerivation, base }:

     

       101296
       101491
        
            mkDerivation {

     
···

       101974
       102169
        
              license = lib.licenses.bsd3;

     

       101975
       102170
        
            }) {};

     

       101976
       102171
        
       

     

       101977
       101977
       -
         "fourmolu" = callPackage

     

       101978
       101978
       -
           ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal

     

       101979
       101979
       -
            , containers, Diff, directory, dlist, exceptions, filepath

     

       101980
       101980
       -
            , ghc-lib-parser, gitrev, hspec, hspec-discover, HsYAML

     

       101981
       101981
       -
            , HsYAML-aeson, mtl, optparse-applicative, path, path-io, syb

     

       101982
       101982
       -
            , temporary, text

     

       102172
       102172
       +
         "fourmolu_0_3_0_0" = callPackage

     

       102173
       102173
       +
           ({ mkDerivation, aeson, base, bytestring, containers, directory

     

       102174
       102174
       +
            , dlist, exceptions, filepath, ghc-lib-parser, gitrev, hspec

     

       102175
       102175
       +
            , hspec-discover, HsYAML, HsYAML-aeson, mtl, optparse-applicative

     

       102176
       102176
       +
            , path, path-io, syb, text

     

       101983
       102177
        
            }:

     

       101984
       102178
        
            mkDerivation {

     

       101985
       102179
        
              pname = "fourmolu";

     

       101986
       101986
       -
              version = "0.4.0.0";

     

       101987
       101987
       -
              sha256 = "1mq0h6nsl7ssfwh6zqhyja7w212vn8msmlm5iwwimca279hzwywb";

     

       101988
       101988
       -
              revision = "1";

     

       101989
       101989
       -
              editedCabalFile = "03bwhqj547brmgk191gy3k9xayi6fqqk2f5sbz3ail1bk7b73xnq";

     

       102180
       102180
       +
              version = "0.3.0.0";

     

       102181
       102181
       +
              sha256 = "0v89dvcr8l0swj23kkakc39q6lyxjz90rqgwy7m6a5p6iv3h2wms";

     

       102182
       102182
       +
              revision = "2";

     

       102183
       102183
       +
              editedCabalFile = "16ky7wzmnwhzkk18r63ynq78vlrg065z6mp3hqgs92khpjr33g1l";

     

       101990
       102184
        
              isLibrary = true;

     

       101991
       102185
        
              isExecutable = true;

     

       102186
       102186
       +
              enableSeparateDataOutput = true;

     

       101992
       102187
        
              libraryHaskellDepends = [

     

       101993
       101993
       -
                aeson ansi-terminal base bytestring Cabal containers Diff directory

     

       101994
       101994
       -
                dlist exceptions filepath ghc-lib-parser HsYAML HsYAML-aeson mtl

     

       101995
       101995
       -
                syb text

     

       102188
       102188
       +
                aeson base bytestring containers directory dlist exceptions

     

       102189
       102189
       +
                filepath ghc-lib-parser HsYAML HsYAML-aeson mtl syb text

     

       101996
       102190
        
              ];

     

       101997
       102191
        
              executableHaskellDepends = [

     

       101998
       101998
       -
                base directory filepath ghc-lib-parser gitrev optparse-applicative

     

       101999
       101999
       -
                text

     

       102192
       102192
       +
                base directory ghc-lib-parser gitrev optparse-applicative text

     

       102000
       102193
        
              ];

     

       102001
       102194
        
              testHaskellDepends = [

     

       102002
       102002
       -
                base containers directory filepath hspec path path-io temporary

     

       102003
       102003
       -
                text

     

       102195
       102195
       +
                base containers filepath hspec path path-io text

     

       102004
       102196
        
              ];

     

       102005
       102197
        
              testToolDepends = [ hspec-discover ];

     

       102006
       102198
        
              description = "A formatter for Haskell source code";

     

       102007
       102199
        
              license = lib.licenses.bsd3;

     

       102200
       102200
       +
              hydraPlatforms = lib.platforms.none;

     

       102008
       102201
        
              mainProgram = "fourmolu";

     

       102009
       102202
        
            }) {};

     

       102010
       102203
        
       

     

       102011
       102011
       -
         "fourmolu_0_6_0_0" = callPackage

     

       102012
       102012
       -
           ({ mkDerivation, aeson, ansi-terminal, array, base, bytestring

     

       102013
       102013
       -
            , Cabal, containers, Diff, directory, dlist, exceptions, filepath

     

       102204
       102204
       +
         "fourmolu" = callPackage

     

       102205
       102205
       +
           ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal

     

       102206
       102206
       +
            , containers, Diff, directory, dlist, exceptions, filepath

     

       102014
       102207
        
            , ghc-lib-parser, gitrev, hspec, hspec-discover, HsYAML

     

       102015
       102208
        
            , HsYAML-aeson, mtl, optparse-applicative, path, path-io, syb

     

       102016
       102209
        
            , temporary, text

     

       102017
       102210
        
            }:

     

       102018
       102211
        
            mkDerivation {

     

       102019
       102212
        
              pname = "fourmolu";

     

       102020
       102020
       -
              version = "0.6.0.0";

     

       102021
       102021
       -
              sha256 = "0yxv3ih2jjnjzdhz31y4a94ly6g3qhddrm3lvflqrb4krk445p67";

     

       102213
       102213
       +
              version = "0.4.0.0";

     

       102214
       102214
       +
              sha256 = "1mq0h6nsl7ssfwh6zqhyja7w212vn8msmlm5iwwimca279hzwywb";

     

       102215
       102215
       +
              revision = "1";

     

       102216
       102216
       +
              editedCabalFile = "03bwhqj547brmgk191gy3k9xayi6fqqk2f5sbz3ail1bk7b73xnq";

     

       102022
       102217
        
              isLibrary = true;

     

       102023
       102218
        
              isExecutable = true;

     

       102024
       102219
        
              libraryHaskellDepends = [

     

       102025
       102025
       -
                aeson ansi-terminal array base bytestring Cabal containers Diff

     

       102026
       102026
       -
                directory dlist exceptions filepath ghc-lib-parser HsYAML

     

       102027
       102027
       -
                HsYAML-aeson mtl syb text

     

       102220
       102220
       +
                aeson ansi-terminal base bytestring Cabal containers Diff directory

     

       102221
       102221
       +
                dlist exceptions filepath ghc-lib-parser HsYAML HsYAML-aeson mtl

     

       102222
       102222
       +
                syb text

     

       102028
       102223
        
              ];

     

       102029
       102224
        
              executableHaskellDepends = [

     

       102030
       102225
        
                base directory filepath ghc-lib-parser gitrev optparse-applicative

     
···

       102037
       102232
        
              testToolDepends = [ hspec-discover ];

     

       102038
       102233
        
              description = "A formatter for Haskell source code";

     

       102039
       102234
        
              license = lib.licenses.bsd3;

     

       102040
       102040
       -
              hydraPlatforms = lib.platforms.none;

     

       102041
       102235
        
              mainProgram = "fourmolu";

     

       102042
       102236
        
            }) {};

     

       102043
       102237
        
       

     
···

       102452
       102646
        
            }:

     

       102453
       102647
        
            mkDerivation {

     

       102454
       102648
        
              pname = "freckle-app";

     

       102455
       102455
       -
              version = "1.6.0.0";

     

       102456
       102456
       -
              sha256 = "1ciqkqzif6hnasqhcmlhm5smq06mjh05l94v36413zv7ikcszygx";

     

       102649
       102649
       +
              version = "1.6.0.3";

     

       102650
       102650
       +
              sha256 = "0nv29d82zsrf6x30jsjgi9wlnfshy50h3pi5x7igxm3zxhh9saf6";

     

       102457
       102651
        
              libraryHaskellDepends = [

     

       102458
       102652
        
                aeson base Blammo bugsnag bytestring case-insensitive conduit

     

       102459
       102653
        
                containers datadog doctest dotenv ekg-core envparse errors

     
···

       103625
       103819
        
              ];

     

       103626
       103820
        
              description = "Cross platform library for file change notification";

     

       103627
       103821
        
              license = lib.licenses.bsd3;

     

       103822
       103822
       +
            }) {};

     

       103823
       103823
       +
       

     

       103824
       103824
       +
         "fsnotify_0_4_0_0" = callPackage

     

       103825
       103825
       +
           ({ mkDerivation, async, base, bytestring, containers, directory

     

       103826
       103826
       +
            , exceptions, filepath, hinotify, hspec, hspec-core

     

       103827
       103827
       +
            , hspec-expectations, HUnit, monad-control, random, retry

     

       103828
       103828
       +
            , safe-exceptions, temporary, text, time, unix, unix-compat

     

       103829
       103829
       +
            }:

     

       103830
       103830
       +
            mkDerivation {

     

       103831
       103831
       +
              pname = "fsnotify";

     

       103832
       103832
       +
              version = "0.4.0.0";

     

       103833
       103833
       +
              sha256 = "033qwa71spjz3klqmsdzi85fjb0ps9l5v1vl5zylz5jarh41z66y";

     

       103834
       103834
       +
              libraryHaskellDepends = [

     

       103835
       103835
       +
                async base bytestring containers directory filepath hinotify

     

       103836
       103836
       +
                monad-control safe-exceptions text time unix unix-compat

     

       103837
       103837
       +
              ];

     

       103838
       103838
       +
              testHaskellDepends = [

     

       103839
       103839
       +
                async base directory exceptions filepath hspec hspec-core

     

       103840
       103840
       +
                hspec-expectations HUnit random retry safe-exceptions temporary

     

       103841
       103841
       +
                unix-compat

     

       103842
       103842
       +
              ];

     

       103843
       103843
       +
              description = "Cross platform library for file change notification";

     

       103844
       103844
       +
              license = lib.licenses.bsd3;

     

       103845
       103845
       +
              hydraPlatforms = lib.platforms.none;

     

       103628
       103846
        
            }) {};

     

       103629
       103847
        
       

     

       103630
       103848
        
         "fsnotify-conduit" = callPackage

     
···

       107615
       107833
        
            }:

     

       107616
       107834
        
            mkDerivation {

     

       107617
       107835
        
              pname = "genvalidity-hspec";

     

       107618
       107618
       -
              version = "1.0.0.0";

     

       107619
       107619
       -
              sha256 = "1p00iphswnsaabcnjmvf4ahydpqg66zya4qfjb52bbz6cb7k06s7";

     

       107620
       107620
       -
              libraryHaskellDepends = [

     

       107621
       107621
       -
                base genvalidity genvalidity-property hspec hspec-core QuickCheck

     

       107622
       107622
       -
                transformers validity

     

       107623
       107623
       -
              ];

     

       107624
       107624
       -
              testHaskellDepends = [

     

       107625
       107625
       -
                base genvalidity hspec hspec-core QuickCheck

     

       107626
       107626
       -
              ];

     

       107627
       107627
       -
              description = "Standard spec's for GenValidity instances";

     

       107628
       107628
       -
              license = lib.licenses.mit;

     

       107629
       107629
       -
            }) {};

     

       107630
       107630
       -
       

     

       107631
       107631
       -
         "genvalidity-hspec_1_0_0_1" = callPackage

     

       107632
       107632
       -
           ({ mkDerivation, base, genvalidity, genvalidity-property, hspec

     

       107633
       107633
       -
            , hspec-core, QuickCheck, transformers, validity

     

       107634
       107634
       -
            }:

     

       107635
       107635
       -
            mkDerivation {

     

       107636
       107636
       -
              pname = "genvalidity-hspec";

     

       107637
       107836
        
              version = "1.0.0.1";

     

       107638
       107837
        
              sha256 = "1l5iwzdidlir92zanr9672954dxcp4cg8pl5rb4x10vzg5y0s369";

     

       107639
       107838
        
              libraryHaskellDepends = [

     
···

       107645
       107844
        
              ];

     

       107646
       107845
        
              description = "Standard spec's for GenValidity instances";

     

       107647
       107846
        
              license = lib.licenses.mit;

     

       107648
       107648
       -
              hydraPlatforms = lib.platforms.none;

     

       107649
       107847
        
            }) {};

     

       107650
       107848
        
       

     

       107651
       107849
        
         "genvalidity-hspec-aeson" = callPackage

     
···

       109838
       110036
        
              license = lib.licenses.mit;

     

       109839
       110037
        
            }) {};

     

       109840
       110038
        
       

     

       110039
       110039
       +
         "ghc-parser_0_2_4_0" = callPackage

     

       110040
       110040
       +
           ({ mkDerivation, base, ghc }:

     

       110041
       110041
       +
            mkDerivation {

     

       110042
       110042
       +
              pname = "ghc-parser";

     

       110043
       110043
       +
              version = "0.2.4.0";

     

       110044
       110044
       +
              sha256 = "1s7y7npv37x1jxgq6ryl1ijcb7izmz07ab5pmqj4prng6g3majc9";

     

       110045
       110045
       +
              libraryHaskellDepends = [ base ghc ];

     

       110046
       110046
       +
              description = "Haskell source parser from GHC";

     

       110047
       110047
       +
              license = lib.licenses.mit;

     

       110048
       110048
       +
              hydraPlatforms = lib.platforms.none;

     

       110049
       110049
       +
            }) {};

     

       110050
       110050
       +
       

     

       109841
       110051
        
         "ghc-paths" = callPackage

     

       109842
       110052
        
           ({ mkDerivation, base, Cabal, directory }:

     

       109843
       110053
        
            mkDerivation {

     
···

       110206
       110416
        
            }) {};

     

       110207
       110417
        
       

     

       110208
       110418
        
         "ghc-tags-core" = callPackage

     

       110209
       110209
       -
           ({ mkDerivation, attoparsec, base, bytestring, criterion, deepseq

     

       110210
       110210
       -
            , directory, filepath, filepath-bytestring, ghc, lattices, mtl

     

       110211
       110211
       -
            , pipes, pipes-attoparsec, pipes-bytestring, QuickCheck

     

       110212
       110212
       -
            , quickcheck-instances, tasty, tasty-golden, tasty-quickcheck, text

     

       110213
       110213
       -
            , transformers

     

       110419
       110419
       +
           ({ mkDerivation, attoparsec, base, bytestring, containers

     

       110420
       110420
       +
            , criterion, deepseq, directory, filepath, filepath-bytestring, ghc

     

       110421
       110421
       +
            , lattices, mtl, pipes, pipes-attoparsec, pipes-bytestring

     

       110422
       110422
       +
            , QuickCheck, quickcheck-instances, tasty, tasty-golden

     

       110423
       110423
       +
            , tasty-quickcheck, text, transformers

     

       110214
       110424
        
            }:

     

       110215
       110425
        
            mkDerivation {

     

       110216
       110426
        
              pname = "ghc-tags-core";

     

       110217
       110217
       -
              version = "0.3.1.1";

     

       110218
       110218
       -
              sha256 = "0ch9xr262c0ssjzgk8yid3hwa04g5q0zn2yxgwjzbzg60ydf9cas";

     

       110427
       110427
       +
              version = "0.4.1.0";

     

       110428
       110428
       +
              sha256 = "0lcgbp61zvaa52ynp4lwnjf7vwk126f496r16zfbc6saxrgdmz0p";

     

       110219
       110429
        
              libraryHaskellDepends = [

     

       110220
       110220
       -
                attoparsec base bytestring directory filepath-bytestring ghc mtl

     

       110221
       110221
       -
                pipes pipes-attoparsec pipes-bytestring text transformers

     

       110430
       110430
       +
                attoparsec base bytestring containers deepseq directory

     

       110431
       110431
       +
                filepath-bytestring ghc mtl pipes pipes-attoparsec pipes-bytestring

     

       110432
       110432
       +
                text transformers

     

       110222
       110433
        
              ];

     

       110223
       110434
        
              testHaskellDepends = [

     

       110224
       110435
        
                attoparsec base bytestring directory filepath filepath-bytestring

     
···

       110243
       110454
        
            }:

     

       110244
       110455
        
            mkDerivation {

     

       110245
       110456
        
              pname = "ghc-tags-plugin";

     

       110246
       110246
       -
              version = "0.4.0.1";

     

       110247
       110247
       -
              sha256 = "14s7h7d8ihp800bz79mxpm4jsd3c0c1h228akbl08z69x6ggb1ac";

     

       110457
       110457
       +
              version = "0.5.1.0";

     

       110458
       110458
       +
              sha256 = "0k8lg8k4vd6z12zfks50j6i9mz827bgchjg55snbgnh3h30is6ab";

     

       110248
       110459
        
              isLibrary = true;

     

       110249
       110460
        
              isExecutable = true;

     

       110250
       110461
        
              libraryHaskellDepends = [

     
···

       110639
       110850
        
              pname = "ghcid";

     

       110640
       110851
        
              version = "0.8.7";

     

       110641
       110852
        
              sha256 = "0yqc1pkfajnr56gnh43sbj50r7c3r41b2jfz07ivgl6phi4frjbq";

     

       110853
       110853
       +
              revision = "1";

     

       110854
       110854
       +
              editedCabalFile = "0s4z20cbap0bymljkdbw6lr3dchi34yvy9j27f4xjwx93dhnrmkk";

     

       110642
       110855
        
              isLibrary = true;

     

       110643
       110856
        
              isExecutable = true;

     

       110644
       110857
        
              libraryHaskellDepends = [

     
···

       110658
       110871
        
              maintainers = [ lib.maintainers.maralorn ];

     

       110659
       110872
        
            }) {};

     

       110660
       110873
        
       

     

       110874
       110874
       +
         "ghcid_0_8_8" = callPackage

     

       110875
       110875
       +
           ({ mkDerivation, ansi-terminal, base, cmdargs, containers

     

       110876
       110876
       +
            , directory, extra, filepath, fsnotify, process, tasty, tasty-hunit

     

       110877
       110877
       +
            , terminal-size, time, unix

     

       110878
       110878
       +
            }:

     

       110879
       110879
       +
            mkDerivation {

     

       110880
       110880
       +
              pname = "ghcid";

     

       110881
       110881
       +
              version = "0.8.8";

     

       110882
       110882
       +
              sha256 = "1y2qr1g0jy1jd8lh6bqwhzad15jgz0psq5qx31hbgq6ikm1nxjcj";

     

       110883
       110883
       +
              isLibrary = true;

     

       110884
       110884
       +
              isExecutable = true;

     

       110885
       110885
       +
              libraryHaskellDepends = [

     

       110886
       110886
       +
                ansi-terminal base cmdargs directory extra filepath process time

     

       110887
       110887
       +
              ];

     

       110888
       110888
       +
              executableHaskellDepends = [

     

       110889
       110889
       +
                ansi-terminal base cmdargs containers directory extra filepath

     

       110890
       110890
       +
                fsnotify process terminal-size time unix

     

       110891
       110891
       +
              ];

     

       110892
       110892
       +
              testHaskellDepends = [

     

       110893
       110893
       +
                ansi-terminal base cmdargs containers directory extra filepath

     

       110894
       110894
       +
                fsnotify process tasty tasty-hunit terminal-size time unix

     

       110895
       110895
       +
              ];

     

       110896
       110896
       +
              description = "GHCi based bare bones IDE";

     

       110897
       110897
       +
              license = lib.licenses.bsd3;

     

       110898
       110898
       +
              hydraPlatforms = lib.platforms.none;

     

       110899
       110899
       +
              mainProgram = "ghcid";

     

       110900
       110900
       +
              maintainers = [ lib.maintainers.maralorn ];

     

       110901
       110901
       +
            }) {};

     

       110902
       110902
       +
       

     

       110661
       110903
        
         "ghcide" = callPackage

     

       110662
       110904
        
           ({ mkDerivation, aeson, aeson-pretty, array, async, base

     

       110663
       110905
        
            , base16-bytestring, binary, bytestring, case-insensitive

     

       110664
       110664
       -
            , containers, cryptohash-sha1, data-default, deepseq, dependent-map

     

       110665
       110665
       -
            , dependent-sum, Diff, directory, dlist, enummapset, exceptions

     

       110666
       110666
       -
            , extra, filepath, fingertree, focus, fuzzy, ghc, ghc-boot

     

       110667
       110667
       -
            , ghc-boot-th, ghc-check, ghc-exactprint, ghc-paths

     

       110668
       110668
       -
            , ghc-trace-events, ghc-typelits-knownnat, gitrev, Glob

     

       110669
       110669
       -
            , haddock-library, hashable, heapsize, hie-bios, hie-compat, hiedb

     

       110670
       110670
       -
            , hls-graph, hls-plugin-api, hp2pretty, hslogger, implicit-hie

     

       110671
       110671
       -
            , implicit-hie-cradle, lens, list-t, lsp, lsp-test, lsp-types

     

       110672
       110672
       -
            , monoid-subclasses, mtl, network-uri, opentelemetry

     

       110673
       110673
       -
            , optparse-applicative, parallel, prettyprinter

     

       110674
       110674
       -
            , prettyprinter-ansi-terminal, process, QuickCheck

     

       110675
       110675
       -
            , quickcheck-instances, random, record-dot-preprocessor

     

       110676
       110676
       -
            , record-hasfield, regex-tdfa, retrie, rope-utf16-splay, safe

     

       110677
       110677
       -
            , safe-exceptions, shake, shake-bench, sorted-list, sqlite-simple

     

       110678
       110678
       -
            , stm, stm-containers, syb, tasty, tasty-expected-failure

     

       110679
       110679
       -
            , tasty-hunit, tasty-quickcheck, tasty-rerun, text, time

     

       110906
       110906
       +
            , co-log-core, containers, cryptohash-sha1, data-default, deepseq

     

       110907
       110907
       +
            , dependent-map, dependent-sum, Diff, directory, dlist, enummapset

     

       110908
       110908
       +
            , exceptions, extra, filepath, fingertree, focus, fuzzy, ghc

     

       110909
       110909
       +
            , ghc-boot, ghc-boot-th, ghc-check, ghc-paths, ghc-trace-events

     

       110910
       110910
       +
            , ghc-typelits-knownnat, gitrev, Glob, haddock-library, hashable

     

       110911
       110911
       +
            , heapsize, hie-bios, hie-compat, hiedb, hls-graph, hls-plugin-api

     

       110912
       110912
       +
            , hslogger, implicit-hie, implicit-hie-cradle, lens, list-t, lsp

     

       110913
       110913
       +
            , lsp-test, lsp-types, monoid-subclasses, mtl, network-uri

     

       110914
       110914
       +
            , opentelemetry, optparse-applicative, parallel, prettyprinter

     

       110915
       110915
       +
            , prettyprinter-ansi-terminal, QuickCheck, random

     

       110916
       110916
       +
            , record-dot-preprocessor, record-hasfield, regex-tdfa

     

       110917
       110917
       +
            , safe-exceptions, shake, sorted-list, sqlite-simple, stm

     

       110918
       110918
       +
            , stm-containers, syb, tasty, tasty-expected-failure, tasty-hunit

     

       110919
       110919
       +
            , tasty-quickcheck, tasty-rerun, text, text-rope, time

     

       110680
       110920
        
            , transformers, unix, unliftio, unliftio-core, unordered-containers

     

       110681
       110681
       -
            , utf8-string, vector, vector-algorithms, yaml

     

       110921
       110921
       +
            , vector

     

       110682
       110922
        
            }:

     

       110683
       110923
        
            mkDerivation {

     

       110684
       110924
        
              pname = "ghcide";

     

       110685
       110685
       -
              version = "1.7.0.0";

     

       110686
       110686
       -
              sha256 = "097vpp1gds36ijldz29bsk71pxc82l966ka578cxsrcdc3g3ll1b";

     

       110687
       110687
       -
              revision = "2";

     

       110688
       110688
       -
              editedCabalFile = "1j4jzqhghjlzsyfn9jh70ah73nydjp9sjabpc041q5fv17s9b65z";

     

       110925
       110925
       +
              version = "1.8.0.0";

     

       110926
       110926
       +
              sha256 = "0j46xlaphmsmfpiycdi2n24mydvrb3c20sw2zzqm396x5ziz9p8p";

     

       110689
       110927
        
              isLibrary = true;

     

       110690
       110928
        
              isExecutable = true;

     

       110691
       110929
        
              libraryHaskellDepends = [

     

       110692
       110930
        
                aeson aeson-pretty array async base base16-bytestring binary

     

       110693
       110693
       -
                bytestring case-insensitive containers cryptohash-sha1 data-default

     

       110694
       110694
       -
                deepseq dependent-map dependent-sum Diff directory dlist enummapset

     

       110695
       110695
       -
                exceptions extra filepath fingertree focus ghc ghc-boot ghc-boot-th

     

       110696
       110696
       -
                ghc-check ghc-exactprint ghc-paths ghc-trace-events Glob

     

       110931
       110931
       +
                bytestring case-insensitive co-log-core containers cryptohash-sha1

     

       110932
       110932
       +
                data-default deepseq dependent-map dependent-sum Diff directory

     

       110933
       110933
       +
                dlist enummapset exceptions extra filepath fingertree focus ghc

     

       110934
       110934
       +
                ghc-boot ghc-boot-th ghc-check ghc-paths ghc-trace-events Glob

     

       110697
       110935
        
                haddock-library hashable heapsize hie-bios hie-compat hiedb

     

       110698
       110936
        
                hls-graph hls-plugin-api hslogger implicit-hie-cradle lens list-t

     

       110699
       110699
       -
                lsp lsp-types monoid-subclasses mtl network-uri opentelemetry

     

       110937
       110937
       +
                lsp lsp-types monoid-subclasses mtl opentelemetry

     

       110700
       110938
        
                optparse-applicative parallel prettyprinter

     

       110701
       110701
       -
                prettyprinter-ansi-terminal random regex-tdfa retrie

     

       110702
       110702
       -
                rope-utf16-splay safe safe-exceptions sorted-list sqlite-simple stm

     

       110703
       110703
       -
                stm-containers syb text time transformers unix unliftio

     

       110704
       110704
       -
                unliftio-core unordered-containers utf8-string vector

     

       110705
       110705
       -
                vector-algorithms

     

       110939
       110939
       +
                prettyprinter-ansi-terminal random regex-tdfa safe-exceptions

     

       110940
       110940
       +
                sorted-list sqlite-simple stm stm-containers syb text text-rope

     

       110941
       110941
       +
                time transformers unix unliftio unliftio-core unordered-containers

     

       110942
       110942
       +
                vector

     

       110706
       110943
        
              ];

     

       110707
       110944
        
              executableHaskellDepends = [

     

       110708
       110708
       -
                aeson base bytestring containers data-default directory extra

     

       110709
       110709
       -
                filepath ghc gitrev hashable heapsize hie-bios hiedb hls-graph

     

       110710
       110710
       -
                hls-plugin-api lens lsp lsp-test lsp-types optparse-applicative

     

       110711
       110711
       -
                process safe-exceptions shake tasty-hunit text unordered-containers

     

       110945
       110945
       +
                aeson base data-default directory extra filepath ghc gitrev

     

       110946
       110946
       +
                hashable heapsize hie-bios hiedb hls-graph hls-plugin-api lens lsp

     

       110947
       110947
       +
                lsp-types optparse-applicative safe-exceptions text

     

       110948
       110948
       +
                unordered-containers

     

       110712
       110949
        
              ];

     

       110713
       110950
        
              testHaskellDepends = [

     

       110714
       110714
       -
                aeson async base binary bytestring containers data-default

     

       110715
       110715
       -
                directory extra filepath fuzzy ghc ghc-typelits-knownnat

     

       110716
       110716
       -
                haddock-library hls-graph hls-plugin-api lens list-t lsp lsp-test

     

       110717
       110717
       -
                lsp-types monoid-subclasses network-uri optparse-applicative

     

       110718
       110718
       -
                parallel process QuickCheck quickcheck-instances random

     

       110719
       110719
       -
                record-dot-preprocessor record-hasfield regex-tdfa rope-utf16-splay

     

       110720
       110720
       -
                safe safe-exceptions shake sqlite-simple stm stm-containers tasty

     

       110721
       110721
       -
                tasty-expected-failure tasty-hunit tasty-quickcheck tasty-rerun

     

       110722
       110722
       -
                text unordered-containers vector

     

       110951
       110951
       +
                aeson async base containers data-default directory extra filepath

     

       110952
       110952
       +
                fuzzy ghc ghc-typelits-knownnat hls-plugin-api lens list-t lsp

     

       110953
       110953
       +
                lsp-test lsp-types monoid-subclasses network-uri QuickCheck random

     

       110954
       110954
       +
                record-dot-preprocessor record-hasfield regex-tdfa shake

     

       110955
       110955
       +
                sqlite-simple stm stm-containers tasty tasty-expected-failure

     

       110956
       110956
       +
                tasty-hunit tasty-quickcheck tasty-rerun text text-rope

     

       110957
       110957
       +
                unordered-containers

     

       110723
       110958
        
              ];

     

       110724
       110959
        
              testToolDepends = [ implicit-hie ];

     

       110725
       110725
       -
              benchmarkHaskellDepends = [

     

       110726
       110726
       -
                aeson base directory extra filepath lens optparse-applicative shake

     

       110727
       110727
       -
                shake-bench text yaml

     

       110728
       110728
       -
              ];

     

       110729
       110729
       -
              benchmarkToolDepends = [ hp2pretty implicit-hie ];

     

       110730
       110960
        
              description = "The core of an IDE";

     

       110731
       110961
        
              license = lib.licenses.asl20;

     

       110732
       110962
        
              maintainers = [ lib.maintainers.maralorn ];

     

       110733
       110963
        
            }) {};

     

       110734
       110964
        
       

     

       110965
       110965
       +
         "ghcide-bench" = callPackage

     

       110966
       110966
       +
           ({ mkDerivation, aeson, async, base, binary, bytestring, containers

     

       110967
       110967
       +
            , data-default, deepseq, directory, extra, filepath, ghcide

     

       110968
       110968
       +
            , ghcide-test-utils, hashable, hls-graph, hls-plugin-api

     

       110969
       110969
       +
            , implicit-hie, lens, lsp-test, lsp-types, optparse-applicative

     

       110970
       110970
       +
            , parser-combinators, process, safe-exceptions, shake, tasty

     

       110971
       110971
       +
            , tasty-hunit, tasty-rerun, text

     

       110972
       110972
       +
            }:

     

       110973
       110973
       +
            mkDerivation {

     

       110974
       110974
       +
              pname = "ghcide-bench";

     

       110975
       110975
       +
              version = "0.1";

     

       110976
       110976
       +
              sha256 = "0l7sablv85dgyzj12rbn0az704mzx4hjbm6kz88223kwn71qnnzz";

     

       110977
       110977
       +
              isLibrary = true;

     

       110978
       110978
       +
              isExecutable = true;

     

       110979
       110979
       +
              libraryHaskellDepends = [

     

       110980
       110980
       +
                aeson async base binary bytestring deepseq directory extra filepath

     

       110981
       110981
       +
                ghcide ghcide-test-utils hashable lens lsp-test lsp-types

     

       110982
       110982
       +
                optparse-applicative parser-combinators process safe-exceptions

     

       110983
       110983
       +
                shake text

     

       110984
       110984
       +
              ];

     

       110985
       110985
       +
              executableHaskellDepends = [

     

       110986
       110986
       +
                aeson base bytestring containers data-default directory extra

     

       110987
       110987
       +
                filepath hls-graph hls-plugin-api lens lsp-test lsp-types

     

       110988
       110988
       +
                optparse-applicative process safe-exceptions shake tasty-hunit text

     

       110989
       110989
       +
              ];

     

       110990
       110990
       +
              testHaskellDepends = [

     

       110991
       110991
       +
                base extra lsp-test tasty tasty-hunit tasty-rerun

     

       110992
       110992
       +
              ];

     

       110993
       110993
       +
              testToolDepends = [ ghcide implicit-hie ];

     

       110994
       110994
       +
              description = "An LSP client for running performance experiments on HLS";

     

       110995
       110995
       +
              license = lib.licenses.asl20;

     

       110996
       110996
       +
              mainProgram = "ghcide-bench";

     

       110997
       110997
       +
            }) {};

     

       110998
       110998
       +
       

     

       110999
       110999
       +
         "ghcide-test-utils" = callPackage

     

       111000
       111000
       +
           ({ mkDerivation, aeson, base, containers, data-default, directory

     

       111001
       111001
       +
            , extra, filepath, ghcide, hls-plugin-api, lens, lsp-test

     

       111002
       111002
       +
            , lsp-types, tasty-hunit, text

     

       111003
       111003
       +
            }:

     

       111004
       111004
       +
            mkDerivation {

     

       111005
       111005
       +
              pname = "ghcide-test-utils";

     

       111006
       111006
       +
              version = "1.8.0.0";

     

       111007
       111007
       +
              sha256 = "171y27lkngnsv26qd1wga5yfdjrz48bmz1nzwrskfcfws8hwizd7";

     

       111008
       111008
       +
              libraryHaskellDepends = [

     

       111009
       111009
       +
                aeson base containers data-default directory extra filepath ghcide

     

       111010
       111010
       +
                hls-plugin-api lens lsp-test lsp-types tasty-hunit text

     

       111011
       111011
       +
              ];

     

       111012
       111012
       +
              description = "Test utils for ghcide";

     

       111013
       111013
       +
              license = lib.licenses.asl20;

     

       111014
       111014
       +
            }) {};

     

       111015
       111015
       +
       

     

       110735
       111016
        
         "ghcjs-ajax" = callPackage

     

       110736
       111017
        
           ({ mkDerivation, aeson, base, http-types, text }:

     

       110737
       111018
        
            mkDerivation {

     
···

       121039
       121320
        
              mainProgram = "gtk-sni-tray-standalone";

     

       121040
       121321
        
            }) {inherit (pkgs) gtk3;};

     

       121041
       121322
        
       

     

       121323
       121323
       +
         "gtk-sni-tray_0_1_8_1" = callPackage

     

       121324
       121324
       +
           ({ mkDerivation, base, bytestring, containers, dbus, dbus-hslogger

     

       121325
       121325
       +
            , directory, enclosed-exceptions, filepath, gi-cairo

     

       121326
       121326
       +
            , gi-cairo-connector, gi-cairo-render, gi-dbusmenugtk3, gi-gdk

     

       121327
       121327
       +
            , gi-gdkpixbuf, gi-glib, gi-gtk, gtk-strut, gtk3, haskell-gi

     

       121328
       121328
       +
            , haskell-gi-base, hslogger, optparse-applicative

     

       121329
       121329
       +
            , status-notifier-item, text, transformers, transformers-base, unix

     

       121330
       121330
       +
            }:

     

       121331
       121331
       +
            mkDerivation {

     

       121332
       121332
       +
              pname = "gtk-sni-tray";

     

       121333
       121333
       +
              version = "0.1.8.1";

     

       121334
       121334
       +
              sha256 = "0i131ks6m5akgcfahcbfqhg1i5dxz0y6rba3is4s3m5va6spp5yf";

     

       121335
       121335
       +
              isLibrary = true;

     

       121336
       121336
       +
              isExecutable = true;

     

       121337
       121337
       +
              libraryHaskellDepends = [

     

       121338
       121338
       +
                base bytestring containers dbus directory enclosed-exceptions

     

       121339
       121339
       +
                filepath gi-cairo gi-cairo-connector gi-cairo-render

     

       121340
       121340
       +
                gi-dbusmenugtk3 gi-gdk gi-gdkpixbuf gi-glib gi-gtk gtk-strut

     

       121341
       121341
       +
                haskell-gi haskell-gi-base hslogger status-notifier-item text

     

       121342
       121342
       +
                transformers transformers-base unix

     

       121343
       121343
       +
              ];

     

       121344
       121344
       +
              libraryPkgconfigDepends = [ gtk3 ];

     

       121345
       121345
       +
              executableHaskellDepends = [

     

       121346
       121346
       +
                base dbus dbus-hslogger gi-gdk gi-gtk gtk-strut hslogger

     

       121347
       121347
       +
                optparse-applicative status-notifier-item text unix

     

       121348
       121348
       +
              ];

     

       121349
       121349
       +
              description = "A standalone StatusNotifierItem/AppIndicator tray";

     

       121350
       121350
       +
              license = lib.licenses.bsd3;

     

       121351
       121351
       +
              badPlatforms = lib.platforms.darwin;

     

       121352
       121352
       +
              hydraPlatforms = lib.platforms.none;

     

       121353
       121353
       +
              mainProgram = "gtk-sni-tray-standalone";

     

       121354
       121354
       +
            }) {inherit (pkgs) gtk3;};

     

       121355
       121355
       +
       

     

       121042
       121356
        
         "gtk-strut" = callPackage

     

       121043
       121043
       -
           ({ mkDerivation, base, gi-gdk, gi-gtk, text, transformers }:

     

       121357
       121357
       +
           ({ mkDerivation, base, data-default, gi-gdk, gi-gtk, hslogger, text

     

       121358
       121358
       +
            , transformers

     

       121359
       121359
       +
            }:

     

       121044
       121360
        
            mkDerivation {

     

       121045
       121361
        
              pname = "gtk-strut";

     

       121046
       121046
       -
              version = "0.1.3.0";

     

       121047
       121047
       -
              sha256 = "19p3w1zvnaazfd01yy4cl00sl53xc7kqgqhsw7l3psadmwk6x4w1";

     

       121048
       121048
       -
              libraryHaskellDepends = [ base gi-gdk gi-gtk text transformers ];

     

       121362
       121362
       +
              version = "0.1.3.1";

     

       121363
       121363
       +
              sha256 = "1zy5qv628n2hs8lrg9bggri2gj2jcyl7xwlrz8w4ndgnpsw9zk7c";

     

       121364
       121364
       +
              libraryHaskellDepends = [

     

       121365
       121365
       +
                base data-default gi-gdk gi-gtk hslogger text transformers

     

       121366
       121366
       +
              ];

     

       121049
       121367
        
              description = "Libary for creating strut windows with gi-gtk";

     

       121050
       121368
        
              license = lib.licenses.bsd3;

     

       121051
       121369
        
            }) {};

     

       121052
       121370
        
       

     

       121053
       121053
       -
         "gtk-strut_0_1_3_1" = callPackage

     

       121371
       121371
       +
         "gtk-strut_0_1_3_2" = callPackage

     

       121054
       121372
        
           ({ mkDerivation, base, data-default, gi-gdk, gi-gtk, hslogger, text

     

       121055
       121373
        
            , transformers

     

       121056
       121374
        
            }:

     

       121057
       121375
        
            mkDerivation {

     

       121058
       121376
        
              pname = "gtk-strut";

     

       121059
       121059
       -
              version = "0.1.3.1";

     

       121060
       121060
       -
              sha256 = "1zy5qv628n2hs8lrg9bggri2gj2jcyl7xwlrz8w4ndgnpsw9zk7c";

     

       121377
       121377
       +
              version = "0.1.3.2";

     

       121378
       121378
       +
              sha256 = "0rymacvllin8ni2fd7yyfq43rbbyb921c4nm4z7aa2z82fsrkw3q";

     

       121061
       121379
        
              libraryHaskellDepends = [

     

       121062
       121380
        
                base data-default gi-gdk gi-gtk hslogger text transformers

     

       121063
       121381
        
              ];

     

       121064
       121064
       -
              description = "Libary for creating strut windows with gi-gtk";

     

       121382
       121382
       +
              description = "Library for creating strut windows with gi-gtk";

     

       121065
       121383
        
              license = lib.licenses.bsd3;

     

       121066
       121384
        
              hydraPlatforms = lib.platforms.none;

     

       121067
       121385
        
            }) {};

     
···

       123953
       124271
        
              pname = "hakyll";

     

       123954
       124272
        
              version = "4.15.1.1";

     

       123955
       124273
        
              sha256 = "0b3bw275q1xbx8qs9a6gzzs3c9z3qdj7skqhpp09jkchi5kdvhvi";

     

       123956
       123956
       -
              revision = "6";

     

       123957
       123957
       -
              editedCabalFile = "0vkss84dm4fgx94r2wrv1z5mk515am6vbd2y66v44vl7fcr23q83";

     

       124274
       124274
       +
              revision = "7";

     

       124275
       124275
       +
              editedCabalFile = "0xgcrv98yxf7hjwq2ivg1lcipr3q5f5civp5r6kaq7ygnhggy2w9";

     

       123958
       124276
        
              isLibrary = true;

     

       123959
       124277
        
              isExecutable = true;

     

       123960
       124278
        
              enableSeparateDataOutput = true;

     
···

       124020
       124338
        
            }:

     

       124021
       124339
        
            mkDerivation {

     

       124022
       124340
        
              pname = "hakyll-alectryon";

     

       124023
       124023
       -
              version = "0.1.1.0";

     

       124024
       124024
       -
              sha256 = "1gl6ps6zjdlrc2japw1r2k9fg0ar5r8qirk9v3r78wxjw6p6g2qi";

     

       124341
       124341
       +
              version = "0.1.2.0";

     

       124342
       124342
       +
              sha256 = "0f1jznfr79z3y1zpi30abvcc0i3ylif1aa30wldj7ghpdxsvrjpb";

     

       124025
       124343
        
              libraryHaskellDepends = [

     

       124026
       124344
        
                aeson base bytestring filepath hakyll mtl optparse-applicative

     

       124027
       124345
        
                pandoc pandoc-types process text

     
···

       128206
       128524
        
           ({ mkDerivation, aeson, aeson-pretty, async, base

     

       128207
       128525
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128208
       128526
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128209
       128209
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128210
       128210
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128211
       128211
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128212
       128212
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128213
       128213
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128214
       128214
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128527
       128527
       +
            , filepath, ghc, ghc-boot-th, ghc-paths, ghcide, ghcide-bench

     

       128528
       128528
       +
            , githash, gitrev, hashable, hie-bios, hiedb

     

       128529
       128529
       +
            , hls-alternate-number-format-plugin, hls-call-hierarchy-plugin

     

       128530
       128530
       +
            , hls-change-type-signature-plugin, hls-class-plugin

     

       128531
       128531
       +
            , hls-code-range-plugin, hls-eval-plugin

     

       128532
       128532
       +
            , hls-explicit-fixity-plugin, hls-explicit-imports-plugin

     

       128533
       128533
       +
            , hls-floskell-plugin, hls-fourmolu-plugin, hls-gadt-plugin

     

       128534
       128534
       +
            , hls-graph, hls-haddock-comments-plugin, hls-hlint-plugin

     

       128215
       128535
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128216
       128536
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128217
       128217
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128218
       128218
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128219
       128219
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128220
       128220
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128221
       128221
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128222
       128222
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128537
       128537
       +
            , hls-refactor-plugin, hls-refine-imports-plugin, hls-rename-plugin

     

       128538
       128538
       +
            , hls-retrie-plugin, hls-splice-plugin, hls-stylish-haskell-plugin

     

       128539
       128539
       +
            , hls-tactics-plugin, hls-test-utils, hp2pretty, hslogger

     

       128540
       128540
       +
            , hspec-expectations, implicit-hie, lens, lens-aeson, lsp, lsp-test

     

       128541
       128541
       +
            , lsp-types, mtl, optparse-applicative, optparse-simple

     

       128542
       128542
       +
            , prettyprinter, process, regex-tdfa, safe-exceptions, shake

     

       128543
       128543
       +
            , shake-bench, sqlite-simple, stm, temporary, text, transformers

     

       128544
       128544
       +
            , unix, unliftio-core, unordered-containers, yaml

     

       128223
       128545
        
            }:

     

       128224
       128546
        
            mkDerivation {

     

       128225
       128547
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128226
       128226
       -
              version = "1.7.0.0";

     

       128227
       128227
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128228
       128228
       -
              revision = "1";

     

       128229
       128229
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128548
       128548
       +
              version = "1.8.0.0";

     

       128549
       128549
       +
              sha256 = "0jmc9qfqq5r7skajma6vd84p7vj8a7k37mk7yzwrqs66f48wcc54";

     

       128230
       128550
        
              isLibrary = true;

     

       128231
       128551
        
              isExecutable = true;

     

       128232
       128552
        
              libraryHaskellDepends = [

     

       128233
       128553
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128234
       128554
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128235
       128235
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128555
       128555
       +
                githash hie-bios hiedb hls-alternate-number-format-plugin

     

       128556
       128556
       +
                hls-call-hierarchy-plugin hls-change-type-signature-plugin

     

       128557
       128557
       +
                hls-class-plugin hls-code-range-plugin hls-eval-plugin

     

       128558
       128558
       +
                hls-explicit-fixity-plugin hls-explicit-imports-plugin

     

       128559
       128559
       +
                hls-floskell-plugin hls-fourmolu-plugin hls-gadt-plugin hls-graph

     

       128560
       128560
       +
                hls-haddock-comments-plugin hls-hlint-plugin hls-module-name-plugin

     

       128561
       128561
       +
                hls-ormolu-plugin hls-plugin-api hls-pragmas-plugin

     

       128562
       128562
       +
                hls-qualify-imported-names-plugin hls-refactor-plugin

     

       128563
       128563
       +
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128564
       128564
       +
                hls-splice-plugin hls-stylish-haskell-plugin hls-tactics-plugin lsp

     

       128236
       128565
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128237
       128566
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128238
       128567
        
              ];

     
···

       128240
       128569
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128241
       128570
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128242
       128571
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128243
       128243
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128244
       128244
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128245
       128245
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128246
       128246
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128247
       128247
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128248
       128248
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128249
       128249
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128250
       128250
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128572
       128572
       +
                hls-graph hls-plugin-api hslogger lens lsp lsp-types mtl

     

       128251
       128573
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128252
       128574
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128253
       128253
       -
                transformers unix unordered-containers

     

       128575
       128575
       +
                transformers unix unliftio-core unordered-containers

     

       128254
       128576
        
              ];

     

       128255
       128577
        
              testHaskellDepends = [

     

       128256
       128578
        
                aeson base bytestring containers data-default directory extra

     

       128257
       128257
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128258
       128258
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128259
       128259
       -
                unordered-containers

     

       128579
       128579
       +
                filepath ghcide hls-plugin-api hls-refactor-plugin hls-test-utils

     

       128580
       128580
       +
                hspec-expectations lens lens-aeson lsp-test lsp-types prettyprinter

     

       128581
       128581
       +
                process text unordered-containers

     

       128260
       128582
        
              ];

     

       128261
       128583
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128584
       128584
       +
              benchmarkHaskellDepends = [

     

       128585
       128585
       +
                aeson base containers data-default directory extra filepath

     

       128586
       128586
       +
                ghcide-bench hls-plugin-api lens lens-aeson optparse-applicative

     

       128587
       128587
       +
                shake shake-bench text yaml

     

       128588
       128588
       +
              ];

     

       128589
       128589
       +
              benchmarkToolDepends = [ ghcide-bench hp2pretty implicit-hie ];

     

       128262
       128590
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128263
       128591
        
              license = lib.licenses.asl20;

     

       128264
       128592
        
              maintainers = [ lib.maintainers.maralorn ];

     
···

       128972
       129300
        
              ];

     

       128973
       129301
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       128974
       129302
        
              license = lib.licenses.bsd3;

     

       129303
       129303
       +
            }) {};

     

       129304
       129304
       +
       

     

       129305
       129305
       +
         "haskell-src-meta_0_8_11" = callPackage

     

       129306
       129306
       +
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       129307
       129307
       +
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       129308
       129308
       +
            }:

     

       129309
       129309
       +
            mkDerivation {

     

       129310
       129310
       +
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       129311
       129311
       +
              version = "0.8.11";

     

       129312
       129312
       +
              sha256 = "1wks0xb7ah2gj9n0ffbcaskjihy45l99qkf2h9k13cyfvqkzp9rw";

     

       129313
       129313
       +
              libraryHaskellDepends = [

     

       129314
       129314
       +
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       129315
       129315
       +
              ];

     

       129316
       129316
       +
              testHaskellDepends = [

     

       129317
       129317
       +
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       129318
       129318
       +
                template-haskell

     

       129319
       129319
       +
              ];

     

       129320
       129320
       +
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       129321
       129321
       +
              license = lib.licenses.bsd3;

     

       129322
       129322
       +
              hydraPlatforms = lib.platforms.none;

     

       128975
       129323
        
            }) {};

     

       128976
       129324
        
       

     

       128977
       129325
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     
···

       130238
       130586
        
            }:

     

       130239
       130587
        
            mkDerivation {

     

       130240
       130588
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       130241
       130241
       -
              version = "0.8.0.0";

     

       130242
       130242
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       130589
       130589
       +
              version = "0.8.0.1";

     

       130590
       130590
       +
              sha256 = "12q6j9z7hwb93sli4wk4lidlf3m7y3dazpp5ymvpbxnb7wjzirr6";

     

       130243
       130591
        
              isLibrary = true;

     

       130244
       130592
        
              isExecutable = true;

     

       130245
       130593
        
              libraryHaskellDepends = [

     
···

       130500
       130848
        
            }:

     

       130501
       130849
        
            mkDerivation {

     

       130502
       130850
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       130503
       130503
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       130504
       130504
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       130851
       130851
       +
              version = "0.65.5";

     

       130852
       130852
       +
              sha256 = "00w0y7agxmazfaq8ghkv8mppswxppdp8d02bcdnr70xfich8w3qc";

     

       130505
       130853
        
              isLibrary = true;

     

       130506
       130854
        
              isExecutable = true;

     

       130507
       130855
        
              libraryHaskellDepends = [

     
···

       130549
       130897
        
            }:

     

       130550
       130898
        
            mkDerivation {

     

       130551
       130899
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       130552
       130552
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       130553
       130553
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       130900
       130900
       +
              version = "0.65.5";

     

       130901
       130901
       +
              sha256 = "121vyncj8f2hwxd1j96d134c6fdr4lf3pqdrrj5n3gjb0rj61vn8";

     

       130554
       130902
        
              libraryHaskellDepends = [

     

       130555
       130903
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       130556
       130904
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     
···

       131445
       131793
        
              license = lib.licenses.mit;

     

       131446
       131794
        
            }) {};

     

       131447
       131795
        
       

     

       131448
       131448
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131449
       131449
       -
           ({ mkDerivation, attoparsec, base, bytestring

     

       131796
       131796
       +
         "hasql_1_6_1_3" = callPackage

     

       131797
       131797
       +
           ({ mkDerivation, aeson, attoparsec, base, bytestring

     

       131450
       131798
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131451
       131451
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131452
       131452
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131453
       131453
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131454
       131454
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131799
       131799
       +
            , dlist, gauge, hashable, hashtables, mtl, network-ip

     

       131800
       131800
       +
            , postgresql-binary, postgresql-libpq, profunctors, QuickCheck

     

       131801
       131801
       +
            , quickcheck-instances, rerebase, scientific, tasty, tasty-hunit

     

       131802
       131802
       +
            , tasty-quickcheck, text, text-builder, time, transformers, uuid

     

       131803
       131803
       +
            , vector

     

       131455
       131804
        
            }:

     

       131456
       131805
        
            mkDerivation {

     

       131457
       131806
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131458
       131458
       -
              version = "1.6.1.1";

     

       131459
       131459
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131807
       131807
       +
              version = "1.6.1.3";

     

       131808
       131808
       +
              sha256 = "0bqsv0g7kv2wb9inx7gbrasdyw03nyjjjdv1x8jghcdgz0nhb1jn";

     

       131460
       131809
        
              libraryHaskellDepends = [

     

       131461
       131461
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131462
       131462
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131463
       131463
       -
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       131810
       131810
       +
                aeson attoparsec base bytestring bytestring-strict-builder

     

       131811
       131811
       +
                contravariant dlist hashable hashtables mtl network-ip

     

       131812
       131812
       +
                postgresql-binary postgresql-libpq profunctors scientific text

     

       131813
       131813
       +
                text-builder time transformers uuid vector

     

       131464
       131814
        
              ];

     

       131465
       131815
        
              testHaskellDepends = [

     

       131466
       131816
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     
···

       133334
       133684
        
           ({ mkDerivation }:

     

       133335
       133685
        
            mkDerivation {

     

       133336
       133686
        
              pname = "hcom";

     

       133337
       133337
       -
              version = "0.0.0.5";

     

       133338
       133338
       -
              sha256 = "02f959qd7gm5gpa8w39hqj5a8pn6gizjif7rr7mwlq8g3gsq8gsk";

     

       133687
       133687
       +
              version = "0.0.0.6";

     

       133688
       133688
       +
              sha256 = "1793wnjrny1nydqnbvvh1wsq9qnnknf80fmpxvz281mdpjz6n1h2";

     

       133339
       133689
        
              doHaddock = false;

     

       133340
       133690
        
              description = "Haskell COM support library";

     

       133341
       133691
        
              license = lib.licenses.bsd3;

     
···

       137144
       137494
        
            }:

     

       137145
       137495
        
            mkDerivation {

     

       137146
       137496
        
              pname = "hgettext";

     

       137147
       137147
       -
              version = "0.1.40";

     

       137148
       137148
       -
              sha256 = "1qrmvgi0517zywqw3yvm7f86766sv6hanchv6cr54vm2z9r88ciy";

     

       137497
       137497
       +
              version = "0.1.40.1";

     

       137498
       137498
       +
              sha256 = "1wdwrp4zjhjjq49yihid9x4lhx26nbixax84njj02d79wq2kmdb7";

     

       137149
       137499
        
              isLibrary = true;

     

       137150
       137500
        
              isExecutable = true;

     

       137151
       137501
        
              libraryHaskellDepends = [

     
···

       137390
       137740
        
            }:

     

       137391
       137741
        
            mkDerivation {

     

       137392
       137742
        
              pname = "hhp";

     

       137393
       137393
       -
              version = "1.0.0";

     

       137394
       137394
       -
              sha256 = "0jwn10k2v3i8w57mx5w8czvgaw483dp9fdf1w214qr9dz654sb9a";

     

       137743
       137743
       +
              version = "1.0.1";

     

       137744
       137744
       +
              sha256 = "0926x82vbndj3mahh7pix0gfc5jjr1yl499ggkgfdc55mykr4bn9";

     

       137395
       137745
        
              isLibrary = true;

     

       137396
       137746
        
              isExecutable = true;

     

       137397
       137747
        
              enableSeparateDataOutput = true;

     
···

       137617
       137967
        
       

     

       137618
       137968
        
         "hie-bios" = callPackage

     

       137619
       137969
        
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       137620
       137620
       -
            , conduit, conduit-extra, containers, cryptohash-sha1, deepseq

     

       137621
       137621
       -
            , directory, exceptions, extra, file-embed, filepath, ghc, hslogger

     

       137622
       137622
       -
            , optparse-applicative, process, tagged, tasty

     

       137623
       137623
       -
            , tasty-expected-failure, tasty-hunit, temporary, text, time

     

       137624
       137624
       -
            , transformers, unix-compat, unordered-containers, vector, yaml

     

       137625
       137625
       -
            }:

     

       137626
       137626
       -
            mkDerivation {

     

       137627
       137627
       -
              pname = "hie-bios";

     

       137628
       137628
       -
              version = "0.9.1";

     

       137629
       137629
       -
              sha256 = "0pcbgrn0hl19rk72z7mcd44j72lsmnl88nlk95rlb47l0ymr3ij1";

     

       137630
       137630
       -
              revision = "1";

     

       137631
       137631
       -
              editedCabalFile = "1hvhln1mnvghs05959fi5i71gaw04zhdk4wg558h2p4ybjcjsvb5";

     

       137632
       137632
       -
              isLibrary = true;

     

       137633
       137633
       -
              isExecutable = true;

     

       137634
       137634
       -
              libraryHaskellDepends = [

     

       137635
       137635
       -
                aeson base base16-bytestring bytestring conduit conduit-extra

     

       137636
       137636
       -
                containers cryptohash-sha1 deepseq directory exceptions extra

     

       137637
       137637
       -
                file-embed filepath ghc hslogger process temporary text time

     

       137638
       137638
       -
                transformers unix-compat unordered-containers vector yaml

     

       137639
       137639
       -
              ];

     

       137640
       137640
       -
              executableHaskellDepends = [

     

       137641
       137641
       -
                base directory filepath ghc optparse-applicative

     

       137642
       137642
       -
              ];

     

       137643
       137643
       -
              testHaskellDepends = [

     

       137644
       137644
       -
                aeson base directory extra filepath ghc tagged tasty

     

       137645
       137645
       -
                tasty-expected-failure tasty-hunit temporary text

     

       137646
       137646
       -
                unordered-containers yaml

     

       137647
       137647
       -
              ];

     

       137648
       137648
       -
              description = "Set up a GHC API session";

     

       137649
       137649
       -
              license = lib.licenses.bsd3;

     

       137650
       137650
       -
              mainProgram = "hie-bios";

     

       137651
       137651
       -
            }) {};

     

       137652
       137652
       -
       

     

       137653
       137653
       -
         "hie-bios_0_10_0" = callPackage

     

       137654
       137654
       -
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       137655
       137970
        
            , co-log-core, conduit, conduit-extra, containers, cryptohash-sha1

     

       137656
       137971
        
            , deepseq, directory, exceptions, extra, file-embed, filepath, ghc

     

       137657
       137972
        
            , optparse-applicative, prettyprinter, process, tagged, tasty

     
···

       137660
       137975
        
            }:

     

       137661
       137976
        
            mkDerivation {

     

       137662
       137977
        
              pname = "hie-bios";

     

       137663
       137663
       -
              version = "0.10.0";

     

       137664
       137664
       -
              sha256 = "0k9d106y46dqwr5dw6yzmqvb03gshlp6qbzznz67qkwbkj2calyz";

     

       137665
       137665
       -
              revision = "1";

     

       137666
       137666
       -
              editedCabalFile = "1brqph8n754kv0jgrjg12jhgpzsx92m5jafx8wjnm5gf2ri7ip8h";

     

       137978
       137978
       +
              version = "0.11.0";

     

       137979
       137979
       +
              sha256 = "1vqfbyi1jlgzrvl9njgdhvj1hp0b7rl4xpchyldpf179151vy24p";

     

       137667
       137980
        
              isLibrary = true;

     

       137668
       137981
        
              isExecutable = true;

     

       137669
       137982
        
              libraryHaskellDepends = [

     
···

       137679
       137992
        
              ];

     

       137680
       137993
        
              testHaskellDepends = [

     

       137681
       137994
        
                aeson base directory extra filepath ghc tagged tasty

     

       137682
       137682
       -
                tasty-expected-failure tasty-hunit temporary text

     

       137995
       137995
       +
                tasty-expected-failure tasty-hunit temporary text transformers

     

       137683
       137996
        
                unordered-containers yaml

     

       137684
       137997
        
              ];

     

       137685
       137998
        
              description = "Set up a GHC API session";

     

       137686
       137999
        
              license = lib.licenses.bsd3;

     

       137687
       137687
       -
              hydraPlatforms = lib.platforms.none;

     

       137688
       138000
        
              mainProgram = "hie-bios";

     

       137689
       138001
        
            }) {};

     

       137690
       138002
        
       

     
···

       137694
       138006
        
            }:

     

       137695
       138007
        
            mkDerivation {

     

       137696
       138008
        
              pname = "hie-compat";

     

       137697
       137697
       -
              version = "0.2.1.1";

     

       137698
       137698
       -
              sha256 = "054ll31b2j31a2yjcz7q7zxqyyszrkbaz4kzxhih4k84v9h0nhk6";

     

       138009
       138009
       +
              version = "0.3.0.0";

     

       138010
       138010
       +
              sha256 = "169175gn1699k2w7w8ific49qmvw8h1gh585k3pzfwb921lyj0mb";

     

       137699
       138011
        
              libraryHaskellDepends = [

     

       137700
       138012
        
                array base bytestring containers directory filepath ghc ghc-boot

     

       137701
       138013
        
                transformers

     
···

       137750
       138062
        
            }:

     

       137751
       138063
        
            mkDerivation {

     

       137752
       138064
        
              pname = "hiedb";

     

       137753
       137753
       -
              version = "0.4.1.0";

     

       137754
       137754
       -
              sha256 = "1389qmlga5rq8has02rn35pzag5wnfpx3w77r60mzl3b4pkpzi7i";

     

       137755
       137755
       -
              revision = "3";

     

       137756
       137756
       -
              editedCabalFile = "0y6vsx4n3hbpbl6d9qpb5d40s2rh0pkqm76gnjvx045zvrdkxi66";

     

       138065
       138065
       +
              version = "0.4.2.0";

     

       138066
       138066
       +
              sha256 = "025rc75wfb3dpnxrd5r3jvxm8x1wpb3m0zya69y78pbama753jlw";

     

       137757
       138067
        
              isLibrary = true;

     

       137758
       138068
        
              isExecutable = true;

     

       137759
       138069
        
              libraryHaskellDepends = [

     
···

       138879
       139189
        
              mainProgram = "hipsql-demo-server";

     

       138880
       139190
        
            }) {};

     

       138881
       139191
        
       

     

       139192
       139192
       +
         "hipsql-tx-simple" = callPackage

     

       139193
       139193
       +
           ({ mkDerivation, base, hipsql-monad, hipsql-server

     

       139194
       139194
       +
            , postgresql-simple, postgresql-tx

     

       139195
       139195
       +
            }:

     

       139196
       139196
       +
            mkDerivation {

     

       139197
       139197
       +
              pname = "hipsql-tx-simple";

     

       139198
       139198
       +
              version = "0.0.0.0";

     

       139199
       139199
       +
              sha256 = "17ab2k9q7d5xqjbqr6r22xlgi3hnw20cq1lw2ambhvzwdlb0z9kw";

     

       139200
       139200
       +
              libraryHaskellDepends = [

     

       139201
       139201
       +
                base hipsql-monad hipsql-server postgresql-simple postgresql-tx

     

       139202
       139202
       +
              ];

     

       139203
       139203
       +
              license = lib.licenses.bsd3;

     

       139204
       139204
       +
              hydraPlatforms = lib.platforms.none;

     

       139205
       139205
       +
            }) {};

     

       139206
       139206
       +
       

     

       138882
       139207
        
         "hircules" = callPackage

     

       138883
       139208
        
           ({ mkDerivation, base, containers, directory, gtk, mtl, network

     

       138884
       139209
        
            , old-locale, old-time, time, utf8-string

     
···

       139414
       139739
        
           ({ mkDerivation, base, some }:

     

       139415
       139740
        
            mkDerivation {

     

       139416
       139741
        
              pname = "hkd";

     

       139417
       139417
       -
              version = "0.1";

     

       139418
       139418
       -
              sha256 = "1xz0i8lkh0rp55b0s7npkzqgyz9pf1bwq9b66cwbg073r9sz41wa";

     

       139419
       139419
       -
              revision = "4";

     

       139420
       139420
       -
              editedCabalFile = "08qjy1616ypa6r0jwh5m66dlvnj87k4cdcggi28caadzg8cf1fz5";

     

       139742
       139742
       +
              version = "0.2";

     

       139743
       139743
       +
              sha256 = "1sq0w5n6y7m2qqpl9s04hsg14qc7p8xrj4x1s1lhw9qbapwb8g8w";

     

       139421
       139744
        
              libraryHaskellDepends = [ base some ];

     

       139422
       139745
        
              testHaskellDepends = [ base some ];

     

       139423
       139746
        
              description = "\"higher-kinded data\"";

     
···

       139463
       139786
        
            }) {};

     

       139464
       139787
        
       

     

       139465
       139788
        
         "hkd-records" = callPackage

     

       139466
       139466
       -
           ({ mkDerivation, base, hkd, text }:

     

       139789
       139789
       +
           ({ mkDerivation, base, hkd, template-haskell, text }:

     

       139467
       139790
        
            mkDerivation {

     

       139468
       139791
        
              pname = "hkd-records";

     

       139469
       139469
       -
              version = "0.0.2";

     

       139470
       139470
       -
              sha256 = "1404c3gqrk2i0ab67v12h5khcghbkad7cyphfmp6kkn8d5smpz1m";

     

       139471
       139471
       -
              libraryHaskellDepends = [ base hkd text ];

     

       139792
       139792
       +
              version = "0.0.6";

     

       139793
       139793
       +
              sha256 = "0wgavxkpsk9qmqz1vnabr2bi679pd8sfn1kpf5s73bsq81mif09h";

     

       139794
       139794
       +
              libraryHaskellDepends = [ base hkd template-haskell text ];

     

       139472
       139795
        
              description = "higher kinded record operations";

     

       139473
       139796
        
              license = lib.licenses.bsd3;

     

       139797
       139797
       +
              hydraPlatforms = lib.platforms.none;

     

       139798
       139798
       +
              broken = true;

     

       139474
       139799
        
            }) {};

     

       139475
       139800
        
       

     

       139476
       139801
        
         "hkdf" = callPackage

     
···

       139672
       139997
        
              maintainers = [ lib.maintainers.peti ];

     

       139673
       139998
        
            }) {};

     

       139674
       139999
        
       

     

       139675
       139675
       -
         "hledger_1_27" = callPackage

     

       140000
       140000
       +
         "hledger_1_27_1" = callPackage

     

       139676
       140001
        
           ({ mkDerivation, aeson, ansi-terminal, base, breakpoint, bytestring

     

       139677
       140002
        
            , cmdargs, containers, data-default, Decimal, Diff, directory

     

       139678
       140003
        
            , extra, filepath, githash, hashable, haskeline, hledger-lib, lucid

     
···

       139683
       140008
        
            }:

     

       139684
       140009
        
            mkDerivation {

     

       139685
       140010
        
              pname = "hledger";

     

       139686
       139686
       -
              version = "1.27";

     

       139687
       139687
       -
              sha256 = "0v74wja2rd9ip1993p0sv7pwl2f0k4rapd6r6s5wq0c5j50s2wpq";

     

       140011
       140011
       +
              version = "1.27.1";

     

       140012
       140012
       +
              sha256 = "0qdg87m7ys2ykqqq32p7h7aw827w4f5bcqx4dspxxq6zqlvzddqb";

     

       139688
       140013
        
              isLibrary = true;

     

       139689
       140014
        
              isExecutable = true;

     

       139690
       140015
        
              libraryHaskellDepends = [

     
···

       139941
       140266
        
              license = lib.licenses.gpl3Only;

     

       139942
       140267
        
            }) {};

     

       139943
       140268
        
       

     

       139944
       139944
       -
         "hledger-lib_1_27" = callPackage

     

       140269
       140269
       +
         "hledger-lib_1_27_1" = callPackage

     

       139945
       140270
        
           ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array, base

     

       139946
       140271
        
            , blaze-markup, breakpoint, bytestring, call-stack, cassava

     

       139947
       140272
        
            , cassava-megaparsec, cmdargs, containers, data-default, Decimal

     
···

       139953
       140278
        
            }:

     

       139954
       140279
        
            mkDerivation {

     

       139955
       140280
        
              pname = "hledger-lib";

     

       139956
       139956
       -
              version = "1.27";

     

       139957
       139957
       -
              sha256 = "0l52dhpglvjsw1dllidpqd38gc2djm2mxlcidsm1iil93812vmyp";

     

       140281
       140281
       +
              version = "1.27.1";

     

       140282
       140282
       +
              sha256 = "0w2jnpyfc6pp3n5fzdjd78hdh9vv9w98xwd2j6dw98rm6hlapwhb";

     

       139958
       140283
        
              libraryHaskellDepends = [

     

       139959
       140284
        
                aeson aeson-pretty ansi-terminal array base blaze-markup breakpoint

     

       139960
       140285
        
                bytestring call-stack cassava cassava-megaparsec cmdargs containers

     
···

       140086
       140411
        
              maintainers = [ lib.maintainers.peti ];

     

       140087
       140412
        
            }) {};

     

       140088
       140413
        
       

     

       140089
       140089
       -
         "hledger-ui_1_27" = callPackage

     

       140414
       140414
       +
         "hledger-ui_1_27_1" = callPackage

     

       140090
       140415
        
           ({ mkDerivation, ansi-terminal, async, base, breakpoint, brick

     

       140091
       140416
        
            , cmdargs, containers, data-default, directory, doclayout, extra

     

       140092
       140417
        
            , filepath, fsnotify, hledger, hledger-lib, megaparsec, microlens

     
···

       140095
       140420
        
            }:

     

       140096
       140421
        
            mkDerivation {

     

       140097
       140422
        
              pname = "hledger-ui";

     

       140098
       140098
       -
              version = "1.27";

     

       140099
       140099
       -
              sha256 = "06gkzzckq3bq5z0svi498zvsi9hzgrkzvf8736s28mcazdlkxdj1";

     

       140423
       140423
       +
              version = "1.27.1";

     

       140424
       140424
       +
              sha256 = "1srzlz0mdcp0259k0vsc8xkisd9l59s30j1k1x9bnsn179n8bi22";

     

       140100
       140425
        
              isLibrary = false;

     

       140101
       140426
        
              isExecutable = true;

     

       140102
       140427
        
              executableHaskellDepends = [

     
···

       140169
       140494
        
              maintainers = [ lib.maintainers.peti ];

     

       140170
       140495
        
            }) {};

     

       140171
       140496
        
       

     

       140172
       140172
       -
         "hledger-web_1_27" = callPackage

     

       140497
       140497
       +
         "hledger-web_1_27_1" = callPackage

     

       140173
       140498
        
           ({ mkDerivation, aeson, base, base64, blaze-html, blaze-markup

     

       140174
       140499
        
            , breakpoint, bytestring, case-insensitive, clientsession, cmdargs

     

       140175
       140500
        
            , conduit, conduit-extra, containers, data-default, Decimal

     
···

       140182
       140507
        
            }:

     

       140183
       140508
        
            mkDerivation {

     

       140184
       140509
        
              pname = "hledger-web";

     

       140185
       140185
       -
              version = "1.27";

     

       140186
       140186
       -
              sha256 = "0j4xdpxhx83g4pg4w2x81x93ca3apwdnpgjig43x16p1gc04kvw4";

     

       140510
       140510
       +
              version = "1.27.1";

     

       140511
       140511
       +
              sha256 = "151dxci7dld8626dzw823sr3d9iaac92wfzbfcbdz4jh9f7n07wa";

     

       140187
       140512
        
              isLibrary = true;

     

       140188
       140513
        
              isExecutable = true;

     

       140189
       140514
        
              libraryHaskellDepends = [

     
···

       140296
       140621
        
              license = lib.licenses.mit;

     

       140297
       140622
        
            }) {inherit (pkgs) libsass;};

     

       140298
       140623
        
       

     

       140624
       140624
       +
         "hlint_3_2_8" = callPackage

     

       140625
       140625
       +
           ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs

     

       140626
       140626
       +
            , containers, cpphs, data-default, directory, extra, file-embed

     

       140627
       140627
       +
            , filepath, filepattern, ghc-lib-parser, ghc-lib-parser-ex

     

       140628
       140628
       +
            , hscolour, process, refact, text, transformers, uniplate

     

       140629
       140629
       +
            , unordered-containers, utf8-string, vector, yaml

     

       140630
       140630
       +
            }:

     

       140631
       140631
       +
            mkDerivation {

     

       140632
       140632
       +
              pname = "hlint";

     

       140633
       140633
       +
              version = "3.2.8";

     

       140634
       140634
       +
              sha256 = "14nvq71kn1lhqx02r69f949p33rhxi466fwmxj9g0wd5191jawrs";

     

       140635
       140635
       +
              isLibrary = true;

     

       140636
       140636
       +
              isExecutable = true;

     

       140637
       140637
       +
              enableSeparateDataOutput = true;

     

       140638
       140638
       +
              libraryHaskellDepends = [

     

       140639
       140639
       +
                aeson ansi-terminal base bytestring cmdargs containers cpphs

     

       140640
       140640
       +
                data-default directory extra file-embed filepath filepattern

     

       140641
       140641
       +
                ghc-lib-parser ghc-lib-parser-ex hscolour process refact text

     

       140642
       140642
       +
                transformers uniplate unordered-containers utf8-string vector yaml

     

       140643
       140643
       +
              ];

     

       140644
       140644
       +
              executableHaskellDepends = [ base ];

     

       140645
       140645
       +
              description = "Source code suggestions";

     

       140646
       140646
       +
              license = lib.licenses.bsd3;

     

       140647
       140647
       +
              hydraPlatforms = lib.platforms.none;

     

       140648
       140648
       +
              mainProgram = "hlint";

     

       140649
       140649
       +
              maintainers = [ lib.maintainers.maralorn ];

     

       140650
       140650
       +
            }) {};

     

       140651
       140651
       +
       

     

       140299
       140652
        
         "hlint" = callPackage

     

       140300
       140653
        
           ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs

     

       140301
       140654
        
            , containers, cpphs, data-default, directory, extra, file-embed

     
···

       140490
       140843
        
            }:

     

       140491
       140844
        
            mkDerivation {

     

       140492
       140845
        
              pname = "hls-alternate-number-format-plugin";

     

       140493
       140493
       -
              version = "1.1.0.0";

     

       140494
       140494
       -
              sha256 = "1s81p2jnln8v8ny13cf26d9925lfcyhs5di5xbh3p9645ngdiy9h";

     

       140846
       140846
       +
              version = "1.2.0.0";

     

       140847
       140847
       +
              sha256 = "1rwb24nnwqgqm08yq8737sfan3zvfnccympjrnfjqdj0xihb77j0";

     

       140495
       140848
        
              libraryHaskellDepends = [

     

       140496
       140849
        
                aeson base containers ghc-boot-th ghcide hie-compat hls-graph

     

       140497
       140850
        
                hls-plugin-api lens lsp mtl regex-tdfa syb text

     
···

       140512
       140865
        
            }:

     

       140513
       140866
        
            mkDerivation {

     

       140514
       140867
        
              pname = "hls-brittany-plugin";

     

       140515
       140515
       -
              version = "1.0.2.1";

     

       140516
       140516
       -
              sha256 = "0f86iymcinbad9cpghi7965xhv4ky6kq4jqsn7nndq2jklwgrw7i";

     

       140868
       140868
       +
              version = "1.0.2.2";

     

       140869
       140869
       +
              sha256 = "0spr7qmqjkg0aqr16cp9pi5dqc10lskhqa6mpx49z0rifhk84hay";

     

       140517
       140870
        
              libraryHaskellDepends = [

     

       140518
       140871
        
                base brittany czipwith extra filepath ghc-boot-th ghc-exactprint

     

       140519
       140872
        
                ghcide hls-plugin-api lens lsp-types text transformers

     
···

       140530
       140883
        
            }:

     

       140531
       140884
        
            mkDerivation {

     

       140532
       140885
        
              pname = "hls-call-hierarchy-plugin";

     

       140533
       140533
       -
              version = "1.0.3.0";

     

       140534
       140534
       -
              sha256 = "0yfl75d2ddkzrz3p1pn8spra0qssqazsqklan46zmagrv69yg5iv";

     

       140886
       140886
       +
              version = "1.1.0.0";

     

       140887
       140887
       +
              sha256 = "1010lwrgp3qs3i9rpsphfiq72d8qisvz4jn9rn09h1wdc10bl7sg";

     

       140535
       140888
        
              libraryHaskellDepends = [

     

       140536
       140889
        
                aeson base bytestring containers extra ghc ghcide hiedb

     

       140537
       140890
        
                hls-plugin-api lens lsp sqlite-simple text unordered-containers

     
···

       140551
       140904
        
            }:

     

       140552
       140905
        
            mkDerivation {

     

       140553
       140906
        
              pname = "hls-change-type-signature-plugin";

     

       140554
       140554
       -
              version = "1.0.1.0";

     

       140555
       140555
       -
              sha256 = "0wl4vgml491gkvzmsfj3nlwx18ywvrdwgwdkqjp0rwid0pidd6z8";

     

       140556
       140556
       -
              revision = "1";

     

       140557
       140557
       -
              editedCabalFile = "0kz9zrjrpy5c84mj45spf75sklyhlvfdl5v526bpaiaphihzbr80";

     

       140907
       140907
       +
              version = "1.0.1.1";

     

       140908
       140908
       +
              sha256 = "1sgnx7jl7cfklds2vka4sbrc7462spmjfhw34r7kn52m1079x1k2";

     

       140558
       140909
        
              libraryHaskellDepends = [

     

       140559
       140910
        
                base ghcide hls-plugin-api lsp-types regex-tdfa syb text

     

       140560
       140911
        
                transformers unordered-containers

     
···

       140567
       140918
        
            }) {};

     

       140568
       140919
        
       

     

       140569
       140920
        
         "hls-class-plugin" = callPackage

     

       140570
       140570
       -
           ({ mkDerivation, aeson, base, containers, filepath, ghc

     

       140571
       140571
       -
            , ghc-exactprint, ghcide, hls-plugin-api, hls-test-utils, lens, lsp

     

       140572
       140572
       -
            , lsp-types, text, transformers

     

       140921
       140921
       +
           ({ mkDerivation, aeson, base, containers, deepseq, extra, filepath

     

       140922
       140922
       +
            , ghc, ghc-boot-th, ghc-exactprint, ghcide, hls-graph

     

       140923
       140923
       +
            , hls-plugin-api, hls-test-utils, lens, lsp, lsp-types, text

     

       140924
       140924
       +
            , transformers

     

       140573
       140925
        
            }:

     

       140574
       140926
        
            mkDerivation {

     

       140575
       140927
        
              pname = "hls-class-plugin";

     

       140576
       140576
       -
              version = "1.0.3.0";

     

       140577
       140577
       -
              sha256 = "0ad7ypw7d8waz3nq9p6m8l91rcibd2fzxxmdrpncwshiyrhazq3l";

     

       140928
       140928
       +
              version = "1.1.0.0";

     

       140929
       140929
       +
              sha256 = "049vz69a0xfbc8b3lhf35lcss2pig7nrln6k7n2y5f28dhb3dy00";

     

       140578
       140930
        
              libraryHaskellDepends = [

     

       140579
       140579
       -
                aeson base containers ghc ghc-exactprint ghcide hls-plugin-api lens

     

       140580
       140580
       -
                lsp text transformers

     

       140931
       140931
       +
                aeson base containers deepseq extra ghc ghc-boot-th ghc-exactprint

     

       140932
       140932
       +
                ghcide hls-graph hls-plugin-api lens lsp text transformers

     

       140581
       140933
        
              ];

     

       140582
       140934
        
              testHaskellDepends = [

     

       140583
       140583
       -
                base filepath hls-test-utils lens lsp-types

     

       140935
       140935
       +
                aeson base filepath ghcide hls-plugin-api hls-test-utils lens

     

       140936
       140936
       +
                lsp-types

     

       140584
       140937
        
              ];

     

       140585
       140938
        
              description = "Class/instance management plugin for Haskell Language Server";

     

       140586
       140939
        
              license = lib.licenses.asl20;

     

       140587
       140940
        
            }) {};

     

       140588
       140941
        
       

     

       140942
       140942
       +
         "hls-code-range-plugin" = callPackage

     

       140943
       140943
       +
           ({ mkDerivation, aeson, base, bytestring, containers, deepseq

     

       140944
       140944
       +
            , extra, filepath, ghcide, hashable, hls-plugin-api, hls-test-utils

     

       140945
       140945
       +
            , lens, lsp, lsp-test, mtl, semigroupoids, tasty-hunit, text

     

       140946
       140946
       +
            , transformers, vector

     

       140947
       140947
       +
            }:

     

       140948
       140948
       +
            mkDerivation {

     

       140949
       140949
       +
              pname = "hls-code-range-plugin";

     

       140950
       140950
       +
              version = "1.0.0.0";

     

       140951
       140951
       +
              sha256 = "1jk0nklplwbdikp1y5r1w7l0ab3i28isibdd15prcxjf98rsp8m9";

     

       140952
       140952
       +
              libraryHaskellDepends = [

     

       140953
       140953
       +
                aeson base containers deepseq extra ghcide hashable hls-plugin-api

     

       140954
       140954
       +
                lens lsp mtl semigroupoids text transformers vector

     

       140955
       140955
       +
              ];

     

       140956
       140956
       +
              testHaskellDepends = [

     

       140957
       140957
       +
                base bytestring containers filepath ghcide hls-test-utils lens lsp

     

       140958
       140958
       +
                lsp-test tasty-hunit text transformers vector

     

       140959
       140959
       +
              ];

     

       140960
       140960
       +
              description = "HLS Plugin to support smart selection range";

     

       140961
       140961
       +
              license = lib.licenses.asl20;

     

       140962
       140962
       +
            }) {};

     

       140963
       140963
       +
       

     

       140589
       140964
        
         "hls-eval-plugin" = callPackage

     

       140590
       140965
        
           ({ mkDerivation, aeson, base, containers, data-default, deepseq

     

       140591
       140966
        
            , Diff, directory, dlist, extra, filepath, ghc, ghc-boot-th

     
···

       140596
       140971
        
            }:

     

       140597
       140972
        
            mkDerivation {

     

       140598
       140973
        
              pname = "hls-eval-plugin";

     

       140599
       140599
       -
              version = "1.2.2.0";

     

       140600
       140600
       -
              sha256 = "17si94yzxz19hcddn57wf0npxc9m9vzb08b2gph7pkbxprsksb6g";

     

       140601
       140601
       -
              revision = "1";

     

       140602
       140602
       -
              editedCabalFile = "1hilh189fmqbm65cmsn2j70n83dq356xq1r6mf893chxwins57p3";

     

       140974
       140974
       +
              version = "1.3.0.0";

     

       140975
       140975
       +
              sha256 = "0nzrlggabh8s822zc0hirqj943f9b7hkd45yl3dhf2vkgxwm377s";

     

       140603
       140976
        
              libraryHaskellDepends = [

     

       140604
       140977
        
                aeson base containers data-default deepseq Diff directory dlist

     

       140605
       140978
        
                extra filepath ghc ghc-boot-th ghc-paths ghcide hashable hls-graph

     
···

       140634
       141007
        
              broken = true;

     

       140635
       141008
        
            }) {};

     

       140636
       141009
        
       

     

       141010
       141010
       +
         "hls-explicit-fixity-plugin" = callPackage

     

       141011
       141011
       +
           ({ mkDerivation, base, containers, deepseq, extra, filepath, ghc

     

       141012
       141012
       +
            , ghcide, hashable, hls-plugin-api, hls-test-utils, lsp, text

     

       141013
       141013
       +
            }:

     

       141014
       141014
       +
            mkDerivation {

     

       141015
       141015
       +
              pname = "hls-explicit-fixity-plugin";

     

       141016
       141016
       +
              version = "1.0.0.0";

     

       141017
       141017
       +
              sha256 = "0nwfx9k6yaja3qm2s3bckyfl7qagfb1cly602xcrzrc85q1zg4lx";

     

       141018
       141018
       +
              libraryHaskellDepends = [

     

       141019
       141019
       +
                base containers deepseq extra ghc ghcide hashable hls-plugin-api

     

       141020
       141020
       +
                lsp text

     

       141021
       141021
       +
              ];

     

       141022
       141022
       +
              testHaskellDepends = [ base filepath hls-test-utils text ];

     

       141023
       141023
       +
              description = "Show fixity explicitly while hovering";

     

       141024
       141024
       +
              license = lib.licenses.asl20;

     

       141025
       141025
       +
            }) {};

     

       141026
       141026
       +
       

     

       140637
       141027
        
         "hls-explicit-imports-plugin" = callPackage

     

       140638
       141028
        
           ({ mkDerivation, aeson, base, containers, deepseq, filepath, ghc

     

       140639
       141029
        
            , ghcide, hls-graph, hls-plugin-api, hls-test-utils, lsp, text

     
···

       140641
       141031
        
            }:

     

       140642
       141032
        
            mkDerivation {

     

       140643
       141033
        
              pname = "hls-explicit-imports-plugin";

     

       140644
       140644
       -
              version = "1.1.0.0";

     

       140645
       140645
       -
              sha256 = "1r5cy59xk35d6smnrka42hxfa012h45nvsmlr1a1kbyac8ywzf6m";

     

       141034
       141034
       +
              version = "1.1.0.1";

     

       141035
       141035
       +
              sha256 = "0xdh9mvhdq9cgw33gi6q46ik010d6mv5acxj07pwca48dks3c2bx";

     

       140646
       141036
        
              libraryHaskellDepends = [

     

       140647
       141037
        
                aeson base containers deepseq ghc ghcide hls-graph hls-plugin-api

     

       140648
       141038
        
                lsp text unordered-containers

     
···

       140658
       141048
        
            }:

     

       140659
       141049
        
            mkDerivation {

     

       140660
       141050
        
              pname = "hls-floskell-plugin";

     

       140661
       140661
       -
              version = "1.0.1.1";

     

       140662
       140662
       -
              sha256 = "01c8xwfdgx5g5ipb366q0smjisyq1dfjz7scjfg5p3lyn0v555wb";

     

       141051
       141051
       +
              version = "1.0.1.2";

     

       141052
       141052
       +
              sha256 = "06klnrgz6jsxxsy4gpf2mcnbj35kd9gp3xy9l0pyhki14fhi5y4p";

     

       140663
       141053
        
              libraryHaskellDepends = [

     

       140664
       141054
        
                base floskell ghcide hls-plugin-api lsp-types text transformers

     

       140665
       141055
        
              ];

     
···

       140675
       141065
        
            }:

     

       140676
       141066
        
            mkDerivation {

     

       140677
       141067
        
              pname = "hls-fourmolu-plugin";

     

       140678
       140678
       -
              version = "1.0.3.0";

     

       140679
       140679
       -
              sha256 = "103rndxbmv72ghbh685766498j9rqnmgdwsrswk5nrf7afwd9x8w";

     

       140680
       140680
       -
              revision = "1";

     

       140681
       140681
       -
              editedCabalFile = "1y7jbjzi68x8xxqwhczn4z4nqis2gczggzv65fyvxhlzympsrg28";

     

       141068
       141068
       +
              version = "1.1.0.0";

     

       141069
       141069
       +
              sha256 = "1b3yzzg7lkf57qlv8hr7y15kd88dxijzxhardi27l4p6kh2bv1r1";

     

       140682
       141070
        
              libraryHaskellDepends = [

     

       140683
       141071
        
                base filepath fourmolu ghc ghc-boot-th ghcide hls-plugin-api lens

     

       140684
       141072
        
                lsp process-extras text

     
···

       140692
       141080
        
              license = lib.licenses.asl20;

     

       140693
       141081
        
            }) {};

     

       140694
       141082
        
       

     

       141083
       141083
       +
         "hls-gadt-plugin" = callPackage

     

       141084
       141084
       +
           ({ mkDerivation, aeson, base, containers, extra, filepath, ghc

     

       141085
       141085
       +
            , ghc-boot-th, ghc-exactprint, ghcide, hls-plugin-api

     

       141086
       141086
       +
            , hls-refactor-plugin, hls-test-utils, lens, lsp, lsp-test, mtl

     

       141087
       141087
       +
            , text, transformers, unordered-containers

     

       141088
       141088
       +
            }:

     

       141089
       141089
       +
            mkDerivation {

     

       141090
       141090
       +
              pname = "hls-gadt-plugin";

     

       141091
       141091
       +
              version = "1.0.0.0";

     

       141092
       141092
       +
              sha256 = "09k1ykb7694v9zmhr78dwbwdp33zvs3vnbq02hsinchhaqb3xj54";

     

       141093
       141093
       +
              libraryHaskellDepends = [

     

       141094
       141094
       +
                aeson base containers extra ghc ghc-boot-th ghc-exactprint ghcide

     

       141095
       141095
       +
                hls-plugin-api hls-refactor-plugin lens lsp mtl text transformers

     

       141096
       141096
       +
                unordered-containers

     

       141097
       141097
       +
              ];

     

       141098
       141098
       +
              testHaskellDepends = [

     

       141099
       141099
       +
                base filepath hls-test-utils lens lsp lsp-test text

     

       141100
       141100
       +
              ];

     

       141101
       141101
       +
              description = "Convert to GADT syntax plugin";

     

       141102
       141102
       +
              license = lib.licenses.asl20;

     

       141103
       141103
       +
            }) {};

     

       141104
       141104
       +
       

     

       140695
       141105
        
         "hls-graph" = callPackage

     

       140696
       141106
        
           ({ mkDerivation, aeson, async, base, bytestring, containers

     

       140697
       141107
        
            , deepseq, directory, exceptions, extra, filepath, focus, hashable

     

       140698
       141108
        
            , hspec, hspec-discover, js-dgtable, js-flot, js-jquery, list-t

     

       140699
       141109
        
            , primitive, stm, stm-containers, tasty, tasty-hspec, tasty-hunit

     

       140700
       140700
       -
            , tasty-rerun, text, time, transformers, unordered-containers

     

       141110
       141110
       +
            , tasty-rerun, text, time, transformers, unliftio

     

       141111
       141111
       +
            , unordered-containers

     

       140701
       141112
        
            }:

     

       140702
       141113
        
            mkDerivation {

     

       140703
       141114
        
              pname = "hls-graph";

     

       140704
       140704
       -
              version = "1.7.0.0";

     

       140705
       140705
       -
              sha256 = "1mq1pvn5z8fnlsj9iqck05shm8fak9zf05mbcbrxb5jvq0a31ypd";

     

       140706
       140706
       -
              revision = "1";

     

       140707
       140707
       -
              editedCabalFile = "090jis882l9pjg6dlw8dbf7qzq4g2rbrfwkl96rk7p4yw0hdgd01";

     

       141115
       141115
       +
              version = "1.8.0.0";

     

       141116
       141116
       +
              sha256 = "02lliak6nn2cjah0xvwgxb2gsryckgqjly064p4x7f10anrfw62a";

     

       140708
       141117
        
              enableSeparateDataOutput = true;

     

       140709
       141118
        
              libraryHaskellDepends = [

     

       140710
       141119
        
                aeson async base bytestring containers deepseq directory exceptions

     

       140711
       141120
        
                extra filepath focus hashable js-dgtable js-flot js-jquery list-t

     

       140712
       140712
       -
                primitive stm stm-containers time transformers unordered-containers

     

       141121
       141121
       +
                primitive stm stm-containers time transformers unliftio

     

       141122
       141122
       +
                unordered-containers

     

       140713
       141123
        
              ];

     

       140714
       141124
        
              testHaskellDepends = [

     

       140715
       141125
        
                base containers directory extra filepath hspec stm stm-containers

     

       140716
       140716
       -
                tasty tasty-hspec tasty-hunit tasty-rerun text

     

       141126
       141126
       +
                tasty tasty-hspec tasty-hunit tasty-rerun text unordered-containers

     

       140717
       141127
        
              ];

     

       140718
       141128
        
              testToolDepends = [ hspec-discover ];

     

       140719
       141129
        
              description = "Haskell Language Server internal graph API";

     
···

       140722
       141132
        
       

     

       140723
       141133
        
         "hls-haddock-comments-plugin" = callPackage

     

       140724
       141134
        
           ({ mkDerivation, base, containers, filepath, ghc, ghc-exactprint

     

       140725
       140725
       -
            , ghcide, hls-plugin-api, hls-test-utils, lsp-types, text

     

       140726
       140726
       -
            , unordered-containers

     

       141135
       141135
       +
            , ghcide, hls-plugin-api, hls-refactor-plugin, hls-test-utils

     

       141136
       141136
       +
            , lsp-types, text, unordered-containers

     

       140727
       141137
        
            }:

     

       140728
       141138
        
            mkDerivation {

     

       140729
       141139
        
              pname = "hls-haddock-comments-plugin";

     

       140730
       140730
       -
              version = "1.0.1.0";

     

       140731
       140731
       -
              sha256 = "1jlz6vg5ff2j2vba4yg8nymxfs7vmg5h3kzjhsj6bs2jn8kh722r";

     

       140732
       140732
       -
              revision = "2";

     

       140733
       140733
       -
              editedCabalFile = "0dq2in2cn0wdhn6m8zd10g3hmc23rnl40jss19fvifn0k8lcsqpb";

     

       141140
       141140
       +
              version = "1.1.0.0";

     

       141141
       141141
       +
              sha256 = "0g0vwn5mcl4g1gxzg501mchxyyqwz83hjhqzai33qsmklcmnk5rc";

     

       140734
       141142
        
              libraryHaskellDepends = [

     

       140735
       140735
       -
                base containers ghc ghc-exactprint ghcide hls-plugin-api lsp-types

     

       140736
       140736
       -
                text unordered-containers

     

       141143
       141143
       +
                base containers ghc ghc-exactprint ghcide hls-plugin-api

     

       141144
       141144
       +
                hls-refactor-plugin lsp-types text unordered-containers

     

       140737
       141145
        
              ];

     

       140738
       141146
        
              testHaskellDepends = [ base filepath hls-test-utils text ];

     

       140739
       141147
        
              description = "Haddock comments plugin for Haskell Language Server";

     
···

       140743
       141151
        
         "hls-hlint-plugin" = callPackage

     

       140744
       141152
        
           ({ mkDerivation, aeson, apply-refact, base, binary, bytestring

     

       140745
       141153
        
            , containers, data-default, deepseq, Diff, directory, extra

     

       140746
       140746
       -
            , filepath, ghc, ghc-exactprint, ghc-lib-parser-ex, ghcide

     

       140747
       140747
       -
            , hashable, hlint, hls-plugin-api, hls-test-utils, hslogger, lens

     

       140748
       140748
       -
            , lsp, lsp-types, refact, regex-tdfa, stm, temporary, text

     

       141154
       141154
       +
            , filepath, ghc-exactprint, ghc-lib-parser, ghc-lib-parser-ex

     

       141155
       141155
       +
            , ghcide, hashable, hlint, hls-plugin-api, hls-test-utils, hslogger

     

       141156
       141156
       +
            , lens, lsp, lsp-types, refact, regex-tdfa, stm, temporary, text

     

       140749
       141157
        
            , transformers, unordered-containers

     

       140750
       141158
        
            }:

     

       140751
       141159
        
            mkDerivation {

     

       140752
       141160
        
              pname = "hls-hlint-plugin";

     

       140753
       140753
       -
              version = "1.0.4.0";

     

       140754
       140754
       -
              sha256 = "089pa1fg4ygc39a70g6x1ma1fci6jrkypg7hsmq4gf3h2rwiyvwy";

     

       141161
       141161
       +
              version = "1.1.0.0";

     

       141162
       141162
       +
              sha256 = "1xr6ayzjd12y6l3dd8azlgks7fsiy87z5n14grf7yw65pdfrvgni";

     

       140755
       141163
        
              libraryHaskellDepends = [

     

       140756
       141164
        
                aeson apply-refact base binary bytestring containers data-default

     

       140757
       140757
       -
                deepseq Diff directory extra filepath ghc ghc-exactprint

     

       141165
       141165
       +
                deepseq Diff directory extra filepath ghc-exactprint ghc-lib-parser

     

       140758
       141166
        
                ghc-lib-parser-ex ghcide hashable hlint hls-plugin-api hslogger

     

       140759
       141167
        
                lens lsp refact regex-tdfa stm temporary text transformers

     

       140760
       141168
        
                unordered-containers

     
···

       140774
       141182
        
            }:

     

       140775
       141183
        
            mkDerivation {

     

       140776
       141184
        
              pname = "hls-module-name-plugin";

     

       140777
       140777
       -
              version = "1.0.2.0";

     

       140778
       140778
       -
              sha256 = "09548l8vmfq2y83agsr12w0x82drhmwa4bxpwby0mf466f4hj8da";

     

       141185
       141185
       +
              version = "1.1.0.0";

     

       141186
       141186
       +
              sha256 = "1xjj1sbq3a71z37dcsgv0cd3qjklm4fl5grnivprgywa71a8k201";

     

       140779
       141187
        
              libraryHaskellDepends = [

     

       140780
       141188
        
                aeson base directory filepath ghcide hls-plugin-api lsp text

     

       140781
       141189
        
                transformers unordered-containers

     
···

       140792
       141200
        
            }:

     

       140793
       141201
        
            mkDerivation {

     

       140794
       141202
        
              pname = "hls-ormolu-plugin";

     

       140795
       140795
       -
              version = "1.0.2.1";

     

       140796
       140796
       -
              sha256 = "1if4gahvdayx1ar4wxi4mk074zxpx6wzkwdd64fnri4k5xb15sa7";

     

       141203
       141203
       +
              version = "1.0.2.2";

     

       141204
       141204
       +
              sha256 = "063sy86mkrjnhycwq7ifbm3w0h7wc2df8wm3p4wd45mpk9r0cqsb";

     

       140797
       141205
        
              libraryHaskellDepends = [

     

       140798
       141206
        
                base filepath ghc ghc-boot-th ghcide hls-plugin-api lens lsp ormolu

     

       140799
       141207
        
                text

     
···

       140805
       141213
        
       

     

       140806
       141214
        
         "hls-plugin-api" = callPackage

     

       140807
       141215
        
           ({ mkDerivation, aeson, base, containers, data-default

     

       140808
       140808
       -
            , dependent-map, dependent-sum, Diff, dlist, extra, ghc, hashable

     

       140809
       140809
       -
            , hls-graph, lens, lens-aeson, lsp, lsp-types, opentelemetry

     

       140810
       140810
       -
            , optparse-applicative, process, regex-tdfa, tasty, tasty-hunit

     

       140811
       140811
       -
            , tasty-rerun, text, transformers, unix, unordered-containers

     

       141216
       141216
       +
            , dependent-map, dependent-sum, Diff, dlist, extra, filepath, ghc

     

       141217
       141217
       +
            , hashable, hls-graph, lens, lens-aeson, lsp, lsp-types

     

       141218
       141218
       +
            , opentelemetry, optparse-applicative, process, regex-tdfa, tasty

     

       141219
       141219
       +
            , tasty-hunit, tasty-rerun, text, transformers, unix

     

       141220
       141220
       +
            , unordered-containers

     

       140812
       141221
        
            }:

     

       140813
       141222
        
            mkDerivation {

     

       140814
       141223
        
              pname = "hls-plugin-api";

     

       140815
       140815
       -
              version = "1.4.0.0";

     

       140816
       140816
       -
              sha256 = "0yk2y6qw88vhww8z10d2kgn57wsarfnp6z1gmjl1ik2w96a8g3mv";

     

       140817
       140817
       -
              revision = "1";

     

       140818
       140818
       -
              editedCabalFile = "0mqwnvq892qa793pv68fsfhnkysm386vrkyx28qaaraqfnbxkysn";

     

       141224
       141224
       +
              version = "1.5.0.0";

     

       141225
       141225
       +
              sha256 = "0vw3bldcrhmq0xfj5k07p67rz0w05ls542q18429g2ikxqyw1rz5";

     

       140819
       141226
        
              libraryHaskellDepends = [

     

       140820
       141227
        
                aeson base containers data-default dependent-map dependent-sum Diff

     

       140821
       140821
       -
                dlist extra ghc hashable hls-graph lens lens-aeson lsp

     

       141228
       141228
       +
                dlist extra filepath ghc hashable hls-graph lens lens-aeson lsp

     

       140822
       141229
        
                opentelemetry optparse-applicative process regex-tdfa text

     

       140823
       141230
        
                transformers unix unordered-containers

     

       140824
       141231
        
              ];

     
···

       140836
       141243
        
            }:

     

       140837
       141244
        
            mkDerivation {

     

       140838
       141245
        
              pname = "hls-pragmas-plugin";

     

       140839
       140839
       -
              version = "1.0.2.1";

     

       140840
       140840
       -
              sha256 = "11l79214wz21v7plqf2wb6ac8bgw74fhql1p5cvkv8gr80hpb4jk";

     

       140841
       140841
       -
              revision = "1";

     

       140842
       140842
       -
              editedCabalFile = "0xg7jv31yh6mm4awg759wh792jfca48za133bfs2g2877vf2llzj";

     

       141246
       141246
       +
              version = "1.0.3.0";

     

       141247
       141247
       +
              sha256 = "17fnfndym9w689rp6l7xb3qfb9i603blr52s0qyznmbkdk2l81kl";

     

       140843
       141248
        
              libraryHaskellDepends = [

     

       140844
       141249
        
                base containers extra fuzzy ghc ghcide hls-plugin-api lens lsp text

     

       140845
       141250
        
                transformers unordered-containers

     
···

       140860
       141265
        
              pname = "hls-qualify-imported-names-plugin";

     

       140861
       141266
        
              version = "1.0.1.0";

     

       140862
       141267
        
              sha256 = "0h456cq3qvksrkzfzpq2qsabsl3vpg4gh2mwyxc39xh4qm7ifban";

     

       140863
       140863
       -
              revision = "1";

     

       140864
       140864
       -
              editedCabalFile = "0pb9fgpbv24726n250rkb33gx3f3xcaxmv1qqh12q4sz181qn4mb";

     

       141268
       141268
       +
              revision = "2";

     

       141269
       141269
       +
              editedCabalFile = "1adnnd8fg4pfdc6n1797naqf4pmgspisjmw121mk39y02b057cdw";

     

       140865
       141270
        
              libraryHaskellDepends = [

     

       140866
       141271
        
                aeson base containers deepseq dlist ghc ghcide hls-graph

     

       140867
       141272
        
                hls-plugin-api lsp text transformers unordered-containers

     
···

       140871
       141276
        
              license = lib.licenses.asl20;

     

       140872
       141277
        
            }) {};

     

       140873
       141278
        
       

     

       141279
       141279
       +
         "hls-refactor-plugin" = callPackage

     

       141280
       141280
       +
           ({ mkDerivation, aeson, async, base, bytestring, containers

     

       141281
       141281
       +
            , data-default, deepseq, directory, dlist, extra, filepath, ghc

     

       141282
       141282
       +
            , ghc-boot, ghc-exactprint, ghcide, ghcide-test-utils, hls-graph

     

       141283
       141283
       +
            , hls-plugin-api, hls-test-utils, lens, lsp, lsp-test, lsp-types

     

       141284
       141284
       +
            , mtl, network-uri, parser-combinators, regex-tdfa, retrie, shake

     

       141285
       141285
       +
            , syb, tasty, tasty-expected-failure, tasty-hunit, tasty-rerun

     

       141286
       141286
       +
            , text, text-rope, time, transformers, unordered-containers

     

       141287
       141287
       +
            }:

     

       141288
       141288
       +
            mkDerivation {

     

       141289
       141289
       +
              pname = "hls-refactor-plugin";

     

       141290
       141290
       +
              version = "1.0.0.0";

     

       141291
       141291
       +
              sha256 = "0gn35af8yfdaq7dnbc8x0p79jf2lxs1wvka8xcjcclg3sxji04d1";

     

       141292
       141292
       +
              libraryHaskellDepends = [

     

       141293
       141293
       +
                aeson base bytestring containers data-default deepseq dlist extra

     

       141294
       141294
       +
                ghc ghc-boot ghc-exactprint ghcide hls-graph hls-plugin-api lens

     

       141295
       141295
       +
                lsp mtl regex-tdfa retrie syb text text-rope time transformers

     

       141296
       141296
       +
                unordered-containers

     

       141297
       141297
       +
              ];

     

       141298
       141298
       +
              testHaskellDepends = [

     

       141299
       141299
       +
                aeson async base containers data-default directory extra filepath

     

       141300
       141300
       +
                ghcide ghcide-test-utils hls-plugin-api hls-test-utils lens

     

       141301
       141301
       +
                lsp-test lsp-types network-uri parser-combinators regex-tdfa shake

     

       141302
       141302
       +
                tasty tasty-expected-failure tasty-hunit tasty-rerun text text-rope

     

       141303
       141303
       +
              ];

     

       141304
       141304
       +
              description = "Exactprint refactorings for Haskell Language Server";

     

       141305
       141305
       +
              license = lib.licenses.asl20;

     

       141306
       141306
       +
            }) {};

     

       141307
       141307
       +
       

     

       140874
       141308
        
         "hls-refine-imports-plugin" = callPackage

     

       140875
       141309
        
           ({ mkDerivation, aeson, base, containers, deepseq, filepath, ghc

     

       140876
       141310
        
            , ghcide, hls-explicit-imports-plugin, hls-graph, hls-plugin-api

     
···

       140878
       141312
        
            }:

     

       140879
       141313
        
            mkDerivation {

     

       140880
       141314
        
              pname = "hls-refine-imports-plugin";

     

       140881
       140881
       -
              version = "1.0.2.0";

     

       140882
       140882
       -
              sha256 = "01hgz66dm6rpk7fp6b2byzvnaan3snvimkicl67c6qxla9dpxcjn";

     

       141315
       141315
       +
              version = "1.0.3.0";

     

       141316
       141316
       +
              sha256 = "1rw9vdpzg63506b289rar0csdqniv1alc37q33x9x65qlvkqf9dh";

     

       140883
       141317
        
              libraryHaskellDepends = [

     

       140884
       141318
        
                aeson base containers deepseq ghc ghcide

     

       140885
       141319
        
                hls-explicit-imports-plugin hls-graph hls-plugin-api lsp text

     
···

       140893
       141327
        
         "hls-rename-plugin" = callPackage

     

       140894
       141328
        
           ({ mkDerivation, aeson, base, containers, extra, filepath, ghc

     

       140895
       141329
        
            , ghc-exactprint, ghcide, hashable, hiedb, hls-plugin-api

     

       140896
       140896
       -
            , hls-test-utils, lsp, lsp-types, mod, syb, text, transformers

     

       140897
       140897
       -
            , unordered-containers

     

       141330
       141330
       +
            , hls-refactor-plugin, hls-test-utils, lsp, lsp-types, mod, syb

     

       141331
       141331
       +
            , text, transformers, unordered-containers

     

       140898
       141332
        
            }:

     

       140899
       141333
        
            mkDerivation {

     

       140900
       141334
        
              pname = "hls-rename-plugin";

     

       140901
       140901
       -
              version = "1.0.0.2";

     

       140902
       140902
       -
              sha256 = "1cqcyyh4ywxwl2wppdacp2y6hpbl5534vq8xw2ih489qczcg6s78";

     

       141335
       141335
       +
              version = "1.0.1.0";

     

       141336
       141336
       +
              sha256 = "0619vjcyfdjln5v2gc6hpdvl5lwx8kg97zlqpz937742q6bvkb66";

     

       140903
       141337
        
              libraryHaskellDepends = [

     

       140904
       141338
        
                base containers extra ghc ghc-exactprint ghcide hashable hiedb

     

       140905
       140905
       -
                hls-plugin-api lsp lsp-types mod syb text transformers

     

       140906
       140906
       -
                unordered-containers

     

       141339
       141339
       +
                hls-plugin-api hls-refactor-plugin lsp lsp-types mod syb text

     

       141340
       141340
       +
                transformers unordered-containers

     

       140907
       141341
        
              ];

     

       140908
       141342
        
              testHaskellDepends = [

     

       140909
       141343
        
                aeson base containers filepath hls-plugin-api hls-test-utils

     
···

       140920
       141354
        
            }:

     

       140921
       141355
        
            mkDerivation {

     

       140922
       141356
        
              pname = "hls-retrie-plugin";

     

       140923
       140923
       -
              version = "1.0.2.1";

     

       140924
       140924
       -
              sha256 = "1vl7kdw8sm9r5q35lnihq0r98wd2s3mm76c7wp0cwd55qdkaf7qv";

     

       141357
       141357
       +
              version = "1.0.2.2";

     

       141358
       141358
       +
              sha256 = "19ljig86aw5y0f6w83wgl5aazybh6nlzmigy12p5ldnbl027r4ry";

     

       140925
       141359
        
              libraryHaskellDepends = [

     

       140926
       141360
        
                aeson base bytestring containers deepseq directory extra ghc ghcide

     

       140927
       141361
        
                hashable hls-plugin-api lsp lsp-types retrie safe-exceptions stm

     
···

       140952
       141386
        
              ];

     

       140953
       141387
        
              description = "HLS Plugin to support smart selection range";

     

       140954
       141388
        
              license = lib.licenses.asl20;

     

       141389
       141389
       +
              hydraPlatforms = lib.platforms.none;

     

       141390
       141390
       +
              broken = true;

     

       140955
       141391
        
            }) {};

     

       140956
       141392
        
       

     

       140957
       141393
        
         "hls-splice-plugin" = callPackage

     

       140958
       141394
        
           ({ mkDerivation, aeson, base, containers, dlist, extra, filepath

     

       140959
       141395
        
            , foldl, ghc, ghc-exactprint, ghcide, hls-plugin-api

     

       140960
       140960
       -
            , hls-test-utils, lens, lsp, retrie, syb, text, transformers

     

       140961
       140961
       -
            , unliftio-core, unordered-containers

     

       141396
       141396
       +
            , hls-refactor-plugin, hls-test-utils, lens, lsp, retrie, syb, text

     

       141397
       141397
       +
            , transformers, unliftio-core, unordered-containers

     

       140962
       141398
        
            }:

     

       140963
       141399
        
            mkDerivation {

     

       140964
       141400
        
              pname = "hls-splice-plugin";

     

       140965
       140965
       -
              version = "1.0.1.0";

     

       140966
       140966
       -
              sha256 = "07v4rgss140vfc4xqibccimm48ys4awz7yficr0wf440p6i83qdc";

     

       140967
       140967
       -
              revision = "1";

     

       140968
       140968
       -
              editedCabalFile = "15hr2vc1r4zxf4z26byax95cdqhl1733fna16lifrdj15xkwxs3r";

     

       141401
       141401
       +
              version = "1.0.2.0";

     

       141402
       141402
       +
              sha256 = "0dq726cxgya756rx40nqhb7lz6fxd38y3r2cgvywc8jp0crpvmyc";

     

       140969
       141403
        
              libraryHaskellDepends = [

     

       140970
       141404
        
                aeson base containers dlist extra foldl ghc ghc-exactprint ghcide

     

       140971
       140971
       -
                hls-plugin-api lens lsp retrie syb text transformers unliftio-core

     

       140972
       140972
       -
                unordered-containers

     

       141405
       141405
       +
                hls-plugin-api hls-refactor-plugin lens lsp retrie syb text

     

       141406
       141406
       +
                transformers unliftio-core unordered-containers

     

       140973
       141407
        
              ];

     

       140974
       141408
        
              testHaskellDepends = [ base filepath hls-test-utils text ];

     

       140975
       141409
        
              description = "HLS Plugin to expand TemplateHaskell Splices and QuasiQuotes";

     

       140976
       141410
        
              license = lib.licenses.asl20;

     

       141411
       141411
       +
            }) {};

     

       141412
       141412
       +
       

     

       141413
       141413
       +
         "hls-stan-plugin" = callPackage

     

       141414
       141414
       +
           ({ mkDerivation }:

     

       141415
       141415
       +
            mkDerivation {

     

       141416
       141416
       +
              pname = "hls-stan-plugin";

     

       141417
       141417
       +
              version = "1.0.0.0";

     

       141418
       141418
       +
              sha256 = "03pg68gmardqkx9xa218bb0j4b1f0h5p6gn6xzfwmdj5c005rxjk";

     

       141419
       141419
       +
              description = "Stan integration plugin with Haskell Language Server";

     

       141420
       141420
       +
              license = lib.licenses.asl20;

     

       141421
       141421
       +
              hydraPlatforms = lib.platforms.none;

     

       141422
       141422
       +
              broken = true;

     

       140977
       141423
        
            }) {};

     

       140978
       141424
        
       

     

       140979
       141425
        
         "hls-stylish-haskell-plugin" = callPackage

     
···

       140998
       141444
        
           ({ mkDerivation, aeson, base, containers, deepseq, directory, extra

     

       140999
       141445
        
            , filepath, fingertree, generic-lens, ghc, ghc-boot-th

     

       141000
       141446
        
            , ghc-exactprint, ghc-source-gen, ghcide, hls-graph, hls-plugin-api

     

       141001
       141001
       -
            , hls-test-utils, hspec, hspec-discover, hspec-expectations

     

       141002
       141002
       -
            , hyphenation, lens, lsp, lsp-types, megaparsec, mtl

     

       141003
       141003
       -
            , parser-combinators, prettyprinter, QuickCheck, refinery, retrie

     

       141004
       141004
       -
            , syb, tasty-hspec, tasty-hunit, text, transformers, unagi-chan

     

       141005
       141005
       -
            , unordered-containers

     

       141447
       141447
       +
            , hls-refactor-plugin, hls-test-utils, hspec, hspec-discover

     

       141448
       141448
       +
            , hspec-expectations, hyphenation, lens, lsp, lsp-types, megaparsec

     

       141449
       141449
       +
            , mtl, parser-combinators, prettyprinter, QuickCheck, refinery

     

       141450
       141450
       +
            , retrie, syb, tasty-hspec, tasty-hunit, text, transformers

     

       141451
       141451
       +
            , unagi-chan, unordered-containers

     

       141006
       141452
        
            }:

     

       141007
       141453
        
            mkDerivation {

     

       141008
       141454
        
              pname = "hls-tactics-plugin";

     

       141009
       141009
       -
              version = "1.6.2.0";

     

       141010
       141010
       -
              sha256 = "07qh9sz3rbqflfryxaj7y8vjmv388jdsmaxvz5z0xfq895yk968p";

     

       141455
       141455
       +
              version = "1.7.0.0";

     

       141456
       141456
       +
              sha256 = "097jkwcdmpabfniqj725bm67z4nf4ir2yh0zxjl4h1zn7lyldqdd";

     

       141011
       141457
        
              libraryHaskellDepends = [

     

       141012
       141458
        
                aeson base containers deepseq directory extra filepath fingertree

     

       141013
       141459
        
                generic-lens ghc ghc-boot-th ghc-exactprint ghc-source-gen ghcide

     

       141014
       141014
       -
                hls-graph hls-plugin-api hyphenation lens lsp megaparsec mtl

     

       141015
       141015
       -
                parser-combinators prettyprinter refinery retrie syb text

     

       141016
       141016
       -
                transformers unagi-chan unordered-containers

     

       141460
       141460
       +
                hls-graph hls-plugin-api hls-refactor-plugin hyphenation lens lsp

     

       141461
       141461
       +
                megaparsec mtl parser-combinators prettyprinter refinery retrie syb

     

       141462
       141462
       +
                text transformers unagi-chan unordered-containers

     

       141017
       141463
        
              ];

     

       141018
       141464
        
              testHaskellDepends = [

     

       141019
       141465
        
                aeson base containers deepseq directory filepath ghc ghcide

     
···

       141034
       141480
        
            }:

     

       141035
       141481
        
            mkDerivation {

     

       141036
       141482
        
              pname = "hls-test-utils";

     

       141037
       141037
       -
              version = "1.3.0.0";

     

       141038
       141038
       -
              sha256 = "1qm3lna4jy658bmbr6gpjq2gmcz03rdz535gilxycbjkxl2z3hkq";

     

       141483
       141483
       +
              version = "1.4.0.0";

     

       141484
       141484
       +
              sha256 = "01j85mpcj7klvsbfwfvp9zs7985hxl23bj56lqgh2gd73b5g14xd";

     

       141039
       141485
        
              libraryHaskellDepends = [

     

       141040
       141486
        
                aeson async base blaze-markup bytestring containers data-default

     

       141041
       141487
        
                directory extra filepath ghcide hls-graph hls-plugin-api lens lsp

     
···

       142177
       142623
        
              hydraPlatforms = lib.platforms.none;

     

       142178
       142624
        
            }) {};

     

       142179
       142625
        
       

     

       142626
       142626
       +
         "hoauth2-tutorial" = callPackage

     

       142627
       142627
       +
           ({ mkDerivation, aeson, base, bytestring, hoauth2, http-conduit

     

       142628
       142628
       +
            , http-types, scotty, text, transformers, uri-bytestring, wai, warp

     

       142629
       142629
       +
            }:

     

       142630
       142630
       +
            mkDerivation {

     

       142631
       142631
       +
              pname = "hoauth2-tutorial";

     

       142632
       142632
       +
              version = "0.1.1";

     

       142633
       142633
       +
              sha256 = "1qac41pv4j13kbf43915j5ybdsi3a93akcn15ip3rs36zvcv63i3";

     

       142634
       142634
       +
              isLibrary = true;

     

       142635
       142635
       +
              isExecutable = true;

     

       142636
       142636
       +
              libraryHaskellDepends = [

     

       142637
       142637
       +
                aeson base bytestring hoauth2 http-conduit http-types scotty text

     

       142638
       142638
       +
                transformers uri-bytestring wai warp

     

       142639
       142639
       +
              ];

     

       142640
       142640
       +
              executableHaskellDepends = [ base ];

     

       142641
       142641
       +
              description = "Tutorial for using hoauth2";

     

       142642
       142642
       +
              license = lib.licenses.bsd3;

     

       142643
       142643
       +
              hydraPlatforms = lib.platforms.none;

     

       142644
       142644
       +
              mainProgram = "hoauth2-tutorial";

     

       142645
       142645
       +
              broken = true;

     

       142646
       142646
       +
            }) {};

     

       142647
       142647
       +
       

     

       142180
       142648
        
         "hob" = callPackage

     

       142181
       142649
        
           ({ mkDerivation, base, bytestring, containers, directory, filepath

     

       142182
       142650
        
            , glib, gtk-largeTreeStore, gtk3, gtksourceview3, hspec, mtl, pango

     
···

       143156
       143624
        
              pname = "hookup";

     

       143157
       143625
        
              version = "0.7";

     

       143158
       143626
        
              sha256 = "02prkwj4rj8g330z17bpjh7hpwfdvasaxsk74mcvbi03gjpydrib";

     

       143627
       143627
       +
              revision = "1";

     

       143628
       143628
       +
              editedCabalFile = "1x4hxcb81rczpywcda3s9jbh2gs1sfwvd7wzv3cxxkbd4smlrh1r";

     

       143159
       143629
        
              libraryHaskellDepends = [

     

       143160
       143630
        
                async attoparsec base bytestring HsOpenSSL HsOpenSSL-x509-system

     

       143161
       143631
        
                network stm

     
···

       144604
       145074
        
              sha256 = "0m0jpv0d2zynhn53gbjb50sb91lxss71qnzhcy30agxvf29qpi0w";

     

       144605
       145075
        
              revision = "2";

     

       144606
       145076
        
              editedCabalFile = "1xpbb5js710rd7kbdgx6hl10dl7n95yp6pidqrh8f9ifwx076k3g";

     

       145077
       145077
       +
              setupHaskellDepends = [ base Cabal directory filepath ];

     

       145078
       145078
       +
              libraryHaskellDepends = [

     

       145079
       145079
       +
                aeson async base bytestring containers exceptions lifted-base

     

       145080
       145080
       +
                monad-control mtl resource-pool semigroups text text-show time

     

       145081
       145081
       +
                transformers transformers-base uuid-types vector

     

       145082
       145082
       +
              ];

     

       145083
       145083
       +
              librarySystemDepends = [ postgresql ];

     

       145084
       145084
       +
              testHaskellDepends = [

     

       145085
       145085
       +
                aeson base bytestring exceptions HUnit lifted-base monad-control

     

       145086
       145086
       +
                mtl QuickCheck random scientific test-framework

     

       145087
       145087
       +
                test-framework-hunit text text-show time transformers-base

     

       145088
       145088
       +
                unordered-containers uuid-types vector

     

       145089
       145089
       +
              ];

     

       145090
       145090
       +
              description = "Haskell bindings to libpqtypes";

     

       145091
       145091
       +
              license = lib.licenses.bsd3;

     

       145092
       145092
       +
              hydraPlatforms = lib.platforms.none;

     

       145093
       145093
       +
              broken = true;

     

       145094
       145094
       +
            }) {inherit (pkgs) postgresql;};

     

       145095
       145095
       +
       

     

       145096
       145096
       +
         "hpqtypes_1_10_0_0" = callPackage

     

       145097
       145097
       +
           ({ mkDerivation, aeson, async, base, bytestring, Cabal, containers

     

       145098
       145098
       +
            , directory, exceptions, filepath, HUnit, lifted-base

     

       145099
       145099
       +
            , monad-control, mtl, postgresql, QuickCheck, random, resource-pool

     

       145100
       145100
       +
            , scientific, semigroups, test-framework, test-framework-hunit

     

       145101
       145101
       +
            , text, text-show, time, transformers, transformers-base

     

       145102
       145102
       +
            , unordered-containers, uuid-types, vector

     

       145103
       145103
       +
            }:

     

       145104
       145104
       +
            mkDerivation {

     

       145105
       145105
       +
              pname = "hpqtypes";

     

       145106
       145106
       +
              version = "1.10.0.0";

     

       145107
       145107
       +
              sha256 = "082hn1g2ilia146rkczia0b37n628wa6xi28w75ikxpwpnkmz422";

     

       144607
       145108
        
              setupHaskellDepends = [ base Cabal directory filepath ];

     

       144608
       145109
        
              libraryHaskellDepends = [

     

       144609
       145110
        
                aeson async base bytestring containers exceptions lifted-base

     
···

       149115
       149616
        
              license = lib.licenses.mit;

     

       149116
       149617
        
            }) {};

     

       149117
       149618
        
       

     

       149118
       149118
       -
         "hspec_2_10_5" = callPackage

     

       149619
       149619
       +
         "hspec_2_10_6" = callPackage

     

       149119
       149620
        
           ({ mkDerivation, base, hspec-core, hspec-discover

     

       149120
       149621
        
            , hspec-expectations, QuickCheck

     

       149121
       149622
        
            }:

     

       149122
       149623
        
            mkDerivation {

     

       149123
       149624
        
              pname = "hspec";

     

       149124
       149124
       -
              version = "2.10.5";

     

       149125
       149125
       -
              sha256 = "1nn9xj1n9007i2zjg03m6n1zjb8f9i2dgvdx1whr06rjya0dyb8v";

     

       149625
       149625
       +
              version = "2.10.6";

     

       149626
       149626
       +
              sha256 = "129yk1ar962xf02axbdbcvx2icw09b2b6q7q1639391aikisivqz";

     

       149126
       149627
        
              libraryHaskellDepends = [

     

       149127
       149628
        
                base hspec-core hspec-discover hspec-expectations QuickCheck

     

       149128
       149629
        
              ];

     
···

       149246
       149747
        
              license = lib.licenses.mit;

     

       149247
       149748
        
            }) {};

     

       149248
       149749
        
       

     

       149249
       149249
       -
         "hspec-core_2_10_5" = callPackage

     

       149750
       149750
       +
         "hspec-core_2_10_6" = callPackage

     

       149250
       149751
        
           ({ mkDerivation, ansi-terminal, array, base, base-orphans

     

       149251
       149752
        
            , call-stack, deepseq, directory, filepath, ghc, ghc-boot-th

     

       149252
       149753
        
            , hspec-expectations, hspec-meta, HUnit, process, QuickCheck

     
···

       149255
       149756
        
            }:

     

       149256
       149757
        
            mkDerivation {

     

       149257
       149758
        
              pname = "hspec-core";

     

       149258
       149258
       -
              version = "2.10.5";

     

       149259
       149259
       -
              sha256 = "084kr32arn6pcfhjf024hm98b9cwlslnjpxq0knhkcgh576asy22";

     

       149759
       149759
       +
              version = "2.10.6";

     

       149760
       149760
       +
              sha256 = "1cz02l3xkj91f41ghz3mkm5nxl6zaj5kgam63rqp8f0yxzhfrvwm";

     

       149260
       149761
        
              libraryHaskellDepends = [

     

       149261
       149762
        
                ansi-terminal array base call-stack deepseq directory filepath ghc

     

       149262
       149262
       -
                ghc-boot-th hspec-expectations HUnit QuickCheck quickcheck-io

     

       149263
       149263
       -
                random setenv stm tf-random time transformers

     

       149763
       149763
       +
                ghc-boot-th hspec-expectations HUnit process QuickCheck

     

       149764
       149764
       +
                quickcheck-io random setenv stm tf-random time transformers

     

       149264
       149765
        
              ];

     

       149265
       149766
        
              testHaskellDepends = [

     

       149266
       149767
        
                ansi-terminal array base base-orphans call-stack deepseq directory

     
···

       149337
       149838
        
              maintainers = [ lib.maintainers.maralorn ];

     

       149338
       149839
        
            }) {};

     

       149339
       149840
        
       

     

       149340
       149340
       -
         "hspec-discover_2_10_5" = callPackage

     

       149841
       149841
       +
         "hspec-discover_2_10_6" = callPackage

     

       149341
       149842
        
           ({ mkDerivation, base, directory, filepath, hspec-meta, mockery

     

       149342
       149843
        
            , QuickCheck

     

       149343
       149844
        
            }:

     

       149344
       149845
        
            mkDerivation {

     

       149345
       149846
        
              pname = "hspec-discover";

     

       149346
       149346
       -
              version = "2.10.5";

     

       149347
       149347
       -
              sha256 = "0w0xsvzsyc3wrjv12nfynq7bgcxmg1kgpjp4lplp88q1c7y2rkv6";

     

       149847
       149847
       +
              version = "2.10.6";

     

       149848
       149848
       +
              sha256 = "0x7yx55l2cngg4vw2k4mirajbprpa7bkx8rnyvyads8c6f97s71v";

     

       149348
       149849
        
              isLibrary = true;

     

       149349
       149850
        
              isExecutable = true;

     

       149350
       149851
        
              libraryHaskellDepends = [ base directory filepath ];

     
···

       149700
       150201
        
              mainProgram = "hspec-meta-discover";

     

       149701
       150202
        
            }) {};

     

       149702
       150203
        
       

     

       149703
       149703
       -
         "hspec-meta_2_9_3" = callPackage

     

       150204
       150204
       +
         "hspec-meta_2_10_5" = callPackage

     

       149704
       150205
        
           ({ mkDerivation, ansi-terminal, array, base, call-stack, clock

     

       149705
       150206
        
            , deepseq, directory, filepath, ghc, ghc-boot-th, QuickCheck

     

       149706
       150207
        
            , quickcheck-io, random, setenv, stm, time, transformers

     

       149707
       150208
        
            }:

     

       149708
       150209
        
            mkDerivation {

     

       149709
       150210
        
              pname = "hspec-meta";

     

       149710
       149710
       -
              version = "2.9.3";

     

       149711
       149711
       -
              sha256 = "1raxwpsmcijl3x2h5naw6aydhbiknxvhj3x7v384bi1rqi51ainm";

     

       150211
       150211
       +
              version = "2.10.5";

     

       150212
       150212
       +
              sha256 = "0jgagvmvp3nvz9vdgvr42x0xv7nnjzz1rshs6x4wzc38qvcrssbn";

     

       149712
       150213
        
              isLibrary = true;

     

       149713
       150214
        
              isExecutable = true;

     

       149714
       150215
        
              libraryHaskellDepends = [

     
···

       153797
       154298
        
              broken = true;

     

       153798
       154299
        
            }) {};

     

       153799
       154300
        
       

     

       154301
       154301
       +
         "hurl-xml" = callPackage

     

       154302
       154302
       +
           ({ mkDerivation, base, bytestring, containers, css-syntax

     

       154303
       154303
       +
            , data-default-class, directory, file-embed, filepath, html-conduit

     

       154304
       154304
       +
            , hurl, network-uri, stylist-traits, temporary, text, time

     

       154305
       154305
       +
            , xml-conduit, xml-conduit-stylist

     

       154306
       154306
       +
            }:

     

       154307
       154307
       +
            mkDerivation {

     

       154308
       154308
       +
              pname = "hurl-xml";

     

       154309
       154309
       +
              version = "0.1.0.0";

     

       154310
       154310
       +
              sha256 = "14z0b68fsqpbhap6yywjv3y48bz0chn4p0hhklw9zgyyhhrvlz1z";

     

       154311
       154311
       +
              libraryHaskellDepends = [

     

       154312
       154312
       +
                base bytestring containers css-syntax data-default-class directory

     

       154313
       154313
       +
                file-embed filepath html-conduit hurl network-uri stylist-traits

     

       154314
       154314
       +
                temporary text time xml-conduit xml-conduit-stylist

     

       154315
       154315
       +
              ];

     

       154316
       154316
       +
              description = "Fetch parsed XML & possibly CSS for a URL based on MIMEtype";

     

       154317
       154317
       +
              license = lib.licenses.gpl3Only;

     

       154318
       154318
       +
              hydraPlatforms = lib.platforms.none;

     

       154319
       154319
       +
            }) {};

     

       154320
       154320
       +
       

     

       153800
       154321
        
         "hurriyet" = callPackage

     

       153801
       154322
        
           ({ mkDerivation, aeson, base, bytestring, containers, here, hspec

     

       153802
       154323
        
            , http-client, http-client-tls, mtl, text

     
···

       157630
       158151
        
              mainProgram = "ihaskell";

     

       157631
       158152
        
            }) {};

     

       157632
       158153
        
       

     

       158154
       158154
       +
         "ihaskell_0_10_3_0" = callPackage

     

       158155
       158155
       +
           ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring

     

       158156
       158156
       +
            , cmdargs, containers, directory, exceptions, filepath, ghc

     

       158157
       158157
       +
            , ghc-boot, ghc-parser, ghc-paths, haskeline, here, hlint, hspec

     

       158158
       158158
       +
            , hspec-contrib, http-client, http-client-tls, HUnit

     

       158159
       158159
       +
            , ipython-kernel, parsec, process, random, raw-strings-qq, setenv

     

       158160
       158160
       +
            , shelly, split, stm, strict, text, time, transformers, unix

     

       158161
       158161
       +
            , unordered-containers, utf8-string, vector

     

       158162
       158162
       +
            }:

     

       158163
       158163
       +
            mkDerivation {

     

       158164
       158164
       +
              pname = "ihaskell";

     

       158165
       158165
       +
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       158166
       158166
       +
              sha256 = "0caghqp1k04mhfxqpz2hics92wdw8krnjycqsxsjp8s7impl36vl";

     

       158167
       158167
       +
              isLibrary = true;

     

       158168
       158168
       +
              isExecutable = true;

     

       158169
       158169
       +
              enableSeparateDataOutput = true;

     

       158170
       158170
       +
              libraryHaskellDepends = [

     

       158171
       158171
       +
                aeson base base64-bytestring binary bytestring cmdargs containers

     

       158172
       158172
       +
                directory exceptions filepath ghc ghc-boot ghc-parser ghc-paths

     

       158173
       158173
       +
                haskeline hlint http-client http-client-tls ipython-kernel parsec

     

       158174
       158174
       +
                process random shelly split stm strict text time transformers unix

     

       158175
       158175
       +
                unordered-containers utf8-string vector

     

       158176
       158176
       +
              ];

     

       158177
       158177
       +
              executableHaskellDepends = [

     

       158178
       158178
       +
                aeson base bytestring containers directory ghc ipython-kernel

     

       158179
       158179
       +
                process strict text transformers unix unordered-containers

     

       158180
       158180
       +
              ];

     

       158181
       158181
       +
              testHaskellDepends = [

     

       158182
       158182
       +
                base directory ghc ghc-paths here hspec hspec-contrib HUnit

     

       158183
       158183
       +
                raw-strings-qq setenv shelly text transformers

     

       158184
       158184
       +
              ];

     

       158185
       158185
       +
              description = "A Haskell backend kernel for the Jupyter project";

     

       158186
       158186
       +
              license = lib.licenses.mit;

     

       158187
       158187
       +
              hydraPlatforms = lib.platforms.none;

     

       158188
       158188
       +
              mainProgram = "ihaskell";

     

       158189
       158189
       +
            }) {};

     

       158190
       158190
       +
       

     

       157633
       158191
        
         "ihaskell-aeson" = callPackage

     

       157634
       158192
        
           ({ mkDerivation, aeson, aeson-pretty, base, bytestring, here

     

       157635
       158193
        
            , ihaskell, text

     
···

       157869
       158427
        
       

     

       157870
       158428
        
         "ihp-hsx" = callPackage

     

       157871
       158429
        
           ({ mkDerivation, base, blaze-html, blaze-markup, bytestring

     

       157872
       157872
       -
            , containers, haskell-src-meta, megaparsec, string-conversions

     

       157873
       157873
       -
            , template-haskell, text

     

       158430
       158430
       +
            , containers, ghc, megaparsec, string-conversions, template-haskell

     

       158431
       158431
       +
            , text

     

       157874
       158432
        
            }:

     

       157875
       158433
        
            mkDerivation {

     

       157876
       158434
        
              pname = "ihp-hsx";

     

       157877
       157877
       -
              version = "0.18.0";

     

       157878
       157878
       -
              sha256 = "1a5sc7qz24qkkm0s5fc3pqdnq7gl29fw400sv7zq05bkrrnlfzpn";

     

       158435
       158435
       +
              version = "0.20.0";

     

       158436
       158436
       +
              sha256 = "118bhsyn5r9p03b8six9g5xna4vrh2qsq3ka4mqlvzv4kp4d7dkb";

     

       157879
       158437
        
              libraryHaskellDepends = [

     

       157880
       157880
       -
                base blaze-html blaze-markup bytestring containers haskell-src-meta

     

       157881
       157881
       -
                megaparsec string-conversions template-haskell text

     

       158438
       158438
       +
                base blaze-html blaze-markup bytestring containers ghc megaparsec

     

       158439
       158439
       +
                string-conversions template-haskell text

     

       157882
       158440
        
              ];

     

       157883
       158441
        
              description = "JSX-like but for Haskell";

     

       157884
       158442
        
              license = lib.licenses.mit;

     
···

       162083
       162641
        
              license = lib.licenses.mit;

     

       162084
       162642
        
            }) {};

     

       162085
       162643
        
       

     

       162644
       162644
       +
         "ipython-kernel_0_10_3_0" = callPackage

     

       162645
       162645
       +
           ({ mkDerivation, aeson, base, binary, bytestring, containers

     

       162646
       162646
       +
            , cryptonite, directory, filepath, memory, parsec, process

     

       162647
       162647
       +
            , temporary, text, transformers, unordered-containers, uuid

     

       162648
       162648
       +
            , zeromq4-haskell

     

       162649
       162649
       +
            }:

     

       162650
       162650
       +
            mkDerivation {

     

       162651
       162651
       +
              pname = "ipython-kernel";

     

       162652
       162652
       +
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       162653
       162653
       +
              sha256 = "0zvcqgvrykfmp706snbpxy8ia0hkxshrj8r8kfwkvkwhxd72ad5c";

     

       162654
       162654
       +
              isLibrary = true;

     

       162655
       162655
       +
              isExecutable = true;

     

       162656
       162656
       +
              enableSeparateDataOutput = true;

     

       162657
       162657
       +
              libraryHaskellDepends = [

     

       162658
       162658
       +
                aeson base binary bytestring containers cryptonite directory

     

       162659
       162659
       +
                filepath memory parsec process temporary text transformers

     

       162660
       162660
       +
                unordered-containers uuid zeromq4-haskell

     

       162661
       162661
       +
              ];

     

       162662
       162662
       +
              description = "A library for creating kernels for IPython frontends";

     

       162663
       162663
       +
              license = lib.licenses.mit;

     

       162664
       162664
       +
              hydraPlatforms = lib.platforms.none;

     

       162665
       162665
       +
            }) {};

     

       162666
       162666
       +
       

     

       162086
       162667
        
         "irc" = callPackage

     

       162087
       162668
        
           ({ mkDerivation, attoparsec, base, bytestring, HUnit, QuickCheck

     

       162088
       162669
        
            , test-framework, test-framework-hunit, test-framework-quickcheck2

     
···

       162493
       163074
        
           ({ mkDerivation, base, hspec, QuickCheck, text }:

     

       162494
       163075
        
            mkDerivation {

     

       162495
       163076
        
              pname = "isbn";

     

       162496
       162496
       -
              version = "1.1.0.3";

     

       162497
       162497
       -
              sha256 = "16srdvsjsiqzcm0hb3rhwry1vr170fz85g84wk6nyk1glbva4bga";

     

       162498
       162498
       -
              libraryHaskellDepends = [ base text ];

     

       162499
       162499
       -
              testHaskellDepends = [ base hspec QuickCheck text ];

     

       162500
       162500
       -
              description = "ISBN Validation and Manipulation";

     

       162501
       162501
       -
              license = lib.licenses.asl20;

     

       162502
       162502
       -
            }) {};

     

       162503
       162503
       -
       

     

       162504
       162504
       -
         "isbn_1_1_0_4" = callPackage

     

       162505
       162505
       -
           ({ mkDerivation, base, hspec, QuickCheck, text }:

     

       162506
       162506
       -
            mkDerivation {

     

       162507
       162507
       -
              pname = "isbn";

     

       162508
       163077
        
              version = "1.1.0.4";

     

       162509
       163078
        
              sha256 = "1s8ypi1rx8iqsn0kvp4k818ljfsj7zdh0rkzii60vblaxrfhhczb";

     

       162510
       163079
        
              libraryHaskellDepends = [ base text ];

     

       162511
       163080
        
              testHaskellDepends = [ base hspec QuickCheck text ];

     

       162512
       163081
        
              description = "ISBN Validation and Manipulation";

     

       162513
       163082
        
              license = lib.licenses.asl20;

     

       162514
       162514
       -
              hydraPlatforms = lib.platforms.none;

     

       162515
       163083
        
            }) {};

     

       162516
       163084
        
       

     

       162517
       163085
        
         "isdicom" = callPackage

     
···

       162767
       163335
        
            }:

     

       162768
       163336
        
            mkDerivation {

     

       162769
       163337
        
              pname = "isomorphism-class";

     

       162770
       162770
       -
              version = "0.1.0.6";

     

       162771
       162771
       -
              sha256 = "0sy9v5830giqkk4r7c0ycvm5z3racf953dy5lwsfxm7zygzb8dm3";

     

       163338
       163338
       +
              version = "0.1.0.7";

     

       163339
       163339
       +
              sha256 = "0kngrwjj5m2pg4pkcvcxamsx82y03lfpj4hs7ifsxf64qm67bmgy";

     

       162772
       163340
        
              libraryHaskellDepends = [

     

       162773
       163341
        
                base bytestring containers hashable primitive text

     

       162774
       163342
        
                unordered-containers vector

     
···

       165999
       166567
        
            }:

     

       166000
       166568
        
            mkDerivation {

     

       166001
       166569
        
              pname = "json-stream";

     

       166002
       166002
       -
              version = "0.4.4.1";

     

       166003
       166003
       -
              sha256 = "1czl29nn2i4li6m1dn151l5rbiwrb3c47njnmlk3pqk138k0czgy";

     

       166004
       166004
       -
              libraryHaskellDepends = [

     

       166005
       166005
       -
                aeson base bytestring primitive scientific text

     

       166006
       166006
       -
                unordered-containers vector

     

       166007
       166007
       -
              ];

     

       166008
       166008
       -
              testHaskellDepends = [

     

       166009
       166009
       -
                aeson base bytestring directory hspec primitive QuickCheck

     

       166010
       166010
       -
                quickcheck-unicode scientific text unordered-containers vector

     

       166011
       166011
       -
              ];

     

       166012
       166012
       -
              description = "Incremental applicative JSON parser";

     

       166013
       166013
       -
              license = lib.licenses.bsd3;

     

       166014
       166014
       -
            }) {};

     

       166015
       166015
       -
       

     

       166016
       166016
       -
         "json-stream_0_4_4_2" = callPackage

     

       166017
       166017
       -
           ({ mkDerivation, aeson, base, bytestring, directory, hspec

     

       166018
       166018
       -
            , primitive, QuickCheck, quickcheck-unicode, scientific, text

     

       166019
       166019
       -
            , unordered-containers, vector

     

       166020
       166020
       -
            }:

     

       166021
       166021
       -
            mkDerivation {

     

       166022
       166022
       -
              pname = "json-stream";

     

       166023
       166570
        
              version = "0.4.4.2";

     

       166024
       166571
        
              sha256 = "12xchk8dpkr971h5ncwxhh97i8af2fp2rvgxvkg0d3a2ksbfpkal";

     

       166025
       166572
        
              libraryHaskellDepends = [

     
···

       166032
       166579
        
              ];

     

       166033
       166580
        
              description = "Incremental applicative JSON parser";

     

       166034
       166581
        
              license = lib.licenses.bsd3;

     

       166035
       166035
       -
              hydraPlatforms = lib.platforms.none;

     

       166036
       166582
        
            }) {};

     

       166037
       166583
        
       

     

       166038
       166584
        
         "json-syntax" = callPackage

     
···

       168517
       169063
        
            }:

     

       168518
       169064
        
            mkDerivation {

     

       168519
       169065
        
              pname = "keid-frp-banana";

     

       168520
       168520
       -
              version = "0.1.0.0";

     

       168521
       168521
       -
              sha256 = "1d0il5v7chn9gyr5gs15d35pyls1ynnn6jfysx7rqhzhglgvc164";

     

       169066
       169066
       +
              version = "0.1.1.0";

     

       169067
       169067
       +
              sha256 = "0m62bj6cc9xl5rricmc1xxs8q8vlbn7ablcrx923289bynyiir0i";

     

       168522
       169068
        
              libraryHaskellDepends = [

     

       168523
       169069
        
                base geomancy keid-core reactive-banana resourcet rio these vulkan

     

       168524
       169070
        
              ];

     
···

       169596
       170142
        
            }:

     

       169597
       170143
        
            mkDerivation {

     

       169598
       170144
        
              pname = "koji-tool";

     

       169599
       169599
       -
              version = "0.9.4";

     

       169600
       169600
       -
              sha256 = "0s4h1qqw6bxffyvi5qn8k42b3h6alyzcccbad802x5p08arpnfp2";

     

       170145
       170145
       +
              version = "0.9.5";

     

       170146
       170146
       +
              sha256 = "0pcy0xr6iq5g6w0vxvrx7wiz2gy6whb8c2hh53w8x7a2j04na8gn";

     

       169601
       170147
        
              isLibrary = false;

     

       169602
       170148
        
              isExecutable = true;

     

       169603
       170149
        
              executableHaskellDepends = [

     
···

       171651
       172197
        
              pname = "language-conf";

     

       171652
       172198
        
              version = "0.2.2.0";

     

       171653
       172199
        
              sha256 = "16m3m31c17hjkl6mkln5fy8n0pim0cdamqk5g6s65yq65kj3whgp";

     

       172200
       172200
       +
              revision = "1";

     

       172201
       172201
       +
              editedCabalFile = "18r7g8am4wl01wyxw15npyld3ikdssy6ydsjgi2kw3c66cjxmmsh";

     

       171654
       172202
        
              isLibrary = true;

     

       171655
       172203
        
              isExecutable = true;

     

       171656
       172204
        
              libraryHaskellDepends = [

     
···

       177625
       178173
        
            }:

     

       177626
       178174
        
            mkDerivation {

     

       177627
       178175
        
              pname = "linearmap-category";

     

       177628
       177628
       -
              version = "0.4.3.0";

     

       177629
       177629
       -
              sha256 = "0319x0fz863d44p1lzgbnp8nwxdpvn50ms29z7lwh0g3s0mcs628";

     

       178176
       178176
       +
              version = "0.5.0.1";

     

       178177
       178177
       +
              sha256 = "0d8abx928mr0cw04xja5ffybzlmvb4pq6g4cdm9px5r7x567hpb5";

     

       177630
       178178
        
              libraryHaskellDepends = [

     

       177631
       178179
        
                base call-stack constrained-categories containers

     

       177632
       178180
        
                data-default-class free-vector-spaces hashable ieee754 lens linear

     
···

       180862
       181410
        
           ({ mkDerivation, base, logict, mtl, transformers }:

     

       180863
       181411
        
            mkDerivation {

     

       180864
       181412
        
              pname = "logict-state";

     

       180865
       180865
       -
              version = "0.1.0.5";

     

       180866
       180866
       -
              sha256 = "17rx8rj6m4jny52zh4daw6ac9pyp0yns470nm0bf2z9y69mfr63g";

     

       181413
       181413
       +
              version = "0.1.1.0";

     

       181414
       181414
       +
              sha256 = "080qdlq9d8hkzzs4xls5myjdjjzyslz8834mfm4c2ria8hdabqsx";

     

       180867
       181415
        
              libraryHaskellDepends = [ base logict mtl transformers ];

     

       180868
       181416
        
              description = "Library for logic programming based on haskell package logict";

     

       180869
       181417
        
              license = lib.licenses.bsd3;

     
···

       181763
       182311
        
              broken = true;

     

       181764
       182312
        
            }) {};

     

       181765
       182313
        
       

     

       181766
       181766
       -
         "lsp" = callPackage

     

       182314
       182314
       +
         "lsp_1_4_0_0" = callPackage

     

       181767
       182315
        
           ({ mkDerivation, aeson, async, attoparsec, base, bytestring

     

       181768
       182316
        
            , containers, data-default, exceptions, filepath, hashable

     

       181769
       182317
        
            , hslogger, hspec, hspec-discover, lens, lsp-types, mtl

     
···

       181793
       182341
        
              testToolDepends = [ hspec-discover ];

     

       181794
       182342
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       181795
       182343
        
              license = lib.licenses.mit;

     

       182344
       182344
       +
              hydraPlatforms = lib.platforms.none;

     

       181796
       182345
        
            }) {};

     

       181797
       182346
        
       

     

       181798
       181798
       -
         "lsp_1_5_0_0" = callPackage

     

       182347
       182347
       +
         "lsp" = callPackage

     

       181799
       182348
        
           ({ mkDerivation, aeson, async, attoparsec, base, bytestring

     

       181800
       182349
        
            , co-log-core, containers, data-default, directory, exceptions

     

       181801
       182350
        
            , filepath, hashable, hspec, hspec-discover, lens, lsp-types, mtl

     

       181802
       181802
       -
            , network-uri, prettyprinter, QuickCheck, quickcheck-instances

     

       181803
       181803
       -
            , random, scientific, sorted-list, stm, temporary, text, text-rope

     

       181804
       181804
       -
            , time, transformers, unliftio-core, unordered-containers, uuid

     

       182351
       182351
       +
            , prettyprinter, random, sorted-list, stm, temporary, text

     

       182352
       182352
       +
            , text-rope, transformers, unliftio-core, unordered-containers

     

       182353
       182353
       +
            , uuid

     

       181805
       182354
        
            }:

     

       181806
       182355
        
            mkDerivation {

     

       181807
       182356
        
              pname = "lsp";

     

       181808
       181808
       -
              version = "1.5.0.0";

     

       181809
       181809
       -
              sha256 = "0cqrdsq4w4nwhzpxadxa5mvh3cn1zy9wjsq7ib38r6b09zxzi3i7";

     

       182357
       182357
       +
              version = "1.6.0.0";

     

       182358
       182358
       +
              sha256 = "0w04n299d8yh545jggh93wm6nxpp5jwz8hr7qynbxslcdrv06s49";

     

       181810
       182359
        
              isLibrary = true;

     

       181811
       182360
        
              isExecutable = true;

     

       181812
       182361
        
              libraryHaskellDepends = [

     

       181813
       182362
        
                aeson async attoparsec base bytestring co-log-core containers

     

       181814
       182363
        
                data-default directory exceptions filepath hashable lens lsp-types

     

       181815
       181815
       -
                mtl network-uri prettyprinter random scientific sorted-list stm

     

       181816
       181816
       -
                temporary text text-rope time transformers unliftio-core

     

       181817
       181817
       -
                unordered-containers uuid

     

       182364
       182364
       +
                mtl prettyprinter random sorted-list stm temporary text text-rope

     

       182365
       182365
       +
                transformers unliftio-core unordered-containers uuid

     

       181818
       182366
        
              ];

     

       181819
       182367
        
              testHaskellDepends = [

     

       181820
       181820
       -
                aeson base containers filepath hspec lens network-uri QuickCheck

     

       181821
       181821
       -
                quickcheck-instances sorted-list text text-rope

     

       182368
       182368
       +
                base containers hspec sorted-list text text-rope

     

       181822
       182369
        
                unordered-containers

     

       181823
       182370
        
              ];

     

       181824
       182371
        
              testToolDepends = [ hspec-discover ];

     

       181825
       182372
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       181826
       182373
        
              license = lib.licenses.mit;

     

       181827
       181827
       -
              hydraPlatforms = lib.platforms.none;

     

       181828
       182374
        
            }) {};

     

       181829
       182375
        
       

     

       181830
       182376
        
         "lsp-test" = callPackage

     

       181831
       182377
        
           ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async, base

     

       181832
       181832
       -
            , bytestring, conduit, conduit-parse, containers, data-default

     

       181833
       181833
       -
            , Diff, directory, extra, filepath, Glob, hspec, lens, lsp

     

       181834
       181834
       -
            , lsp-types, mtl, parser-combinators, process, some, text, time

     

       181835
       181835
       -
            , transformers, unix, unliftio, unordered-containers

     

       181836
       181836
       -
            }:

     

       181837
       181837
       -
            mkDerivation {

     

       181838
       181838
       -
              pname = "lsp-test";

     

       181839
       181839
       -
              version = "0.14.0.2";

     

       181840
       181840
       -
              sha256 = "1capjilca74cqiwmrhbl1an6ih3227n3g417dfvql0lffa3j6qsf";

     

       181841
       181841
       -
              revision = "1";

     

       181842
       181842
       -
              editedCabalFile = "0szqlr1brhr1z2m2fwqj98ghh73d2sim4r5mbqzm072f6iycl6ky";

     

       181843
       181843
       -
              libraryHaskellDepends = [

     

       181844
       181844
       -
                aeson aeson-pretty ansi-terminal async base bytestring conduit

     

       181845
       181845
       -
                conduit-parse containers data-default Diff directory filepath Glob

     

       181846
       181846
       -
                lens lsp-types mtl parser-combinators process some text time

     

       181847
       181847
       -
                transformers unix unordered-containers

     

       181848
       181848
       -
              ];

     

       181849
       181849
       -
              testHaskellDepends = [

     

       181850
       181850
       -
                aeson base data-default directory filepath hspec lens lsp mtl

     

       181851
       181851
       -
                parser-combinators process text unliftio unordered-containers

     

       181852
       181852
       -
              ];

     

       181853
       181853
       -
              testToolDepends = [ lsp ];

     

       181854
       181854
       -
              benchmarkHaskellDepends = [ base extra lsp process ];

     

       181855
       181855
       -
              description = "Functional test framework for LSP servers";

     

       181856
       181856
       -
              license = lib.licenses.bsd3;

     

       181857
       181857
       -
            }) {};

     

       181858
       181858
       -
       

     

       181859
       181859
       -
         "lsp-test_0_14_0_3" = callPackage

     

       181860
       181860
       -
           ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async, base

     

       181861
       182378
        
            , bytestring, co-log-core, conduit, conduit-parse, containers

     

       181862
       181862
       -
            , data-default, Diff, directory, extra, filepath, Glob, hspec, lens

     

       181863
       181863
       -
            , lsp, lsp-types, mtl, parser-combinators, process, some, text

     

       181864
       181864
       -
            , time, transformers, unix, unliftio, unordered-containers

     

       182379
       182379
       +
            , data-default, Diff, directory, exceptions, extra, filepath, Glob

     

       182380
       182380
       +
            , hspec, lens, lsp, lsp-types, mtl, parser-combinators, process

     

       182381
       182381
       +
            , some, text, time, transformers, unix, unliftio

     

       182382
       182382
       +
            , unordered-containers

     

       181865
       182383
        
            }:

     

       181866
       182384
        
            mkDerivation {

     

       181867
       182385
        
              pname = "lsp-test";

     

       181868
       181868
       -
              version = "0.14.0.3";

     

       181869
       181869
       -
              sha256 = "110hkf91033m1vg90mj7ifq5214r4a2qwswkgb0ahj4sd8c0hsa7";

     

       182386
       182386
       +
              version = "0.14.1.0";

     

       182387
       182387
       +
              sha256 = "0db4mpzn05k3isk1a3rdpqr7if9j0kr3bxdri9739q9a8azf4fp1";

     

       181870
       182388
        
              libraryHaskellDepends = [

     

       181871
       182389
        
                aeson aeson-pretty ansi-terminal async base bytestring co-log-core

     

       181872
       182390
        
                conduit conduit-parse containers data-default Diff directory

     

       181873
       181873
       -
                filepath Glob lens lsp lsp-types mtl parser-combinators process

     

       181874
       181874
       -
                some text time transformers unix unordered-containers

     

       182391
       182391
       +
                exceptions filepath Glob lens lsp lsp-types mtl parser-combinators

     

       182392
       182392
       +
                process some text time transformers unix unordered-containers

     

       181875
       182393
        
              ];

     

       181876
       182394
        
              testHaskellDepends = [

     

       181877
       182395
        
                aeson base co-log-core data-default directory filepath hspec lens

     
···

       181882
       182400
        
              benchmarkHaskellDepends = [ base extra lsp process ];

     

       181883
       182401
        
              description = "Functional test framework for LSP servers";

     

       181884
       182402
        
              license = lib.licenses.bsd3;

     

       181885
       181885
       -
              hydraPlatforms = lib.platforms.none;

     

       181886
       182403
        
            }) {};

     

       181887
       182404
        
       

     

       181888
       181888
       -
         "lsp-types" = callPackage

     

       182405
       182405
       +
         "lsp-types_1_4_0_1" = callPackage

     

       181889
       182406
        
           ({ mkDerivation, aeson, base, binary, bytestring, containers

     

       181890
       182407
        
            , data-default, deepseq, Diff, directory, dlist, filepath, hashable

     

       181891
       182408
        
            , hslogger, lens, mod, mtl, network-uri, rope-utf16-splay

     
···

       181906
       182423
        
              ];

     

       181907
       182424
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       181908
       182425
        
              license = lib.licenses.mit;

     

       182426
       182426
       +
              hydraPlatforms = lib.platforms.none;

     

       181909
       182427
        
            }) {};

     

       181910
       182428
        
       

     

       181911
       181911
       -
         "lsp-types_1_5_0_0" = callPackage

     

       182429
       182429
       +
         "lsp-types" = callPackage

     

       181912
       182430
        
           ({ mkDerivation, aeson, base, binary, containers, data-default

     

       181913
       181913
       -
            , deepseq, Diff, dlist, filepath, hashable, lens, mod, mtl

     

       181914
       181914
       -
            , network-uri, scientific, some, template-haskell, text

     

       181915
       181915
       -
            , unordered-containers

     

       182431
       182431
       +
            , deepseq, Diff, dlist, exceptions, filepath, hashable, hspec

     

       182432
       182432
       +
            , hspec-discover, lens, mod, mtl, network-uri, QuickCheck

     

       182433
       182433
       +
            , quickcheck-instances, safe, scientific, some, template-haskell

     

       182434
       182434
       +
            , text, tuple, unordered-containers

     

       181916
       182435
        
            }:

     

       181917
       182436
        
            mkDerivation {

     

       181918
       182437
        
              pname = "lsp-types";

     

       181919
       181919
       -
              version = "1.5.0.0";

     

       181920
       181920
       -
              sha256 = "18hbhwd0cl32dbw88wskpxkqvnkym0rvjm46mcpnz3nxa1rdbn0m";

     

       182438
       182438
       +
              version = "1.6.0.0";

     

       182439
       182439
       +
              sha256 = "00lqq5lw7pi8qrnjlibsvhldp747kdc9zkr6rg3bbkbz7kxw8p9q";

     

       181921
       182440
        
              libraryHaskellDepends = [

     

       181922
       182441
        
                aeson base binary containers data-default deepseq Diff dlist

     

       181923
       181923
       -
                filepath hashable lens mod mtl network-uri scientific some

     

       181924
       181924
       -
                template-haskell text unordered-containers

     

       182442
       182442
       +
                exceptions filepath hashable lens mod mtl network-uri safe

     

       182443
       182443
       +
                scientific some template-haskell text unordered-containers

     

       182444
       182444
       +
              ];

     

       182445
       182445
       +
              testHaskellDepends = [

     

       182446
       182446
       +
                aeson base filepath hspec lens network-uri QuickCheck

     

       182447
       182447
       +
                quickcheck-instances text tuple

     

       181925
       182448
        
              ];

     

       182449
       182449
       +
              testToolDepends = [ hspec-discover ];

     

       181926
       182450
        
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       181927
       182451
        
              license = lib.licenses.mit;

     

       181928
       181928
       -
              hydraPlatforms = lib.platforms.none;

     

       181929
       182452
        
            }) {};

     

       181930
       182453
        
       

     

       181931
       182454
        
         "lss" = callPackage

     
···

       187463
       187986
        
           ({ mkDerivation, base, template-haskell }:

     

       187464
       187987
        
            mkDerivation {

     

       187465
       187988
        
              pname = "memoize";

     

       187466
       187466
       -
              version = "1.1.1";

     

       187467
       187467
       -
              sha256 = "18xn1rb0wqxm0zi4rm5ipihj5kndmc3dbahxxwdpxwapsk4i9j1k";

     

       187468
       187468
       -
              revision = "1";

     

       187469
       187469
       -
              editedCabalFile = "195bcyvvvqi23b9i575206nvbh406khh9s36ma4ldl1021izq0nr";

     

       187989
       187989
       +
              version = "1.1.2";

     

       187990
       187990
       +
              sha256 = "0sm1vwdkzq6ibnfp5v4lqagwfcnyrsf075mr1a8mwidgcr03lb9l";

     

       187470
       187991
        
              libraryHaskellDepends = [ base template-haskell ];

     

       187471
       187992
        
              testHaskellDepends = [ base ];

     

       187472
       187993
        
              description = "A memoization library";

     
···

       189402
       189923
        
           ({ mkDerivation, base, bytestring, containers, text }:

     

       189403
       189924
        
            mkDerivation {

     

       189404
       189925
        
              pname = "mime-types";

     

       189405
       189405
       -
              version = "0.1.0.9";

     

       189406
       189406
       -
              sha256 = "1lkipa4v73z3l5lqs6sdhl898iq41kyxv2jb9agsajzgd58l6cha";

     

       189926
       189926
       +
              version = "0.1.1.0";

     

       189927
       189927
       +
              sha256 = "06z1z5q7c77sdaych0jq1d54vdkrx1gybzyl6crcnhkiwga1xl7b";

     

       189407
       189928
        
              libraryHaskellDepends = [ base bytestring containers text ];

     

       189408
       189929
        
              description = "Basic mime-type handling types and functions";

     

       189409
       189930
        
              license = lib.licenses.mit;

     
···

       190118
       190639
        
              libraryHaskellDepends = [ aeson base ghcjs-base miso ];

     

       190119
       190640
        
              description = "Miso state transition logger";

     

       190120
       190641
        
              license = lib.licenses.bsd3;

     

       190642
       190642
       +
              hydraPlatforms = lib.platforms.none;

     

       190643
       190643
       +
              broken = true;

     

       190121
       190644
        
            }) {};

     

       190122
       190645
        
       

     

       190123
       190646
        
         "miso-examples" = callPackage

     
···

       191984
       192507
        
            }:

     

       191985
       192508
        
            mkDerivation {

     

       191986
       192509
        
              pname = "monad-logger-aeson";

     

       191987
       191987
       -
              version = "0.3.1.0";

     

       191988
       191988
       -
              sha256 = "1j5gxmzqblqqbdf1xdmi2j0s89hhc28bv8jsbx114wdqyl9v4nb5";

     

       192510
       192510
       +
              version = "0.4.0.2";

     

       192511
       192511
       +
              sha256 = "1z0r0xkd8i9nw9jlzb7m50m2qi48mf6v26h533jn91yw6gi830r0";

     

       191989
       192512
        
              isLibrary = true;

     

       191990
       192513
        
              isExecutable = true;

     

       191991
       192514
        
              libraryHaskellDepends = [

     
···

       193049
       193572
        
              license = lib.licenses.bsd3;

     

       193050
       193573
        
            }) {};

     

       193051
       193574
        
       

     

       193575
       193575
       +
         "monadology" = callPackage

     

       193576
       193576
       +
           ({ mkDerivation, base, constraints, invariant, tasty, tasty-hunit

     

       193577
       193577
       +
            , transformers, type-rig, witness

     

       193578
       193578
       +
            }:

     

       193579
       193579
       +
            mkDerivation {

     

       193580
       193580
       +
              pname = "monadology";

     

       193581
       193581
       +
              version = "0.1";

     

       193582
       193582
       +
              sha256 = "0pr9ia4jns545sk5x85pdwgbw1qd648nh9avb5q7jql7dwa21928";

     

       193583
       193583
       +
              libraryHaskellDepends = [

     

       193584
       193584
       +
                base constraints invariant transformers type-rig witness

     

       193585
       193585
       +
              ];

     

       193586
       193586
       +
              testHaskellDepends = [ base tasty tasty-hunit transformers ];

     

       193587
       193587
       +
              license = lib.licenses.bsd2;

     

       193588
       193588
       +
              hydraPlatforms = lib.platforms.none;

     

       193589
       193589
       +
            }) {};

     

       193590
       193590
       +
       

     

       193052
       193591
        
         "monadplus" = callPackage

     

       193053
       193592
        
           ({ mkDerivation, base }:

     

       193054
       193593
        
            mkDerivation {

     
···

       200719
       201258
        
            }:

     

       200720
       201259
        
            mkDerivation {

     

       200721
       201260
        
              pname = "network-dns";

     

       200722
       200722
       -
              version = "1.1.0.1";

     

       200723
       200723
       -
              sha256 = "0q709qfhph93k8yni6047yr2zhswmc3cvizyyk63vmh3h2dwfmgs";

     

       201261
       201261
       +
              version = "1.1.0.2";

     

       201262
       201262
       +
              sha256 = "1b7bgx2sbcdw6c9p1v458glrwpp7869wz0vr0inz3f7g55ll8a3l";

     

       200724
       201263
        
              isLibrary = true;

     

       200725
       201264
        
              isExecutable = true;

     

       200726
       201265
        
              libraryHaskellDepends = [

     
···

       202153
       202692
        
            }) {};

     

       202154
       202693
        
       

     

       202155
       202694
        
         "ngx-export-tools-extra" = callPackage

     

       202156
       202156
       -
           ({ mkDerivation, aeson, array, base, base64, binary, bytestring

     

       202157
       202157
       -
            , case-insensitive, containers, ede, enclosed-exceptions

     

       202158
       202158
       -
            , http-client, http-client-brread-timeout, http-types, network

     

       202159
       202159
       -
            , ngx-export, ngx-export-tools, pcre-heavy, pcre-light

     

       202160
       202160
       -
            , prettyprinter, safe, snap-core, snap-server, template-haskell

     

       202161
       202161
       -
            , text, time, trifecta, unordered-containers

     

       202695
       202695
       +
           ({ mkDerivation, aeson, array, async, base, base64, binary

     

       202696
       202696
       +
            , bytestring, case-insensitive, containers, ede

     

       202697
       202697
       +
            , enclosed-exceptions, http-client, http-client-brread-timeout

     

       202698
       202698
       +
            , http-types, network, ngx-export, ngx-export-tools, pcre-heavy

     

       202699
       202699
       +
            , pcre-light, prettyprinter, resolv, safe, snap-core, snap-server

     

       202700
       202700
       +
            , template-haskell, text, time, trifecta, unordered-containers

     

       202162
       202701
        
            }:

     

       202163
       202702
        
            mkDerivation {

     

       202164
       202703
        
              pname = "ngx-export-tools-extra";

     

       202165
       202165
       -
              version = "1.1.0";

     

       202166
       202166
       -
              sha256 = "191v30zxqwpyb546sbgbn7nwbxmv7l476msavgrqnahphcgg5zqy";

     

       202704
       202704
       +
              version = "1.2.0";

     

       202705
       202705
       +
              sha256 = "14s7dri3ivy4zk0nsz2xqq951rf3ypicwqnxixjqbrnbwgakccdw";

     

       202167
       202706
        
              libraryHaskellDepends = [

     

       202168
       202168
       -
                aeson array base base64 binary bytestring case-insensitive

     

       202707
       202707
       +
                aeson array async base base64 binary bytestring case-insensitive

     

       202169
       202708
        
                containers ede enclosed-exceptions http-client

     

       202170
       202709
        
                http-client-brread-timeout http-types network ngx-export

     

       202171
       202171
       -
                ngx-export-tools pcre-heavy pcre-light prettyprinter safe snap-core

     

       202172
       202172
       -
                snap-server template-haskell text time trifecta

     

       202710
       202710
       +
                ngx-export-tools pcre-heavy pcre-light prettyprinter resolv safe

     

       202711
       202711
       +
                snap-core snap-server template-haskell text time trifecta

     

       202173
       202712
        
                unordered-containers

     

       202174
       202713
        
              ];

     

       202175
       202714
        
              description = "More extra tools for Nginx haskell module";

     
···

       206710
       207249
        
              license = lib.licenses.bsd3;

     

       206711
       207250
        
            }) {};

     

       206712
       207251
        
       

     

       206713
       206713
       -
         "opaleye_0_9_5_1" = callPackage

     

       207252
       207252
       +
         "opaleye_0_9_6_0" = callPackage

     

       206714
       207253
        
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       206715
       207254
        
            , case-insensitive, containers, contravariant, dotenv, hspec

     

       206716
       207255
        
            , hspec-discover, multiset, postgresql-simple, pretty

     
···

       206720
       207259
        
            }:

     

       206721
       207260
        
            mkDerivation {

     

       206722
       207261
        
              pname = "opaleye";

     

       206723
       206723
       -
              version = "0.9.5.1";

     

       206724
       206724
       -
              sha256 = "0441hf03zll5jjbmb6iz6f13aj5kcmnpqlxfrbb1lsby10i2l0kn";

     

       207262
       207262
       +
              version = "0.9.6.0";

     

       207263
       207263
       +
              sha256 = "1hzpahvpgx8yr6jhyjklj2bigcb2ia4vwcix6kx0i015zns0m04z";

     

       206725
       207264
        
              libraryHaskellDepends = [

     

       206726
       207265
        
                aeson base base16-bytestring bytestring case-insensitive

     

       206727
       207266
        
                contravariant postgresql-simple pretty product-profunctors

     
···

       209413
       209952
        
              broken = true;

     

       209414
       209953
        
            }) {};

     

       209415
       209954
        
       

     

       209955
       209955
       +
         "ormolu_0_1_4_1" = callPackage

     

       209956
       209956
       +
           ({ mkDerivation, ansi-terminal, base, bytestring, containers, Diff

     

       209957
       209957
       +
            , dlist, exceptions, filepath, ghc-lib-parser, gitrev, hspec

     

       209958
       209958
       +
            , hspec-discover, mtl, optparse-applicative, path, path-io, syb

     

       209959
       209959
       +
            , text

     

       209960
       209960
       +
            }:

     

       209961
       209961
       +
            mkDerivation {

     

       209962
       209962
       +
              pname = "ormolu";

     

       209963
       209963
       +
              version = "0.1.4.1";

     

       209964
       209964
       +
              sha256 = "1aamgzimjn9h7kwby9ajfgbj5dx08nmxyalwvpg9rs4xd8pbpd9s";

     

       209965
       209965
       +
              revision = "1";

     

       209966
       209966
       +
              editedCabalFile = "1fi8fxyhw9jdwhsbmrikjqd461wrz7h4kdszrahlvdjfdsn4wh7d";

     

       209967
       209967
       +
              isLibrary = true;

     

       209968
       209968
       +
              isExecutable = true;

     

       209969
       209969
       +
              enableSeparateDataOutput = true;

     

       209970
       209970
       +
              libraryHaskellDepends = [

     

       209971
       209971
       +
                ansi-terminal base bytestring containers Diff dlist exceptions

     

       209972
       209972
       +
                ghc-lib-parser mtl syb text

     

       209973
       209973
       +
              ];

     

       209974
       209974
       +
              executableHaskellDepends = [

     

       209975
       209975
       +
                base filepath ghc-lib-parser gitrev optparse-applicative text

     

       209976
       209976
       +
              ];

     

       209977
       209977
       +
              testHaskellDepends = [

     

       209978
       209978
       +
                base containers filepath hspec path path-io text

     

       209979
       209979
       +
              ];

     

       209980
       209980
       +
              testToolDepends = [ hspec-discover ];

     

       209981
       209981
       +
              description = "A formatter for Haskell source code";

     

       209982
       209982
       +
              license = lib.licenses.bsd3;

     

       209983
       209983
       +
              hydraPlatforms = lib.platforms.none;

     

       209984
       209984
       +
              mainProgram = "ormolu";

     

       209985
       209985
       +
            }) {};

     

       209986
       209986
       +
       

     

       209416
       209987
        
         "ormolu_0_2_0_0" = callPackage

     

       209417
       209988
        
           ({ mkDerivation, ansi-terminal, base, bytestring, containers, Diff

     

       209418
       209989
        
            , dlist, exceptions, filepath, ghc-lib-parser, gitrev, hspec

     
···

       210853
       211424
        
              pname = "pandoc-crossref";

     

       210854
       211425
        
              version = "0.3.13.0";

     

       210855
       211426
        
              sha256 = "0fn5xrsh1x1rk74vd30yvg4ha9aicqbm7r1w0nrq9fkgcmz1q01x";

     

       211427
       211427
       +
              revision = "1";

     

       211428
       211428
       +
              editedCabalFile = "09sjf2fm09jcz1mnqlbmbfwb1237j26xcfgfq6b2fpl00gjg83di";

     

       210856
       211429
        
              isLibrary = true;

     

       210857
       211430
        
              isExecutable = true;

     

       210858
       211431
        
              enableSeparateDataOutput = true;

     
···

       214152
       214725
        
       

     

       214153
       214726
        
         "patrol" = callPackage

     

       214154
       214727
        
           ({ mkDerivation, aeson, base, bytestring, case-insensitive

     

       214155
       214155
       -
            , containers, http-client, http-types, network-uri, text, time

     

       214156
       214156
       -
            , uuid

     

       214728
       214728
       +
            , containers, exceptions, hspec, http-client, http-types

     

       214729
       214729
       +
            , network-uri, text, time, uuid

     

       214157
       214730
        
            }:

     

       214158
       214731
        
            mkDerivation {

     

       214159
       214732
        
              pname = "patrol";

     

       214160
       214160
       -
              version = "0.0.4";

     

       214161
       214161
       -
              sha256 = "1n9ixzmsn35zjk9liwfc0mv3kz3mhczxlj01bc5zjb7cmd66cs3f";

     

       214733
       214733
       +
              version = "0.1.0.1";

     

       214734
       214734
       +
              sha256 = "1mdl9r8kga6n7v7yvds46j0y8mg59h1irw8fbwqzzj142va9q8xc";

     

       214162
       214735
        
              libraryHaskellDepends = [

     

       214163
       214163
       -
                aeson base bytestring case-insensitive containers http-client

     

       214164
       214164
       -
                http-types network-uri text time uuid

     

       214736
       214736
       +
                aeson base bytestring case-insensitive containers exceptions

     

       214737
       214737
       +
                http-client http-types network-uri text time uuid

     

       214738
       214738
       +
              ];

     

       214739
       214739
       +
              testHaskellDepends = [

     

       214740
       214740
       +
                aeson base bytestring case-insensitive containers exceptions hspec

     

       214741
       214741
       +
                http-client http-types network-uri text time uuid

     

       214165
       214742
        
              ];

     

       214166
       214743
        
              description = "Sentry SDK";

     

       214167
       214167
       -
              license = lib.licenses.isc;

     

       214744
       214744
       +
              license = lib.licenses.mit;

     

       214745
       214745
       +
              hydraPlatforms = lib.platforms.none;

     

       214746
       214746
       +
              broken = true;

     

       214168
       214747
        
            }) {};

     

       214169
       214748
        
       

     

       214170
       214749
        
         "patronscraper" = callPackage

     
···

       216049
       216628
        
              maintainers = [ lib.maintainers.psibi ];

     

       216050
       216629
        
            }) {};

     

       216051
       216630
        
       

     

       216052
       216052
       -
         "persistent_2_14_2_0" = callPackage

     

       216631
       216631
       +
         "persistent_2_14_3_0" = callPackage

     

       216053
       216632
        
           ({ mkDerivation, aeson, attoparsec, base, base64-bytestring

     

       216054
       216633
        
            , blaze-html, bytestring, conduit, containers, criterion, deepseq

     

       216055
       216634
        
            , fast-logger, file-embed, hspec, http-api-data, lift-type

     
···

       216060
       216639
        
            }:

     

       216061
       216640
        
            mkDerivation {

     

       216062
       216641
        
              pname = "persistent";

     

       216063
       216063
       -
              version = "2.14.2.0";

     

       216064
       216064
       -
              sha256 = "0iwkn9llas29jmih1zqj52973352pz4yp3dpajdxbypyn16v8p5v";

     

       216642
       216642
       +
              version = "2.14.3.0";

     

       216643
       216643
       +
              sha256 = "06cs30886s0y50kw4p2x8jw1k173il4mfqdfbkkdnd6kc97j920j";

     

       216065
       216644
        
              libraryHaskellDepends = [

     

       216066
       216645
        
                aeson attoparsec base base64-bytestring blaze-html bytestring

     

       216067
       216646
        
                conduit containers fast-logger http-api-data lift-type monad-logger

     
···

       217538
       218117
        
           ({ mkDerivation, base }:

     

       217539
       218118
        
            mkDerivation {

     

       217540
       218119
        
              pname = "phonetic-languages-basis";

     

       217541
       217541
       -
              version = "0.1.1.0";

     

       217542
       217542
       -
              sha256 = "0fpsavprp4l39l0mj7rwckrsbwdphzxs61y24ds1dg3zvhphn06c";

     

       218120
       218120
       +
              version = "0.2.0.0";

     

       218121
       218121
       +
              sha256 = "0hpdf2m0wpzd680hhlsiymygmdr2sw62d2s2qj1pb5757n2kans1";

     

       217543
       218122
        
              libraryHaskellDepends = [ base ];

     

       217544
       218123
        
              description = "A basics of the phonetic-languages functionality";

     

       217545
       218124
        
              license = lib.licenses.mit;

     
···

       217684
       218263
        
            }:

     

       217685
       218264
        
            mkDerivation {

     

       217686
       218265
        
              pname = "phonetic-languages-phonetics-basics";

     

       217687
       217687
       -
              version = "0.9.0.0";

     

       217688
       217688
       -
              sha256 = "1sbsywylcmjf592618rs727k1lfc42yll541cqwm34ffhzsvfzij";

     

       218266
       218266
       +
              version = "0.9.1.0";

     

       218267
       218267
       +
              sha256 = "1ahmgk42n08644h6gmrnz5p13pip18sbyaim5za0z7aaxm9qr70v";

     

       217689
       218268
        
              isLibrary = true;

     

       217690
       218269
        
              isExecutable = true;

     

       217691
       218270
        
              libraryHaskellDepends = [

     
···

       217758
       218337
        
            }:

     

       217759
       218338
        
            mkDerivation {

     

       217760
       218339
        
              pname = "phonetic-languages-simplified-base";

     

       217761
       217761
       -
              version = "0.6.0.0";

     

       217762
       217762
       -
              sha256 = "0bryrk05xpdz3dx96vwma91kig8xs6mkdlbpslk9qxf8b55yrnd2";

     

       218340
       218340
       +
              version = "0.6.1.0";

     

       218341
       218341
       +
              sha256 = "1217hpd1x65nl1yf50bghj8gmnv1wdwd5wbrhx454726p0fbjd7s";

     

       217763
       218342
        
              libraryHaskellDepends = [

     

       217764
       218343
        
                base phonetic-languages-basis phonetic-languages-permutations-array

     

       217765
       218344
        
                subG

     
···

       217800
       218379
        
            }:

     

       217801
       218380
        
            mkDerivation {

     

       217802
       218381
        
              pname = "phonetic-languages-simplified-examples-array";

     

       217803
       217803
       -
              version = "0.20.1.0";

     

       217804
       217804
       -
              sha256 = "0c664k9vvk2j522dwn27caf4d35dshj3z07c9qgzy47rjs65r6xw";

     

       218382
       218382
       +
              version = "0.21.0.0";

     

       218383
       218383
       +
              sha256 = "0mlnlnp5k030pgc7ii8nnqmva97wp5j8vvdhgni9l9qxgj3jvf2c";

     

       217805
       218384
        
              isLibrary = true;

     

       217806
       218385
        
              isExecutable = true;

     

       217807
       218386
        
              libraryHaskellDepends = [

     
···

       217842
       218421
        
            }:

     

       217843
       218422
        
            mkDerivation {

     

       217844
       218423
        
              pname = "phonetic-languages-simplified-examples-common";

     

       217845
       217845
       -
              version = "0.5.0.0";

     

       217846
       217846
       -
              sha256 = "0abby7z7zys9dj8w4xk3289jxl39i4kqdzb3cq5rjvacw5z0im6a";

     

       218424
       218424
       +
              version = "0.5.1.0";

     

       218425
       218425
       +
              sha256 = "0mgkgqf3rjjdrz85qxdjz6b0ivgc9h4k06gj5wnv3nbfjk5wpndk";

     

       217847
       218426
        
              libraryHaskellDepends = [

     

       217848
       218427
        
                base heaps phonetic-languages-simplified-properties-array

     

       217849
       218428
        
                phonetic-languages-ukrainian-array ukrainian-phonetics-basic-array

     
···

       217866
       218445
        
            }:

     

       217867
       218446
        
            mkDerivation {

     

       217868
       218447
        
              pname = "phonetic-languages-simplified-generalized-examples-array";

     

       217869
       217869
       -
              version = "0.18.2.0";

     

       217870
       217870
       -
              sha256 = "0jyg507a4gh437vzxj658nhs8l32p2xg4vifrgs5q5jyck61p7z5";

     

       218448
       218448
       +
              version = "0.19.0.1";

     

       218449
       218449
       +
              sha256 = "1fi106cpm5vl8pp6csz9laph8w0jd79xxbgy5gar28ml33zrji6a";

     

       217871
       218450
        
              libraryHaskellDepends = [

     

       217872
       218451
        
                base cli-arguments foldable-ix heaps mmsyn2-array mmsyn3 parallel

     

       217873
       218452
        
                phonetic-languages-basis phonetic-languages-constraints-array

     
···

       217890
       218469
        
            }:

     

       217891
       218470
        
            mkDerivation {

     

       217892
       218471
        
              pname = "phonetic-languages-simplified-generalized-examples-common";

     

       217893
       217893
       -
              version = "0.5.0.0";

     

       217894
       217894
       -
              sha256 = "0mma7d4hjd45fb7nzhpc438qfjfhkrd59rrm734nw8z5i9j6sv35";

     

       218472
       218472
       +
              version = "0.5.1.0";

     

       218473
       218473
       +
              sha256 = "0mdsn3clb422r02y87ix6bphggvg8m2yacar5y4ipj0vq2ky2m4a";

     

       217895
       218474
        
              libraryHaskellDepends = [

     

       217896
       218475
        
                base heaps phonetic-languages-phonetics-basics

     

       217897
       218476
        
                phonetic-languages-simplified-generalized-properties-array

     
···

       217908
       218487
        
            }:

     

       217909
       218488
        
            mkDerivation {

     

       217910
       218489
        
              pname = "phonetic-languages-simplified-generalized-properties-array";

     

       217911
       217911
       -
              version = "0.11.0.0";

     

       217912
       217912
       -
              sha256 = "0j025aahsfywrf76mqg1p80kri7n8q2madg5qc3l6frlwgxhk44m";

     

       218490
       218490
       +
              version = "0.12.0.0";

     

       218491
       218491
       +
              sha256 = "14y4h8p43wrhxs110jn4idcvj441ai6qhhs86kfnhvrg3glw9nln";

     

       217913
       218492
        
              libraryHaskellDepends = [

     

       217914
       218493
        
                base lists-flines mmsyn2-array phonetic-languages-basis

     

       217915
       218494
        
                phonetic-languages-phonetics-basics phonetic-languages-rhythmicity

     
···

       217963
       218542
        
            }:

     

       217964
       218543
        
            mkDerivation {

     

       217965
       218544
        
              pname = "phonetic-languages-simplified-properties-array";

     

       217966
       217966
       -
              version = "0.15.0.0";

     

       217967
       217967
       -
              sha256 = "1p8mdrz1k6352rfcfmwnvs338bkbhzj89ag1swd9rxa79igsv87v";

     

       218545
       218545
       +
              version = "0.16.0.0";

     

       218546
       218546
       +
              sha256 = "05zbdafl2hga04sy5vcq121n8aigbrhfb4xynvafbyxsmsahflkz";

     

       217968
       218547
        
              libraryHaskellDepends = [

     

       217969
       218548
        
                base lists-flines mmsyn2-array phonetic-languages-basis

     

       217970
       218549
        
                phonetic-languages-rhythmicity phonetic-languages-simplified-base

     
···

       217981
       218560
        
            }:

     

       217982
       218561
        
            mkDerivation {

     

       217983
       218562
        
              pname = "phonetic-languages-simplified-properties-array-common";

     

       217984
       217984
       -
              version = "0.2.0.0";

     

       217985
       217985
       -
              sha256 = "1c61pi61kcbr70xfrxiq50frg7rd9sabj7834x3lhlix41s6rhld";

     

       218563
       218563
       +
              version = "0.3.0.0";

     

       218564
       218564
       +
              sha256 = "1yf0z02zyqp9s441c2rg7rnfhvhiiqz0qm3i9r4jxwjr20hak333";

     

       217986
       218565
        
              libraryHaskellDepends = [

     

       217987
       218566
        
                base phonetic-languages-basis phonetic-languages-rhythmicity

     

       217988
       218567
        
              ];

     
···

       222127
       222706
        
           ({ mkDerivation, base, containers, polysemy, polysemy-kvstore }:

     

       222128
       222707
        
            mkDerivation {

     

       222129
       222708
        
              pname = "polysemy-extra";

     

       222130
       222130
       -
              version = "0.2.0.0";

     

       222131
       222131
       -
              sha256 = "0w8spy9l66ys1x9riwy8cwvywzqxkcbhzrqyia85jgl6mgp96zis";

     

       222132
       222132
       -
              revision = "1";

     

       222133
       222133
       -
              editedCabalFile = "0j44rqp13n5hxl0kx06hhliwmsqxl81jrcylsk7h8khjqmphgsn7";

     

       222134
       222134
       -
              libraryHaskellDepends = [

     

       222135
       222135
       -
                base containers polysemy polysemy-kvstore

     

       222136
       222136
       -
              ];

     

       222137
       222137
       -
              description = "Extra Input and Output functions for polysemy";

     

       222138
       222138
       -
              license = lib.licenses.mit;

     

       222139
       222139
       -
            }) {};

     

       222140
       222140
       -
       

     

       222141
       222141
       -
         "polysemy-extra_0_2_1_0" = callPackage

     

       222142
       222142
       -
           ({ mkDerivation, base, containers, polysemy, polysemy-kvstore }:

     

       222143
       222143
       -
            mkDerivation {

     

       222144
       222144
       -
              pname = "polysemy-extra";

     

       222145
       222709
        
              version = "0.2.1.0";

     

       222146
       222710
        
              sha256 = "1h2y9i4rcnhj09wcgl092x3zprak26fa6bq7iqir5r7vg8k9yfsj";

     

       222147
       222711
        
              libraryHaskellDepends = [

     
···

       222149
       222713
        
              ];

     

       222150
       222714
        
              description = "Extra Input and Output functions for polysemy";

     

       222151
       222715
        
              license = lib.licenses.mit;

     

       222152
       222152
       -
              hydraPlatforms = lib.platforms.none;

     

       222153
       222716
        
            }) {};

     

       222154
       222717
        
       

     

       222155
       222718
        
         "polysemy-fs" = callPackage

     
···

       222271
       222834
        
            }:

     

       222272
       222835
        
            mkDerivation {

     

       222273
       222836
        
              pname = "polysemy-log";

     

       222274
       222274
       -
              version = "0.7.0.0";

     

       222275
       222275
       -
              sha256 = "1n39zpg992vmz0pcf89ljf6vy83z5r27jzg4iakh97bpfskacii6";

     

       222837
       222837
       +
              version = "0.7.1.0";

     

       222838
       222838
       +
              sha256 = "1cmj8h9c8w17sg2kqm9dw6cnh0b3va44n8aga02r1dg7cbw7wlbk";

     

       222276
       222839
        
              libraryHaskellDepends = [

     

       222277
       222840
        
                ansi-terminal async base incipit-core polysemy polysemy-conc

     

       222278
       222841
        
                polysemy-time stm time

     
···

       222292
       222855
        
            }:

     

       222293
       222856
        
            mkDerivation {

     

       222294
       222857
        
              pname = "polysemy-log-co";

     

       222295
       222295
       -
              version = "0.7.0.0";

     

       222296
       222296
       -
              sha256 = "10f5fg0xx58v4rnd62ll68k7anahrgb7iqv5fkz4xb17yvrkgckk";

     

       222858
       222858
       +
              version = "0.7.1.0";

     

       222859
       222859
       +
              sha256 = "1qylyx2fjk5x685z523xzk1z3vld1w7gn62jx43hjgd6839ngzbz";

     

       222297
       222860
        
              libraryHaskellDepends = [

     

       222298
       222861
        
                base co-log co-log-polysemy incipit-core polysemy polysemy-conc

     

       222299
       222862
        
                polysemy-log polysemy-time stm

     
···

       222313
       222876
        
            }:

     

       222314
       222877
        
            mkDerivation {

     

       222315
       222878
        
              pname = "polysemy-log-di";

     

       222316
       222316
       -
              version = "0.7.0.0";

     

       222317
       222317
       -
              sha256 = "03rfjx91wc2m79alxjhi2mqlxnal87nbgwidin04s9x3zq2hyk9k";

     

       222879
       222879
       +
              version = "0.7.1.0";

     

       222880
       222880
       +
              sha256 = "1nzqlj1sdic8hai8bmy6mbic0519nm17zinlrzzlmxha78a75bp9";

     

       222318
       222881
        
              libraryHaskellDepends = [

     

       222319
       222882
        
                base di-polysemy incipit-core polysemy polysemy-conc polysemy-log

     

       222320
       222883
        
                polysemy-time stm

     
···

       222354
       222917
        
            }:

     

       222355
       222918
        
            mkDerivation {

     

       222356
       222919
        
              pname = "polysemy-methodology";

     

       222357
       222357
       -
              version = "0.2.1.0";

     

       222358
       222358
       -
              sha256 = "17md6l5smy1ssn99kij6rnb42bx3fx8h49z85cm9sf41k6lb5k1g";

     

       222359
       222359
       -
              revision = "2";

     

       222360
       222360
       -
              editedCabalFile = "0dpancn85f8j3pxhk43lik6fbznp502cc68rkhqkan791kh1bbc7";

     

       222361
       222361
       -
              libraryHaskellDepends = [

     

       222362
       222362
       -
                base polysemy polysemy-kvstore polysemy-several

     

       222363
       222363
       -
              ];

     

       222364
       222364
       -
              description = "Domain modelling algebra for polysemy";

     

       222365
       222365
       -
              license = lib.licenses.mit;

     

       222366
       222366
       -
            }) {};

     

       222367
       222367
       -
       

     

       222368
       222368
       -
         "polysemy-methodology_0_2_2_0" = callPackage

     

       222369
       222369
       -
           ({ mkDerivation, base, polysemy, polysemy-kvstore, polysemy-several

     

       222370
       222370
       -
            }:

     

       222371
       222371
       -
            mkDerivation {

     

       222372
       222372
       -
              pname = "polysemy-methodology";

     

       222373
       222920
        
              version = "0.2.2.0";

     

       222374
       222921
        
              sha256 = "028hb83q643avimgjhhhi9k1yln7drimxhcfzdjv540m1gbdzpja";

     

       222375
       222922
        
              libraryHaskellDepends = [

     
···

       222377
       222924
        
              ];

     

       222378
       222925
        
              description = "Domain modelling algebra for polysemy";

     

       222379
       222926
        
              license = lib.licenses.mit;

     

       222380
       222380
       -
              hydraPlatforms = lib.platforms.none;

     

       222381
       222927
        
            }) {};

     

       222382
       222928
        
       

     

       222383
       222929
        
         "polysemy-methodology-co-log" = callPackage

     
···

       222613
       223159
        
           ({ mkDerivation, base, polysemy }:

     

       222614
       223160
        
            mkDerivation {

     

       222615
       223161
        
              pname = "polysemy-several";

     

       222616
       222616
       -
              version = "0.1.0.0";

     

       222617
       222617
       -
              sha256 = "1mw6a6fz3879yqnpq6h0221i8b8f05j90b1zydhzr57nsbklxzps";

     

       222618
       222618
       -
              revision = "3";

     

       222619
       222619
       -
              editedCabalFile = "0ig9jqrv9dqasgjhshapcxjqp4vdpl1p09q0fy34847vchg5jgpb";

     

       222620
       222620
       -
              libraryHaskellDepends = [ base polysemy ];

     

       222621
       222621
       -
              description = "Run several effects at once, taken from the polysemy-zoo";

     

       222622
       222622
       -
              license = lib.licenses.mit;

     

       222623
       222623
       -
            }) {};

     

       222624
       222624
       -
       

     

       222625
       222625
       -
         "polysemy-several_0_1_1_0" = callPackage

     

       222626
       222626
       -
           ({ mkDerivation, base, polysemy }:

     

       222627
       222627
       -
            mkDerivation {

     

       222628
       222628
       -
              pname = "polysemy-several";

     

       222629
       223162
        
              version = "0.1.1.0";

     

       222630
       223163
        
              sha256 = "0hbnvvg33nn2lhlpa1x1dzkmc9fcnfkb0fia0aa3pi5l96fsa0nw";

     

       222631
       223164
        
              libraryHaskellDepends = [ base polysemy ];

     

       222632
       223165
        
              description = "Run several effects at once, taken from the polysemy-zoo";

     

       222633
       223166
        
              license = lib.licenses.mit;

     

       222634
       222634
       -
              hydraPlatforms = lib.platforms.none;

     

       222635
       223167
        
            }) {};

     

       222636
       223168
        
       

     

       222637
       223169
        
         "polysemy-socket" = callPackage

     
···

       222757
       223289
        
            }) {};

     

       222758
       223290
        
       

     

       222759
       223291
        
         "polysemy-zoo" = callPackage

     

       222760
       222760
       -
           ({ mkDerivation, async, base, compact, constraints, containers

     

       222761
       222761
       -
            , contravariant, exceptions, ghc-prim, hspec, hspec-discover, mtl

     

       222762
       222762
       -
            , polysemy, polysemy-plugin, random, reflection, streaming, text

     

       222763
       222763
       -
            , transformers

     

       223292
       223292
       +
           ({ mkDerivation, async, base, constraints, containers

     

       223293
       223293
       +
            , contravariant, exceptions, ghc-compact, ghc-prim, hspec

     

       223294
       223294
       +
            , hspec-discover, mtl, polysemy, polysemy-plugin, random

     

       223295
       223295
       +
            , reflection, streaming, text, transformers

     

       222764
       223296
        
            }:

     

       222765
       223297
        
            mkDerivation {

     

       222766
       223298
        
              pname = "polysemy-zoo";

     

       222767
       222767
       -
              version = "0.8.0.0";

     

       222768
       222768
       -
              sha256 = "1ylsr092a42xsbx6aancbcnfp1m66azv3vn44hqar069c5y96ilc";

     

       223299
       223299
       +
              version = "0.8.1.0";

     

       223300
       223300
       +
              sha256 = "0p8ljkpmcf0gf29b8dl1xwra189xfs5ba88fgmys2jcg2wz6yy1d";

     

       222769
       223301
        
              libraryHaskellDepends = [

     

       222770
       222770
       -
                async base compact constraints containers contravariant exceptions

     

       222771
       222771
       -
                ghc-prim mtl polysemy random reflection streaming text transformers

     

       223302
       223302
       +
                async base constraints containers contravariant exceptions

     

       223303
       223303
       +
                ghc-compact ghc-prim mtl polysemy random reflection streaming text

     

       223304
       223304
       +
                transformers

     

       222772
       223305
        
              ];

     

       222773
       223306
        
              testHaskellDepends = [

     

       222774
       222774
       -
                async base compact constraints containers contravariant exceptions

     

       222775
       222775
       -
                ghc-prim hspec mtl polysemy polysemy-plugin random reflection

     

       222776
       222776
       -
                streaming text transformers

     

       223307
       223307
       +
                async base constraints containers contravariant exceptions

     

       223308
       223308
       +
                ghc-compact ghc-prim hspec mtl polysemy polysemy-plugin random

     

       223309
       223309
       +
                reflection streaming text transformers

     

       222777
       223310
        
              ];

     

       222778
       223311
        
              testToolDepends = [ hspec-discover ];

     

       222779
       223312
        
              description = "Experimental, user-contributed effects and interpreters for polysemy";

     
···

       223982
       224515
        
       

     

       223983
       224516
        
         "postgresql-binary" = callPackage

     

       223984
       224517
        
           ({ mkDerivation, aeson, base, binary-parser, bytestring

     

       223985
       223985
       -
            , bytestring-strict-builder, containers, conversion

     

       223986
       223986
       -
            , conversion-bytestring, conversion-text, criterion, json-ast

     

       223987
       223987
       -
            , network-ip, postgresql-libpq, QuickCheck, quickcheck-instances

     

       223988
       223988
       -
            , rerebase, scientific, tasty, tasty-hunit, tasty-quickcheck, text

     

       223989
       223989
       -
            , time, transformers, unordered-containers, uuid, vector

     

       224518
       224518
       +
            , bytestring-strict-builder, containers, criterion, network-ip

     

       224519
       224519
       +
            , postgresql-libpq, QuickCheck, quickcheck-instances, rerebase

     

       224520
       224520
       +
            , scientific, tasty, tasty-hunit, tasty-quickcheck, text, time

     

       224521
       224521
       +
            , transformers, unordered-containers, uuid, vector

     

       223990
       224522
        
            }:

     

       223991
       224523
        
            mkDerivation {

     

       223992
       224524
        
              pname = "postgresql-binary";

     

       223993
       223993
       -
              version = "0.12.4.4";

     

       223994
       223994
       -
              sha256 = "03lh7ply77849xwpxh6k2hz20xl9cmvyx8yq03wqywvh7snd1ss3";

     

       224525
       224525
       +
              version = "0.12.5";

     

       224526
       224526
       +
              sha256 = "0fnc97mw4c0aipbqih8jz23ma8xrspgw7r56qq3vzl4k2p9z49vj";

     

       223995
       224527
        
              libraryHaskellDepends = [

     

       223996
       224528
        
                aeson base binary-parser bytestring bytestring-strict-builder

     

       223997
       224529
        
                containers network-ip scientific text time transformers

     

       223998
       224530
        
                unordered-containers uuid vector

     

       223999
       224531
        
              ];

     

       224000
       224532
        
              testHaskellDepends = [

     

       224001
       224001
       -
                aeson conversion conversion-bytestring conversion-text json-ast

     

       224002
       224002
       -
                network-ip postgresql-libpq QuickCheck quickcheck-instances

     

       224533
       224533
       +
                aeson network-ip postgresql-libpq QuickCheck quickcheck-instances

     

       224003
       224534
        
                rerebase tasty tasty-hunit tasty-quickcheck

     

       224004
       224535
        
              ];

     

       224005
       224536
        
              benchmarkHaskellDepends = [ criterion rerebase ];

     
···

       224007
       224538
        
              license = lib.licenses.mit;

     

       224008
       224539
        
            }) {};

     

       224009
       224540
        
       

     

       224010
       224010
       -
         "postgresql-binary_0_12_5" = callPackage

     

       224541
       224541
       +
         "postgresql-binary_0_13" = callPackage

     

       224011
       224542
        
           ({ mkDerivation, aeson, base, binary-parser, bytestring

     

       224012
       224543
        
            , bytestring-strict-builder, containers, criterion, network-ip

     

       224013
       224544
        
            , postgresql-libpq, QuickCheck, quickcheck-instances, rerebase

     
···

       224016
       224547
        
            }:

     

       224017
       224548
        
            mkDerivation {

     

       224018
       224549
        
              pname = "postgresql-binary";

     

       224019
       224019
       -
              version = "0.12.5";

     

       224020
       224020
       -
              sha256 = "0fnc97mw4c0aipbqih8jz23ma8xrspgw7r56qq3vzl4k2p9z49vj";

     

       224550
       224550
       +
              version = "0.13";

     

       224551
       224551
       +
              sha256 = "0pb4bzkhgw59y2l06gikwf6i8g9wfzkx5swmw9c8hdxdzcjzjb1k";

     

       224021
       224552
        
              libraryHaskellDepends = [

     

       224022
       224553
        
                aeson base binary-parser bytestring bytestring-strict-builder

     

       224023
       224554
        
                containers network-ip scientific text time transformers

     
···

       224225
       224756
        
              testHaskellDepends = [ base bytestring hspec postgresql-simple ];

     

       224226
       224757
        
              description = "PostgreSQL Schema Migrations";

     

       224227
       224758
        
              license = lib.licenses.bsd3;

     

       224759
       224759
       +
              mainProgram = "migrate";

     

       224760
       224760
       +
            }) {};

     

       224761
       224761
       +
       

     

       224762
       224762
       +
         "postgresql-migration_0_2_1_4" = callPackage

     

       224763
       224763
       +
           ({ mkDerivation, base, base64-bytestring, bytestring, cryptohash

     

       224764
       224764
       +
            , directory, filepath, hspec, postgresql-simple, text, time

     

       224765
       224765
       +
            }:

     

       224766
       224766
       +
            mkDerivation {

     

       224767
       224767
       +
              pname = "postgresql-migration";

     

       224768
       224768
       +
              version = "0.2.1.4";

     

       224769
       224769
       +
              sha256 = "0p8rggalgijw02p7m77x443md5dg1kjvvm06v980cchsj148c80s";

     

       224770
       224770
       +
              isLibrary = true;

     

       224771
       224771
       +
              isExecutable = true;

     

       224772
       224772
       +
              libraryHaskellDepends = [

     

       224773
       224773
       +
                base base64-bytestring bytestring cryptohash directory filepath

     

       224774
       224774
       +
                postgresql-simple text time

     

       224775
       224775
       +
              ];

     

       224776
       224776
       +
              executableHaskellDepends = [

     

       224777
       224777
       +
                base base64-bytestring bytestring cryptohash directory

     

       224778
       224778
       +
                postgresql-simple text time

     

       224779
       224779
       +
              ];

     

       224780
       224780
       +
              testHaskellDepends = [ base bytestring hspec postgresql-simple ];

     

       224781
       224781
       +
              description = "PostgreSQL Schema Migrations";

     

       224782
       224782
       +
              license = lib.licenses.bsd3;

     

       224783
       224783
       +
              hydraPlatforms = lib.platforms.none;

     

       224228
       224784
        
              mainProgram = "migrate";

     

       224229
       224785
        
            }) {};

     

       224230
       224786
        
       

     
···

       227025
       227581
        
              license = lib.licenses.bsd3;

     

       227026
       227582
        
            }) {};

     

       227027
       227583
        
       

     

       227584
       227584
       +
         "primitive-primvar" = callPackage

     

       227585
       227585
       +
           ({ mkDerivation, base, primitive }:

     

       227586
       227586
       +
            mkDerivation {

     

       227587
       227587
       +
              pname = "primitive-primvar";

     

       227588
       227588
       +
              version = "0.0.0.0";

     

       227589
       227589
       +
              sha256 = "0dgswszya33vabbyxz96g6z2z4nikqv4h8yj59b0q5j9f3pmmd3z";

     

       227590
       227590
       +
              libraryHaskellDepends = [ base primitive ];

     

       227591
       227591
       +
              description = "Unboxed variables for `Prim` values";

     

       227592
       227592
       +
              license = lib.licenses.cc0;

     

       227593
       227593
       +
            }) {};

     

       227594
       227594
       +
       

     

       227028
       227595
        
         "primitive-simd" = callPackage

     

       227029
       227596
        
           ({ mkDerivation, base, criterion, deepseq, ghc-prim, primitive

     

       227030
       227597
        
            , random, vector

     
···

       227079
       227646
        
              pname = "primitive-unaligned";

     

       227080
       227647
        
              version = "0.1.1.1";

     

       227081
       227648
        
              sha256 = "1f3a46d9dr7x1k8b6ixnp9jzxkppx3g27qsxq4f244ndnf2jnchl";

     

       227649
       227649
       +
              revision = "1";

     

       227650
       227650
       +
              editedCabalFile = "1vksp8izwb2hwyc1li3cf209cf2vaj6ww9n3lyrksr8ymd1p6f16";

     

       227082
       227651
        
              libraryHaskellDepends = [ base primitive ];

     

       227083
       227652
        
              testHaskellDepends = [ base primitive ];

     

       227084
       227653
        
              description = "Unaligned access to primitive arrays";

     

       227085
       227654
        
              license = lib.licenses.bsd3;

     

       227655
       227655
       +
            }) {};

     

       227656
       227656
       +
       

     

       227657
       227657
       +
         "primitive-unaligned_0_1_1_2" = callPackage

     

       227658
       227658
       +
           ({ mkDerivation, base, primitive }:

     

       227659
       227659
       +
            mkDerivation {

     

       227660
       227660
       +
              pname = "primitive-unaligned";

     

       227661
       227661
       +
              version = "0.1.1.2";

     

       227662
       227662
       +
              sha256 = "1ksl2gib15inbd80rf0bl3baj8fmk740liv4fdg9493dlhr3a4pa";

     

       227663
       227663
       +
              libraryHaskellDepends = [ base primitive ];

     

       227664
       227664
       +
              testHaskellDepends = [ base primitive ];

     

       227665
       227665
       +
              description = "Unaligned access to primitive arrays";

     

       227666
       227666
       +
              license = lib.licenses.bsd3;

     

       227667
       227667
       +
              hydraPlatforms = lib.platforms.none;

     

       227086
       227668
        
            }) {};

     

       227087
       227669
        
       

     

       227088
       227670
        
         "primitive-unlifted" = callPackage

     
···

       228992
       229574
        
              license = lib.licenses.bsd3;

     

       228993
       229575
        
            }) {};

     

       228994
       229576
        
       

     

       229577
       229577
       +
         "proto-lens_0_7_1_2" = callPackage

     

       229578
       229578
       +
           ({ mkDerivation, base, bytestring, containers, deepseq, ghc-prim

     

       229579
       229579
       +
            , lens-family, parsec, pretty, primitive, profunctors, QuickCheck

     

       229580
       229580
       +
            , tagged, tasty, tasty-quickcheck, text, transformers, vector

     

       229581
       229581
       +
            }:

     

       229582
       229582
       +
            mkDerivation {

     

       229583
       229583
       +
              pname = "proto-lens";

     

       229584
       229584
       +
              version = "0.7.1.2";

     

       229585
       229585
       +
              sha256 = "0zbkwksmnpc5ivbhckg1kjivn1qbk9pz79vifyiydp90nxjh56fy";

     

       229586
       229586
       +
              enableSeparateDataOutput = true;

     

       229587
       229587
       +
              libraryHaskellDepends = [

     

       229588
       229588
       +
                base bytestring containers deepseq ghc-prim lens-family parsec

     

       229589
       229589
       +
                pretty primitive profunctors tagged text transformers vector

     

       229590
       229590
       +
              ];

     

       229591
       229591
       +
              testHaskellDepends = [

     

       229592
       229592
       +
                base bytestring QuickCheck tasty tasty-quickcheck vector

     

       229593
       229593
       +
              ];

     

       229594
       229594
       +
              description = "A lens-based implementation of protocol buffers in Haskell";

     

       229595
       229595
       +
              license = lib.licenses.bsd3;

     

       229596
       229596
       +
              hydraPlatforms = lib.platforms.none;

     

       229597
       229597
       +
            }) {};

     

       229598
       229598
       +
       

     

       228995
       229599
        
         "proto-lens-arbitrary" = callPackage

     

       228996
       229600
        
           ({ mkDerivation, base, bytestring, containers, lens-family

     

       228997
       229601
        
            , proto-lens, QuickCheck, text

     
···

       229132
       229736
        
              license = lib.licenses.bsd3;

     

       229133
       229737
        
            }) {};

     

       229134
       229738
        
       

     

       229739
       229739
       +
         "proto-lens-runtime_0_7_0_3" = callPackage

     

       229740
       229740
       +
           ({ mkDerivation, base, bytestring, containers, deepseq, filepath

     

       229741
       229741
       +
            , lens-family, proto-lens, text, vector

     

       229742
       229742
       +
            }:

     

       229743
       229743
       +
            mkDerivation {

     

       229744
       229744
       +
              pname = "proto-lens-runtime";

     

       229745
       229745
       +
              version = "0.7.0.3";

     

       229746
       229746
       +
              sha256 = "1fb64xcrgd7v2l4hqqcs0riszklkxh516l7n4p9lwwqmagmgz36y";

     

       229747
       229747
       +
              libraryHaskellDepends = [

     

       229748
       229748
       +
                base bytestring containers deepseq filepath lens-family proto-lens

     

       229749
       229749
       +
                text vector

     

       229750
       229750
       +
              ];

     

       229751
       229751
       +
              doHaddock = false;

     

       229752
       229752
       +
              license = lib.licenses.bsd3;

     

       229753
       229753
       +
              hydraPlatforms = lib.platforms.none;

     

       229754
       229754
       +
            }) {};

     

       229755
       229755
       +
       

     

       229135
       229756
        
         "proto-lens-setup" = callPackage

     

       229136
       229757
        
           ({ mkDerivation, base, bytestring, Cabal, containers, deepseq

     

       229137
       229758
        
            , directory, filepath, process, proto-lens-protoc, temporary, text

     
···

       229650
       230271
        
              pname = "pseudo-boolean";

     

       229651
       230272
        
              version = "0.1.10.0";

     

       229652
       230273
        
              sha256 = "1p9w1d80d2kp7wp7wp6xf9dz1iv9knhy8b75mklz7zq3cf5gvnrh";

     

       229653
       229653
       -
              revision = "2";

     

       229654
       229654
       -
              editedCabalFile = "0i5f3p9rhb3pvrrcw5x83h5vhkg5pmakfs1prg7fik447k1bda66";

     

       230274
       230274
       +
              revision = "3";

     

       230275
       230275
       +
              editedCabalFile = "0cn7v9r8kd9xcfhkzd2ln5kqfwv4dc81c4lmv402sa1w82sbbf2h";

     

       229655
       230276
        
              libraryHaskellDepends = [

     

       229656
       230277
        
                attoparsec base bytestring bytestring-builder containers deepseq

     

       229657
       230278
        
                dlist hashable megaparsec parsec void

     
···

       230460
       231081
        
       

     

       230461
       231082
        
         "purebred-email" = callPackage

     

       230462
       231083
        
           ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring

     

       230463
       230463
       -
            , case-insensitive, concise, deepseq, hedgehog, lens, QuickCheck

     

       231084
       231084
       +
            , case-insensitive, concise, deepseq, hedgehog, lens

     

       230464
       231085
        
            , quickcheck-instances, random, semigroupoids, stringsearch, tasty

     

       230465
       231086
        
            , tasty-golden, tasty-hedgehog, tasty-hunit, tasty-quickcheck, text

     

       230466
       231087
        
            , time

     

       230467
       231088
        
            }:

     

       230468
       231089
        
            mkDerivation {

     

       230469
       231090
        
              pname = "purebred-email";

     

       230470
       230470
       -
              version = "0.5.1";

     

       230471
       230471
       -
              sha256 = "1g64z0ibbp5sq9m1jmxks5l89rdmdg8szidclxwz2xs0ilzsy65m";

     

       231091
       231091
       +
              version = "0.6";

     

       231092
       231092
       +
              sha256 = "0i89jyzy04fsrkfsqasrszhhax3hhmms7ih31sypn67w3awkk985";

     

       230472
       231093
        
              isLibrary = true;

     

       230473
       231094
        
              isExecutable = true;

     

       230474
       231095
        
              libraryHaskellDepends = [

     
···

       230477
       231098
        
              ];

     

       230478
       231099
        
              testHaskellDepends = [

     

       230479
       231100
        
                attoparsec base bytestring case-insensitive hedgehog lens

     

       230480
       230480
       -
                QuickCheck quickcheck-instances random tasty tasty-golden

     

       230481
       230481
       -
                tasty-hedgehog tasty-hunit tasty-quickcheck text time

     

       231101
       231101
       +
                quickcheck-instances random tasty tasty-golden tasty-hedgehog

     

       231102
       231102
       +
                tasty-hunit tasty-quickcheck text time

     

       230482
       231103
        
              ];

     

       230483
       231104
        
              description = "types and parser for email messages (including MIME)";

     

       230484
       231105
        
              license = lib.licenses.agpl3Plus;

     
···

       230939
       231560
        
            }:

     

       230940
       231561
        
            mkDerivation {

     

       230941
       231562
        
              pname = "pusher-http-haskell";

     

       230942
       230942
       -
              version = "2.1.0.11";

     

       230943
       230943
       -
              sha256 = "1vrpdj0z41zhpfy4lk87w4fyfvrp27rvqds9j5s2wyxj95k2scm5";

     

       230944
       230944
       -
              libraryHaskellDepends = [

     

       230945
       230945
       -
                aeson base base16-bytestring bytestring cryptonite hashable

     

       230946
       230946
       -
                http-client http-client-tls http-types memory text time

     

       230947
       230947
       -
                unordered-containers

     

       230948
       230948
       -
              ];

     

       230949
       230949
       -
              testHaskellDepends = [

     

       230950
       230950
       -
                aeson base bytestring hspec QuickCheck text unordered-containers

     

       230951
       230951
       -
              ];

     

       230952
       230952
       -
              description = "Haskell client library for the Pusher Channels HTTP API";

     

       230953
       230953
       -
              license = lib.licenses.mit;

     

       230954
       230954
       -
            }) {};

     

       230955
       230955
       -
       

     

       230956
       230956
       -
         "pusher-http-haskell_2_1_0_12" = callPackage

     

       230957
       230957
       -
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       230958
       230958
       -
            , cryptonite, hashable, hspec, http-client, http-client-tls

     

       230959
       230959
       -
            , http-types, memory, QuickCheck, text, time, unordered-containers

     

       230960
       230960
       -
            }:

     

       230961
       230961
       -
            mkDerivation {

     

       230962
       230962
       -
              pname = "pusher-http-haskell";

     

       230963
       231563
        
              version = "2.1.0.12";

     

       230964
       231564
        
              sha256 = "12gk26br85spyl0pcdr71a0i3mq4cbb8qi6vwkmgx4k6hg7h43xl";

     

       230965
       231565
        
              libraryHaskellDepends = [

     
···

       230972
       231572
        
              ];

     

       230973
       231573
        
              description = "Haskell client library for the Pusher Channels HTTP API";

     

       230974
       231574
        
              license = lib.licenses.mit;

     

       230975
       230975
       -
              hydraPlatforms = lib.platforms.none;

     

       230976
       231575
        
            }) {};

     

       230977
       231576
        
       

     

       230978
       231577
        
         "pusher-ws" = callPackage

     
···

       231962
       232561
        
              description = "Unit conversion and manipulation library";

     

       231963
       232562
        
              license = lib.licenses.bsd3;

     

       231964
       232563
        
              mainProgram = "quantities";

     

       232564
       232564
       +
            }) {};

     

       232565
       232565
       +
       

     

       232566
       232566
       +
         "quantizer" = callPackage

     

       232567
       232567
       +
           ({ mkDerivation, base, subG, uniqueness-periods-vector-stats }:

     

       232568
       232568
       +
            mkDerivation {

     

       232569
       232569
       +
              pname = "quantizer";

     

       232570
       232570
       +
              version = "0.1.0.0";

     

       232571
       232571
       +
              sha256 = "0pall4g5fd8flv7b380y7qqnh630jbnf5kbzxhpx13qr287casrh";

     

       232572
       232572
       +
              libraryHaskellDepends = [

     

       232573
       232573
       +
                base subG uniqueness-periods-vector-stats

     

       232574
       232574
       +
              ];

     

       232575
       232575
       +
              description = "Library to provide the behaviour similar to quantum states superposition";

     

       232576
       232576
       +
              license = lib.licenses.mit;

     

       231965
       232577
        
            }) {};

     

       231966
       232578
        
       

     

       231967
       232579
        
         "quantum-arrow" = callPackage

     
···

       236430
       237042
        
              license = lib.licenses.mit;

     

       236431
       237043
        
            }) {};

     

       236432
       237044
        
       

     

       236433
       236433
       -
         "rebase_1_16" = callPackage

     

       237045
       237045
       +
         "rebase_1_16_1" = callPackage

     

       236434
       237046
        
           ({ mkDerivation, base, bifunctors, bytestring, comonad, containers

     

       236435
       237047
        
            , contravariant, deepseq, dlist, either, groups, hashable

     

       236436
       237048
        
            , invariant, mtl, profunctors, scientific, selective, semigroupoids

     
···

       236439
       237051
        
            }:

     

       236440
       237052
        
            mkDerivation {

     

       236441
       237053
        
              pname = "rebase";

     

       236442
       236442
       -
              version = "1.16";

     

       236443
       236443
       -
              sha256 = "0r5dmkw1bb3fkc40gjdcswf7388c8w7lzvzh7wvf7vk4lhxjaxhd";

     

       237054
       237054
       +
              version = "1.16.1";

     

       237055
       237055
       +
              sha256 = "0mb1x5p3lvfhxsrnmkhsv6f4rd1cxp6m3qg6kyz30svrbwxsvvkz";

     

       236444
       237056
        
              revision = "1";

     

       236445
       236445
       -
              editedCabalFile = "048h2ir37j09s0z7fb364p7smyhzq6h4705qklhvylak9242gz2n";

     

       237057
       237057
       +
              editedCabalFile = "1igpk9gz54jfvf5m69xcp7hl567c4lkbmwhzylcbx0i1n0pd7i2n";

     

       236446
       237058
        
              libraryHaskellDepends = [

     

       236447
       237059
        
                base bifunctors bytestring comonad containers contravariant deepseq

     

       236448
       237060
        
                dlist either groups hashable invariant mtl profunctors scientific

     
···

       237590
       238202
        
              pname = "reflex";

     

       237591
       238203
        
              version = "0.8.2.0";

     

       237592
       238204
        
              sha256 = "1hvagxcs413bqairxf77vp19484mxnbfckhd44wv22ncwfh5mq6d";

     

       237593
       237593
       -
              revision = "2";

     

       237594
       237594
       -
              editedCabalFile = "1msjk8bk59dv1pm90l2hxkrl185aj4xblzgc7nkwn7x31ykcnhyw";

     

       238205
       238205
       +
              revision = "3";

     

       238206
       238206
       +
              editedCabalFile = "1sax4fx7pgn85dvih4y6mnvhdq8nssan1rcys5kdfhirnr4vgn1m";

     

       237595
       238207
        
              libraryHaskellDepends = [

     

       237596
       238208
        
                base bifunctors comonad constraints constraints-extras containers

     

       237597
       238209
        
                data-default dependent-map dependent-sum exception-transformers

     
···

       239515
       240127
        
            }:

     

       239516
       240128
        
            mkDerivation {

     

       239517
       240129
        
              pname = "registry-hedgehog";

     

       239518
       239518
       -
              version = "0.7.0.3";

     

       239519
       239519
       -
              sha256 = "1scas90v8qsikacahk6z5xkg4k6vy0fq4kpgdzgmzibfgjb5d4an";

     

       240130
       240130
       +
              version = "0.7.0.5";

     

       240131
       240131
       +
              sha256 = "1mc8m74mx5119b6k7ac4ysilnwm0163a4c57gc15620mw3f0w0dl";

     

       239520
       240132
        
              libraryHaskellDepends = [

     

       239521
       240133
        
                base containers hedgehog mmorph multimap protolude registry tasty

     

       239522
       240134
        
                tasty-discover tasty-hedgehog tasty-th template-haskell text

     
···

       239568
       240180
        
            }:

     

       239569
       240181
        
            mkDerivation {

     

       239570
       240182
        
              pname = "registry-messagepack";

     

       239571
       239571
       -
              version = "0.3.0.1";

     

       239572
       239572
       -
              sha256 = "00h4ics8gavvscp3sjp1j0vyhqj90zi7pmxqhrlzja0fnmhb1brj";

     

       240183
       240183
       +
              version = "0.3.0.2";

     

       240184
       240184
       +
              sha256 = "1xp6b3w8gs702q27cg50gh5mcakgxdc23ahnbbgg2cw4mg4l9nqz";

     

       239573
       240185
        
              libraryHaskellDepends = [

     

       239574
       240186
        
                base containers msgpack protolude registry template-haskell text

     

       239575
       240187
        
                transformers vector

     
···

       241361
       241973
        
              license = lib.licenses.mit;

     

       241362
       241974
        
            }) {};

     

       241363
       241975
        
       

     

       241976
       241976
       +
         "rerebase_1_16_1" = callPackage

     

       241977
       241977
       +
           ({ mkDerivation, rebase }:

     

       241978
       241978
       +
            mkDerivation {

     

       241979
       241979
       +
              pname = "rerebase";

     

       241980
       241980
       +
              version = "1.16.1";

     

       241981
       241981
       +
              sha256 = "04pw2j4nh8x53axmfzp9d2plmiwxpxddgwcji0a8j24lkdyv8k32";

     

       241982
       241982
       +
              libraryHaskellDepends = [ rebase ];

     

       241983
       241983
       +
              description = "Reexports from \"base\" with a bunch of other standard libraries";

     

       241984
       241984
       +
              license = lib.licenses.mit;

     

       241985
       241985
       +
              hydraPlatforms = lib.platforms.none;

     

       241986
       241986
       +
            }) {};

     

       241987
       241987
       +
       

     

       241364
       241988
        
         "reroute" = callPackage

     

       241365
       241989
        
           ({ mkDerivation, base, criterion, deepseq, graph-core, hashable

     

       241366
       241990
        
            , hspec, http-api-data, hvect, mtl, random, regex-compat, text

     
···

       242578
       243202
        
              ];

     

       242579
       243203
        
              description = "Robert Fischer's Common library";

     

       242580
       243204
        
              license = lib.licenses.bsd3;

     

       243205
       243205
       +
              hydraPlatforms = lib.platforms.none;

     

       243206
       243206
       +
              broken = true;

     

       242581
       243207
        
            }) {};

     

       242582
       243208
        
       

     

       242583
       243209
        
         "rfc-env" = callPackage

     
···

       247212
       247838
        
         "sandwich" = callPackage

     

       247213
       247839
        
           ({ mkDerivation, aeson, ansi-terminal, async, base, brick

     

       247214
       247840
        
            , bytestring, colour, containers, directory, exceptions, filepath

     

       247215
       247215
       -
            , free, haskell-src-exts, lens, lifted-async, microlens

     

       247216
       247216
       -
            , microlens-th, monad-control, monad-logger, mtl

     

       247217
       247217
       -
            , optparse-applicative, pretty-show, process, safe, safe-exceptions

     

       247218
       247218
       -
            , stm, string-interpolate, template-haskell, text, time

     

       247219
       247219
       -
            , transformers, transformers-base, unix, unliftio-core, vector, vty

     

       247220
       247220
       -
            }:

     

       247221
       247221
       -
            mkDerivation {

     

       247222
       247222
       -
              pname = "sandwich";

     

       247223
       247223
       -
              version = "0.1.0.10";

     

       247224
       247224
       -
              sha256 = "1163l9ammy91aclxf12hk5z65ivw4zz4b04bgpdlwalhlygnlxba";

     

       247225
       247225
       -
              isLibrary = true;

     

       247226
       247226
       -
              isExecutable = true;

     

       247227
       247227
       -
              libraryHaskellDepends = [

     

       247228
       247228
       -
                aeson ansi-terminal async base brick bytestring colour containers

     

       247229
       247229
       -
                directory exceptions filepath free haskell-src-exts lens

     

       247230
       247230
       -
                lifted-async microlens microlens-th monad-control monad-logger mtl

     

       247231
       247231
       -
                optparse-applicative pretty-show process safe safe-exceptions stm

     

       247232
       247232
       -
                string-interpolate template-haskell text time transformers

     

       247233
       247233
       -
                transformers-base unix unliftio-core vector vty

     

       247234
       247234
       -
              ];

     

       247235
       247235
       -
              executableHaskellDepends = [

     

       247236
       247236
       -
                aeson ansi-terminal async base brick bytestring colour containers

     

       247237
       247237
       -
                directory exceptions filepath free haskell-src-exts lens

     

       247238
       247238
       -
                lifted-async microlens microlens-th monad-control monad-logger mtl

     

       247239
       247239
       -
                optparse-applicative pretty-show process safe safe-exceptions stm

     

       247240
       247240
       -
                string-interpolate template-haskell text time transformers

     

       247241
       247241
       -
                transformers-base unix unliftio-core vector vty

     

       247242
       247242
       -
              ];

     

       247243
       247243
       -
              testHaskellDepends = [

     

       247244
       247244
       -
                aeson ansi-terminal async base brick bytestring colour containers

     

       247245
       247245
       -
                directory exceptions filepath free haskell-src-exts lens

     

       247246
       247246
       -
                lifted-async microlens microlens-th monad-control monad-logger mtl

     

       247247
       247247
       -
                optparse-applicative pretty-show process safe safe-exceptions stm

     

       247248
       247248
       -
                string-interpolate template-haskell text time transformers

     

       247249
       247249
       -
                transformers-base unix unliftio-core vector vty

     

       247250
       247250
       -
              ];

     

       247251
       247251
       -
              description = "Yet another test framework for Haskell";

     

       247252
       247252
       -
              license = lib.licenses.bsd3;

     

       247253
       247253
       -
            }) {};

     

       247254
       247254
       -
       

     

       247255
       247255
       -
         "sandwich_0_1_0_11" = callPackage

     

       247256
       247256
       -
           ({ mkDerivation, aeson, ansi-terminal, async, base, brick

     

       247257
       247257
       -
            , bytestring, colour, containers, directory, exceptions, filepath

     

       247258
       247841
        
            , free, haskell-src-exts, lifted-async, microlens, microlens-th

     

       247259
       247842
        
            , monad-control, monad-logger, mtl, optparse-applicative

     

       247260
       247843
        
            , pretty-show, process, safe, safe-exceptions, stm

     
···

       247293
       247876
        
              ];

     

       247294
       247877
        
              description = "Yet another test framework for Haskell";

     

       247295
       247878
        
              license = lib.licenses.bsd3;

     

       247296
       247296
       -
              hydraPlatforms = lib.platforms.none;

     

       247297
       247879
        
            }) {};

     

       247298
       247880
        
       

     

       247299
       247881
        
         "sandwich-hedgehog" = callPackage

     
···

       250548
       251130
        
              license = lib.licenses.mit;

     

       250549
       251131
        
            }) {};

     

       250550
       251132
        
       

     

       251133
       251133
       +
         "selda_0_5_2_0" = callPackage

     

       251134
       251134
       +
           ({ mkDerivation, base, bytestring, containers, exceptions, mtl

     

       251135
       251135
       +
            , random, text, time, uuid-types

     

       251136
       251136
       +
            }:

     

       251137
       251137
       +
            mkDerivation {

     

       251138
       251138
       +
              pname = "selda";

     

       251139
       251139
       +
              version = "0.5.2.0";

     

       251140
       251140
       +
              sha256 = "1n0zkd80a9z83q5nld0gyg2p25nfy4rjkihql88binhknhk3hkgk";

     

       251141
       251141
       +
              libraryHaskellDepends = [

     

       251142
       251142
       +
                base bytestring containers exceptions mtl random text time

     

       251143
       251143
       +
                uuid-types

     

       251144
       251144
       +
              ];

     

       251145
       251145
       +
              description = "Multi-backend, high-level EDSL for interacting with SQL databases";

     

       251146
       251146
       +
              license = lib.licenses.mit;

     

       251147
       251147
       +
              hydraPlatforms = lib.platforms.none;

     

       251148
       251148
       +
            }) {};

     

       251149
       251149
       +
       

     

       250551
       251150
        
         "selda-json" = callPackage

     

       250552
       251151
        
           ({ mkDerivation, aeson, base, bytestring, selda, text }:

     

       250553
       251152
        
            mkDerivation {

     

       250554
       251153
        
              pname = "selda-json";

     

       250555
       250555
       -
              version = "0.1.1.0";

     

       250556
       250556
       -
              sha256 = "1ai24qmz5nkpqx0zd24ix0ci5aqiccfy57fkf8f87swrv28101l8";

     

       250557
       250557
       -
              revision = "1";

     

       250558
       250558
       -
              editedCabalFile = "1gajzv8zhj8i3bxzjh81vjn8j2igh3nrawfpddvxg1ayb5l2d2y0";

     

       251154
       251154
       +
              version = "0.1.1.1";

     

       251155
       251155
       +
              sha256 = "0sjy83538g6a2yq1q9ifadfwp7lf5b2grmm0i02qpp47n1b039rh";

     

       250559
       251156
        
              libraryHaskellDepends = [ aeson base bytestring selda text ];

     

       250560
       251157
        
              description = "JSON support for the Selda database library";

     

       250561
       251158
        
              license = lib.licenses.mit;

     
···

       250569
       251166
        
            }:

     

       250570
       251167
        
            mkDerivation {

     

       250571
       251168
        
              pname = "selda-postgresql";

     

       250572
       250572
       -
              version = "0.1.8.1";

     

       250573
       250573
       -
              sha256 = "0dxycilvxjbi1cy9c0rzq9ywh48i2lh37j77a5i1x6v1625h51mk";

     

       250574
       250574
       -
              revision = "1";

     

       250575
       250575
       -
              editedCabalFile = "10qlb9yswjsvpj1f7dmm0amkq52g00f1kc2xqh1d7vfkvkb2bhk6";

     

       251169
       251169
       +
              version = "0.1.8.2";

     

       251170
       251170
       +
              sha256 = "1rn75ynvn2iipz9yj3h4iwgz2922s9hwpgiga0brj00pb0b5a52g";

     

       250576
       251171
        
              libraryHaskellDepends = [

     

       250577
       251172
        
                base bytestring exceptions postgresql-binary postgresql-libpq selda

     

       250578
       251173
        
                selda-json text time uuid-types

     
···

       250598
       251193
        
              ];

     

       250599
       251194
        
              description = "SQLite backend for the Selda database EDSL";

     

       250600
       251195
        
              license = lib.licenses.mit;

     

       251196
       251196
       +
            }) {};

     

       251197
       251197
       +
       

     

       251198
       251198
       +
         "selda-sqlite_0_1_7_2" = callPackage

     

       251199
       251199
       +
           ({ mkDerivation, base, bytestring, direct-sqlite, directory

     

       251200
       251200
       +
            , exceptions, selda, text, time, uuid-types

     

       251201
       251201
       +
            }:

     

       251202
       251202
       +
            mkDerivation {

     

       251203
       251203
       +
              pname = "selda-sqlite";

     

       251204
       251204
       +
              version = "0.1.7.2";

     

       251205
       251205
       +
              sha256 = "1cldk804vv82dp3hyxcddzy3plijgkmjz3ykrjzy7afqni97yc4y";

     

       251206
       251206
       +
              libraryHaskellDepends = [

     

       251207
       251207
       +
                base bytestring direct-sqlite directory exceptions selda text time

     

       251208
       251208
       +
                uuid-types

     

       251209
       251209
       +
              ];

     

       251210
       251210
       +
              description = "SQLite backend for the Selda database EDSL";

     

       251211
       251211
       +
              license = lib.licenses.mit;

     

       251212
       251212
       +
              hydraPlatforms = lib.platforms.none;

     

       250601
       251213
        
            }) {};

     

       250602
       251214
        
       

     

       250603
       251215
        
         "select" = callPackage

     
···

       251339
       251951
        
            }:

     

       251340
       251952
        
            mkDerivation {

     

       251341
       251953
        
              pname = "seonbi";

     

       251342
       251342
       -
              version = "0.3.2";

     

       251343
       251343
       -
              sha256 = "1a0mh7fi0h04n56vdl5xh2p4ql813743x7y11zl06llrj5cvgggg";

     

       251954
       251954
       +
              version = "0.3.4";

     

       251955
       251955
       +
              sha256 = "1yi01l1hn9fx7n39s5f7vwp9hlv5f0ah0gxs14dd46i2xrpxf5a8";

     

       251344
       251956
        
              isLibrary = true;

     

       251345
       251957
        
              isExecutable = true;

     

       251346
       251958
        
              enableSeparateDataOutput = true;

     
···

       255913
       256525
        
              mainProgram = "shake";

     

       255914
       256526
        
            }) {};

     

       255915
       256527
        
       

     

       256528
       256528
       +
         "shake_0_19_7" = callPackage

     

       256529
       256529
       +
           ({ mkDerivation, base, binary, bytestring, deepseq, directory

     

       256530
       256530
       +
            , extra, filepath, filepattern, hashable, heaps, js-dgtable

     

       256531
       256531
       +
            , js-flot, js-jquery, primitive, process, QuickCheck, random, time

     

       256532
       256532
       +
            , transformers, unix, unordered-containers, utf8-string

     

       256533
       256533
       +
            }:

     

       256534
       256534
       +
            mkDerivation {

     

       256535
       256535
       +
              pname = "shake";

     

       256536
       256536
       +
              version = "0.19.7";

     

       256537
       256537
       +
              sha256 = "1lcr6q53qwm308bny6gfawcjhxsmalqi3dnwckam02zp2apmcaim";

     

       256538
       256538
       +
              isLibrary = true;

     

       256539
       256539
       +
              isExecutable = true;

     

       256540
       256540
       +
              enableSeparateDataOutput = true;

     

       256541
       256541
       +
              libraryHaskellDepends = [

     

       256542
       256542
       +
                base binary bytestring deepseq directory extra filepath filepattern

     

       256543
       256543
       +
                hashable heaps js-dgtable js-flot js-jquery primitive process

     

       256544
       256544
       +
                random time transformers unix unordered-containers utf8-string

     

       256545
       256545
       +
              ];

     

       256546
       256546
       +
              executableHaskellDepends = [

     

       256547
       256547
       +
                base binary bytestring deepseq directory extra filepath filepattern

     

       256548
       256548
       +
                hashable heaps js-dgtable js-flot js-jquery primitive process

     

       256549
       256549
       +
                random time transformers unix unordered-containers utf8-string

     

       256550
       256550
       +
              ];

     

       256551
       256551
       +
              testHaskellDepends = [

     

       256552
       256552
       +
                base binary bytestring deepseq directory extra filepath filepattern

     

       256553
       256553
       +
                hashable heaps js-dgtable js-flot js-jquery primitive process

     

       256554
       256554
       +
                QuickCheck random time transformers unix unordered-containers

     

       256555
       256555
       +
                utf8-string

     

       256556
       256556
       +
              ];

     

       256557
       256557
       +
              description = "Build system library, like Make, but more accurate dependencies";

     

       256558
       256558
       +
              license = lib.licenses.bsd3;

     

       256559
       256559
       +
              hydraPlatforms = lib.platforms.none;

     

       256560
       256560
       +
              mainProgram = "shake";

     

       256561
       256561
       +
            }) {};

     

       256562
       256562
       +
       

     

       255916
       256563
        
         "shake-ats" = callPackage

     

       255917
       256564
        
           ({ mkDerivation, base, binary, cdeps, dependency, directory, hs2ats

     

       255918
       256565
        
            , language-ats, microlens, shake, shake-c, shake-cabal, shake-ext

     
···

       261685
       262332
        
              mainProgram = "smtp2mta";

     

       261686
       262333
        
            }) {};

     

       261687
       262334
        
       

     

       262335
       262335
       +
         "smtpbz" = callPackage

     

       262336
       262336
       +
            , network, process, QuickCheck, random, safecopy, socks, tagged

     

       262337
       262337
       +
            , text

     

       262338
       262338
       +
            }:

     

       262339
       262339
       +
            mkDerivation {

     

       262340
       262340
       +
              pname = "smtpbz";

     

       262341
       262341
       +
              version = "1.0.0";

     

       262342
       262342
       +
              sha256 = "1xn66l3bifrd6y12rssgsj4dihy325c9lbxl20ms49rnkcnwzwfq";

     

       262343
       262343
       +
              libraryHaskellDepends = [

     

       262344
       262344
       +
                aeson base bytestring http-conduit http-types text

     

       262345
       262345
       +
              ];

     

       262346
       262346
       +
              description = "This is smtpbz";

     

       262347
       262347
       +
              license = lib.licenses.bsd2;

     

       262348
       262348
       +
            }) {};

     

       262349
       262349
       +
       

     

       261688
       262350
        
         "smtps-gmail" = callPackage

     

       261689
       262351
        
           ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring

     

       261690
       262352
        
            , conduit, conduit-extra, data-default, filepath, mime-mail

     
···

       266887
       267549
        
            , mintty, mono-traversable, mtl, mustache, neat-interpolation

     

       266888
       267550
        
            , network-uri, open-browser, optparse-applicative, pantry, path

     

       266889
       267551
        
            , path-io, persistent, persistent-sqlite, persistent-template

     

       266890
       266890
       -
            , pretty, primitive, process, project-template, QuickCheck

     

       267552
       267552
       +
            , pretty, primitive, process, project-template, QuickCheck, random

     

       266891
       267553
        
            , raw-strings-qq, retry, rio, rio-prettyprint, semigroups

     

       266892
       267554
        
            , smallcheck, split, stm, streaming-commons, tar, template-haskell

     

       266893
       267555
        
            , temporary, text, text-metrics, th-reify-many, time, tls

     
···

       266897
       267559
        
            }:

     

       266898
       267560
        
            mkDerivation {

     

       266899
       267561
        
              pname = "stack";

     

       266900
       266900
       -
              version = "2.7.5";

     

       266901
       266901
       -
              sha256 = "103yyfl02chbmkb6csri403921z7jhfdrrv99lch951flv149pcx";

     

       266902
       266902
       -
              revision = "2";

     

       266903
       266903
       -
              editedCabalFile = "18hiffjrzfn97yl9al97vxing6qajiv732nr61i4lv1y4xhhm6v8";

     

       267562
       267562
       +
              version = "2.9.1";

     

       267563
       267563
       +
              sha256 = "01020dx89m07qmjs58vs2kidhkzq3106md08w6c65bzxvlf6kcwk";

     

       266904
       267564
        
              configureFlags = [

     

       266905
       267565
        
                "-fdisable-git-info" "-fhide-dependency-versions"

     

       266906
       267566
        
                "-fsupported-build"

     
···

       266919
       267579
        
                mtl mustache neat-interpolation network-uri open-browser

     

       266920
       267580
        
                optparse-applicative pantry path path-io persistent

     

       266921
       267581
        
                persistent-sqlite persistent-template pretty primitive process

     

       266922
       266922
       -
                project-template retry rio rio-prettyprint semigroups split stm

     

       266923
       266923
       -
                streaming-commons tar template-haskell temporary text text-metrics

     

       266924
       266924
       -
                th-reify-many time tls transformers typed-process

     

       267582
       267582
       +
                project-template random retry rio rio-prettyprint semigroups split

     

       267583
       267583
       +
                stm streaming-commons tar template-haskell temporary text

     

       267584
       267584
       +
                text-metrics th-reify-many time tls transformers typed-process

     

       266925
       267585
        
                unicode-transforms unix unix-compat unliftio unordered-containers

     

       266926
       267586
        
                vector yaml zip-archive zlib

     

       266927
       267587
        
              ];

     
···

       266936
       267596
        
                mtl mustache neat-interpolation network-uri open-browser

     

       266937
       267597
        
                optparse-applicative pantry path path-io persistent

     

       266938
       267598
        
                persistent-sqlite persistent-template pretty primitive process

     

       266939
       266939
       -
                project-template retry rio rio-prettyprint semigroups split stm

     

       266940
       266940
       -
                streaming-commons tar template-haskell temporary text text-metrics

     

       266941
       266941
       -
                th-reify-many time tls transformers typed-process

     

       267599
       267599
       +
                project-template random retry rio rio-prettyprint semigroups split

     

       267600
       267600
       +
                stm streaming-commons tar template-haskell temporary text

     

       267601
       267601
       +
                text-metrics th-reify-many time tls transformers typed-process

     

       266942
       267602
        
                unicode-transforms unix unix-compat unliftio unordered-containers

     

       266943
       267603
        
                vector yaml zip-archive zlib

     

       266944
       267604
        
              ];

     
···

       266953
       267613
        
                mono-traversable mtl mustache neat-interpolation network-uri

     

       266954
       267614
        
                open-browser optparse-applicative pantry path path-io persistent

     

       266955
       267615
        
                persistent-sqlite persistent-template pretty primitive process

     

       266956
       266956
       -
                project-template QuickCheck raw-strings-qq retry rio

     

       267616
       267616
       +
                project-template QuickCheck random raw-strings-qq retry rio

     

       266957
       267617
        
                rio-prettyprint semigroups smallcheck split stm streaming-commons

     

       266958
       267618
        
                tar template-haskell temporary text text-metrics th-reify-many time

     

       266959
       267619
        
                tls transformers typed-process unicode-transforms unix unix-compat

     
···

       267304
       267964
        
            }:

     

       267305
       267965
        
            mkDerivation {

     

       267306
       267966
        
              pname = "stack2cabal";

     

       267307
       267307
       -
              version = "1.0.13";

     

       267308
       267308
       -
              sha256 = "00jibr5mvvaj9ggzvp3f0qcrwz51bg3a2m1447c45cwhailzaqkk";

     

       267967
       267967
       +
              version = "1.0.14";

     

       267968
       267968
       +
              sha256 = "11ja6k9k4gj9cfa7s6jv43wkm5f189a51rr21v4891226rf79agy";

     

       267309
       267969
        
              isLibrary = true;

     

       267310
       267970
        
              isExecutable = true;

     

       267311
       267971
        
              libraryHaskellDepends = [

     
···

       270451
       271111
        
              maintainers = [ lib.maintainers.maralorn ];

     

       270452
       271112
        
            }) {};

     

       270453
       271113
        
       

     

       270454
       270454
       -
         "streamly_0_8_2" = callPackage

     

       271114
       271114
       +
         "streamly_0_8_3" = callPackage

     

       270455
       271115
        
           ({ mkDerivation, atomic-primops, base, containers, deepseq

     

       270456
       271116
        
            , directory, exceptions, filepath, fusion-plugin-types, ghc-prim

     

       270457
       271117
        
            , heaps, lockfree-queue, monad-control, mtl, network, primitive

     
···

       270459
       271119
        
            }:

     

       270460
       271120
        
            mkDerivation {

     

       270461
       271121
        
              pname = "streamly";

     

       270462
       270462
       -
              version = "0.8.2";

     

       270463
       270463
       -
              sha256 = "0mqixkxvwcvb0fcgsrd1xvi9hag5dwj1cwg4brsmzj138fkjrn47";

     

       271122
       271122
       +
              version = "0.8.3";

     

       271123
       271123
       +
              sha256 = "0xjvrkyh8i6hkfr3vsi3n56z85qd56nyjiwi1abzhhdshvxw92xg";

     

       270464
       271124
        
              libraryHaskellDepends = [

     

       270465
       271125
        
                atomic-primops base containers deepseq directory exceptions

     

       270466
       271126
        
                filepath fusion-plugin-types ghc-prim heaps lockfree-queue

     
···

       271245
       271905
        
            }) {};

     

       271246
       271906
        
       

     

       271247
       271907
        
         "string-interpreter" = callPackage

     

       271248
       271248
       -
           ({ mkDerivation, base }:

     

       271908
       271908
       +
           ({ mkDerivation, base, cli-arguments, phonetic-languages-basis

     

       271909
       271909
       +
            , phonetic-languages-permutations-array

     

       271910
       271910
       +
            }:

     

       271249
       271911
        
            mkDerivation {

     

       271250
       271912
        
              pname = "string-interpreter";

     

       271251
       271251
       -
              version = "0.6.0.0";

     

       271252
       271252
       -
              sha256 = "0a0i95j8y49wijh2c0bpy5fwz72w0p6nh19df56g2yy7xik5h6xq";

     

       271253
       271253
       -
              libraryHaskellDepends = [ base ];

     

       271913
       271913
       +
              version = "0.7.0.0";

     

       271914
       271914
       +
              sha256 = "0j8q9vps7r3vd71j4slz540y8a3bbh1c2hdn5d9g2892984chjb2";

     

       271915
       271915
       +
              libraryHaskellDepends = [

     

       271916
       271916
       +
                base cli-arguments phonetic-languages-basis

     

       271917
       271917
       +
                phonetic-languages-permutations-array

     

       271918
       271918
       +
              ];

     

       271254
       271919
        
              description = "Is used in the phonetic languages approach (e. g. in the recursive mode).";

     

       271255
       271920
        
              license = lib.licenses.mit;

     

       271256
       271921
        
            }) {};

     
···

       272169
       272834
        
              hydraPlatforms = lib.platforms.none;

     

       272170
       272835
        
              mainProgram = "stylish-cabal";

     

       272171
       272836
        
              broken = true;

     

       272837
       272837
       +
            }) {};

     

       272838
       272838
       +
       

     

       272839
       272839
       +
         "stylish-haskell_0_13_0_0" = callPackage

     

       272840
       272840
       +
           ({ mkDerivation, aeson, base, bytestring, Cabal, containers

     

       272841
       272841
       +
            , directory, file-embed, filepath, ghc-lib-parser, HsYAML

     

       272842
       272842
       +
            , HsYAML-aeson, HUnit, mtl, optparse-applicative, random, strict

     

       272843
       272843
       +
            , syb, test-framework, test-framework-hunit, text

     

       272844
       272844
       +
            }:

     

       272845
       272845
       +
            mkDerivation {

     

       272846
       272846
       +
              pname = "stylish-haskell";

     

       272847
       272847
       +
              version = "0.13.0.0";

     

       272848
       272848
       +
              sha256 = "0x9w3zh1lzp6l5xj3mynnlr0fzb5mbv0wwpfxp8fr6bk0jcrzjwf";

     

       272849
       272849
       +
              isLibrary = true;

     

       272850
       272850
       +
              isExecutable = true;

     

       272851
       272851
       +
              libraryHaskellDepends = [

     

       272852
       272852
       +
                aeson base bytestring Cabal containers directory file-embed

     

       272853
       272853
       +
                filepath ghc-lib-parser HsYAML HsYAML-aeson mtl syb text

     

       272854
       272854
       +
              ];

     

       272855
       272855
       +
              executableHaskellDepends = [

     

       272856
       272856
       +
                aeson base bytestring Cabal containers directory file-embed

     

       272857
       272857
       +
                filepath ghc-lib-parser HsYAML HsYAML-aeson mtl

     

       272858
       272858
       +
                optparse-applicative strict syb

     

       272859
       272859
       +
              ];

     

       272860
       272860
       +
              testHaskellDepends = [

     

       272861
       272861
       +
                aeson base bytestring Cabal containers directory file-embed

     

       272862
       272862
       +
                filepath ghc-lib-parser HsYAML HsYAML-aeson HUnit mtl random syb

     

       272863
       272863
       +
                test-framework test-framework-hunit text

     

       272864
       272864
       +
              ];

     

       272865
       272865
       +
              description = "Haskell code prettifier";

     

       272866
       272866
       +
              license = lib.licenses.bsd3;

     

       272867
       272867
       +
              hydraPlatforms = lib.platforms.none;

     

       272868
       272868
       +
              mainProgram = "stylish-haskell";

     

       272172
       272869
        
            }) {};

     

       272173
       272870
        
       

     

       272174
       272871
        
         "stylish-haskell" = callPackage

     
···

       273421
       274118
        
              broken = true;

     

       273422
       274119
        
            }) {};

     

       273423
       274120
        
       

     

       274121
       274121
       +
         "svg-icons" = callPackage

     

       274122
       274122
       +
           ({ mkDerivation, base, blaze-markup, blaze-svg, directory, text }:

     

       274123
       274123
       +
            mkDerivation {

     

       274124
       274124
       +
              pname = "svg-icons";

     

       274125
       274125
       +
              version = "0.4.0.2";

     

       274126
       274126
       +
              sha256 = "1z31ynhchk27hzfayrbnh9xzdq5ibz57ls2jk7j5jck9xmxl7zac";

     

       274127
       274127
       +
              isLibrary = true;

     

       274128
       274128
       +
              isExecutable = true;

     

       274129
       274129
       +
              libraryHaskellDepends = [

     

       274130
       274130
       +
                base blaze-markup blaze-svg directory text

     

       274131
       274131
       +
              ];

     

       274132
       274132
       +
              executableHaskellDepends = [

     

       274133
       274133
       +
                base blaze-markup blaze-svg directory text

     

       274134
       274134
       +
              ];

     

       274135
       274135
       +
              description = "Svg Icons and more";

     

       274136
       274136
       +
              license = lib.licenses.bsd3;

     

       274137
       274137
       +
              hydraPlatforms = lib.platforms.none;

     

       274138
       274138
       +
              mainProgram = "svg-icons-exe";

     

       274139
       274139
       +
              broken = true;

     

       274140
       274140
       +
            }) {};

     

       274141
       274141
       +
       

     

       273424
       274142
        
         "svg-tree" = callPackage

     

       273425
       274143
        
           ({ mkDerivation, attoparsec, base, bytestring, containers

     

       273426
       274144
        
            , JuicyPixels, lens, linear, mtl, scientific, text, transformers

     
···

       273955
       274673
        
              license = lib.licenses.bsd3;

     

       273956
       274674
        
            }) {};

     

       273957
       274675
        
       

     

       274676
       274676
       +
         "syb_0_7_2_2" = callPackage

     

       274677
       274677
       +
           ({ mkDerivation, base, containers, mtl, tasty, tasty-hunit }:

     

       274678
       274678
       +
            mkDerivation {

     

       274679
       274679
       +
              pname = "syb";

     

       274680
       274680
       +
              version = "0.7.2.2";

     

       274681
       274681
       +
              sha256 = "1qxjjndfwz2vvpz9707banmcn6jl2v6w6zp401zxaj327fccchw1";

     

       274682
       274682
       +
              libraryHaskellDepends = [ base ];

     

       274683
       274683
       +
              testHaskellDepends = [ base containers mtl tasty tasty-hunit ];

     

       274684
       274684
       +
              description = "Scrap Your Boilerplate";

     

       274685
       274685
       +
              license = lib.licenses.bsd3;

     

       274686
       274686
       +
              hydraPlatforms = lib.platforms.none;

     

       274687
       274687
       +
            }) {};

     

       274688
       274688
       +
       

     

       273958
       274689
        
         "syb-extras" = callPackage

     

       273959
       274690
        
           ({ mkDerivation, base, eq, prelude-extras }:

     

       273960
       274691
        
            mkDerivation {

     
···

       274092
       274823
        
            }:

     

       274093
       274824
        
            mkDerivation {

     

       274094
       274825
        
              pname = "sydtest-discover";

     

       274095
       274095
       -
              version = "0.0.0.1";

     

       274096
       274096
       -
              sha256 = "1f0a169cl8lv6zz9hs351f6aqha9iyl1n2fwfzskccvx1m4dk8z6";

     

       274097
       274097
       -
              isLibrary = true;

     

       274098
       274098
       -
              isExecutable = true;

     

       274099
       274099
       -
              libraryHaskellDepends = [

     

       274100
       274100
       -
                base filepath optparse-applicative path path-io

     

       274101
       274101
       -
              ];

     

       274102
       274102
       -
              executableHaskellDepends = [ base ];

     

       274103
       274103
       -
              description = "Automatic test suite discovery for sydtest";

     

       274104
       274104
       -
              license = "unknown";

     

       274105
       274105
       -
              mainProgram = "sydtest-discover";

     

       274106
       274106
       -
            }) {};

     

       274107
       274107
       -
       

     

       274108
       274108
       -
         "sydtest-discover_0_0_0_2" = callPackage

     

       274109
       274109
       -
           ({ mkDerivation, base, filepath, optparse-applicative, path

     

       274110
       274110
       -
            , path-io

     

       274111
       274111
       -
            }:

     

       274112
       274112
       -
            mkDerivation {

     

       274113
       274113
       -
              pname = "sydtest-discover";

     

       274114
       274826
        
              version = "0.0.0.2";

     

       274115
       274827
        
              sha256 = "1naraj9cp0036ppd42l4zjz6rfzn25n71nkvxjd0x979pakv3h7v";

     

       274116
       274828
        
              isLibrary = true;

     
···

       274121
       274833
        
              executableHaskellDepends = [ base ];

     

       274122
       274834
        
              description = "Automatic test suite discovery for sydtest";

     

       274123
       274835
        
              license = "unknown";

     

       274124
       274124
       -
              hydraPlatforms = lib.platforms.none;

     

       274125
       274836
        
              mainProgram = "sydtest-discover";

     

       274126
       274837
        
            }) {};

     

       274127
       274838
        
       

     
···

       279262
       279973
        
              license = lib.licenses.mit;

     

       279263
       279974
        
            }) {};

     

       279264
       279975
        
       

     

       279976
       279976
       +
         "template-haskell-compat-v0208_0_1_9_1" = callPackage

     

       279977
       279977
       +
           ({ mkDerivation, base, template-haskell }:

     

       279978
       279978
       +
            mkDerivation {

     

       279979
       279979
       +
              pname = "template-haskell-compat-v0208";

     

       279980
       279980
       +
              version = "0.1.9.1";

     

       279981
       279981
       +
              sha256 = "1z87rla4vcbghdrvjkay59b686f0by02102vwrcayn4vbwzn4am1";

     

       279982
       279982
       +
              libraryHaskellDepends = [ base template-haskell ];

     

       279983
       279983
       +
              description = "A backwards compatibility layer for Template Haskell newer than 2.8";

     

       279984
       279984
       +
              license = lib.licenses.mit;

     

       279985
       279985
       +
              hydraPlatforms = lib.platforms.none;

     

       279986
       279986
       +
            }) {};

     

       279987
       279987
       +
       

     

       279265
       279988
        
         "template-haskell-optics" = callPackage

     

       279266
       279989
        
           ({ mkDerivation, base, containers, optics-core, template-haskell

     

       279267
       279990
        
            , th-abstraction

     
···

       281643
       282366
        
            }:

     

       281644
       282367
        
            mkDerivation {

     

       281645
       282368
        
              pname = "text-lips";

     

       281646
       281646
       -
              version = "0.1.0.1";

     

       281647
       281647
       -
              sha256 = "1sm7sy11yc2rfjrpq5in7fqv3gh7zcfli8vw4b2mdlh6nxrh7k89";

     

       282369
       282369
       +
              version = "0.1.0.2";

     

       282370
       282370
       +
              sha256 = "0bjcapvcfpljjcf5z41xm5zqrjfyma8cs7cwzag3bl0zlppnq17h";

     

       281648
       282371
        
              libraryHaskellDepends = [

     

       281649
       282372
        
                base containers parsers text text-loc transformers

     

       281650
       282373
        
              ];

     
···

       281658
       282381
        
           ({ mkDerivation, base, hashable }:

     

       281659
       282382
        
            mkDerivation {

     

       281660
       282383
        
              pname = "text-loc";

     

       281661
       281661
       -
              version = "0.1";

     

       281662
       281662
       -
              sha256 = "069v99jnlayl2srl09355i56wpry0f6mq4bfp8lj0sxcsm1bzpgw";

     

       282384
       282384
       +
              version = "0.1.1";

     

       282385
       282385
       +
              sha256 = "00zd2bd8c9lrl34pwbnv0278jxipdycjjipxrfrfkn2iiawy65f9";

     

       281663
       282386
        
              libraryHaskellDepends = [ base hashable ];

     

       281664
       282387
        
              description = "Line-column locations within a text";

     

       281665
       282388
        
              license = lib.licenses.bsd3;

     
···

       282445
       283168
        
              license = lib.licenses.isc;

     

       282446
       283169
        
            }) {};

     

       282447
       283170
        
       

     

       283171
       283171
       +
         "th-abstraction_0_4_5_0" = callPackage

     

       283172
       283172
       +
           ({ mkDerivation, base, containers, ghc-prim, template-haskell }:

     

       283173
       283173
       +
            mkDerivation {

     

       283174
       283174
       +
              pname = "th-abstraction";

     

       283175
       283175
       +
              version = "0.4.5.0";

     

       283176
       283176
       +
              sha256 = "09hm0famyqsq09lal2ylnhsb31hybj8zanldi7cqncky4i7y5m80";

     

       283177
       283177
       +
              libraryHaskellDepends = [

     

       283178
       283178
       +
                base containers ghc-prim template-haskell

     

       283179
       283179
       +
              ];

     

       283180
       283180
       +
              testHaskellDepends = [ base containers template-haskell ];

     

       283181
       283181
       +
              description = "Nicer interface for reified information about data types";

     

       283182
       283182
       +
              license = lib.licenses.isc;

     

       283183
       283183
       +
              hydraPlatforms = lib.platforms.none;

     

       283184
       283184
       +
            }) {};

     

       283185
       283185
       +
       

     

       282448
       283186
        
         "th-alpha" = callPackage

     

       282449
       283187
        
           ({ mkDerivation, base, containers, derive, mmorph, mtl, tasty

     

       282450
       283188
        
            , tasty-hunit, tasty-quickcheck, template-haskell, th-desugar

     
···

       284073
       284811
        
              mainProgram = "tidal";

     

       284074
       284812
        
            }) {};

     

       284075
       284813
        
       

     

       284076
       284076
       -
         "tidal_1_8_1" = callPackage

     

       284077
       284077
       -
           ({ mkDerivation, base, bifunctors, bytestring, clock, colour

     

       284078
       284078
       -
            , containers, criterion, deepseq, exceptions, hosc, microspec, mtl

     

       284079
       284079
       -
            , network, parsec, primitive, random, text, transformers, weigh

     

       284814
       284814
       +
         "tidal_1_9_2" = callPackage

     

       284815
       284815
       +
           ({ mkDerivation, base, bytestring, clock, colour, containers

     

       284816
       284816
       +
            , criterion, deepseq, exceptions, hosc, microspec, mtl, network

     

       284817
       284817
       +
            , parsec, primitive, random, text, tidal-link, transformers, weigh

     

       284080
       284818
        
            }:

     

       284081
       284819
        
            mkDerivation {

     

       284082
       284820
        
              pname = "tidal";

     

       284083
       284083
       -
              version = "1.8.1";

     

       284084
       284084
       -
              sha256 = "00000haj9y3ss95dhphq2pq0xs2qagg76ra4lir5kg3pv71i2dh9";

     

       284821
       284821
       +
              version = "1.9.2";

     

       284822
       284822
       +
              sha256 = "0ncc5rc2g0brmgd28cbigp1rhvch9az30vg987q8fn7xfzbxw92h";

     

       284085
       284823
        
              enableSeparateDataOutput = true;

     

       284086
       284824
        
              libraryHaskellDepends = [

     

       284087
       284087
       -
                base bifunctors bytestring clock colour containers deepseq

     

       284088
       284088
       -
                exceptions hosc mtl network parsec primitive random text

     

       284089
       284089
       -
                transformers

     

       284825
       284825
       +
                base bytestring clock colour containers deepseq exceptions hosc mtl

     

       284826
       284826
       +
                network parsec primitive random text tidal-link transformers

     

       284090
       284827
        
              ];

     

       284091
       284828
        
              testHaskellDepends = [

     

       284092
       284829
        
                base containers deepseq hosc microspec parsec

     
···

       284101
       284838
        
           ({ mkDerivation, base }:

     

       284102
       284839
        
            mkDerivation {

     

       284103
       284840
        
              pname = "tidal-link";

     

       284104
       284104
       -
              version = "1.0";

     

       284105
       284105
       -
              sha256 = "0rc6gj6vfvhp9583farykw4i434krazak0gmm2h8nvfg8cw7liia";

     

       284841
       284841
       +
              version = "1.0.1";

     

       284842
       284842
       +
              sha256 = "0s3x73zx4rxjawcf2744z9dr05j4pabbxddrz9814h1d61q2cbb1";

     

       284106
       284843
        
              isLibrary = true;

     

       284107
       284844
        
              isExecutable = true;

     

       284108
       284845
        
              libraryHaskellDepends = [ base ];

     
···

       284120
       284857
        
              pname = "tidal-midi";

     

       284121
       284858
        
              version = "0.9.10";

     

       284122
       284859
        
              sha256 = "0d59s9vq2jmlb8b1bbay6n5911fjm9j04c9545p4i5visniv61b4";

     

       284123
       284123
       -
              revision = "2";

     

       284124
       284124
       -
              editedCabalFile = "1vc5ck25wdqz8ywk2zmn2nmg1mihwkihwp2wirxmmd0qxi1v2vpf";

     

       284860
       284860
       +
              revision = "3";

     

       284861
       284861
       +
              editedCabalFile = "0m6hn5nr0lj6h18388kf0dspiv798w6c2h73z6hrypn64dwmhvdg";

     

       284125
       284862
        
              libraryHaskellDepends = [

     

       284126
       284863
        
                base containers PortMidi tidal time transformers

     

       284127
       284864
        
              ];

     

       284128
       284128
       -
              description = "MIDI support for tidal";

     

       284865
       284865
       +
              description = "Please ignore this package";

     

       284129
       284866
        
              license = lib.licenses.gpl3Only;

     

       284130
       284867
        
              hydraPlatforms = lib.platforms.none;

     

       284131
       284868
        
              broken = true;

     
···

       286632
       287369
        
              pname = "toml-reader";

     

       286633
       287370
        
              version = "0.1.0.0";

     

       286634
       287371
        
              sha256 = "06gxp8pzh8cdrifg5n0mhlnrslrx7k235sz2ldpy60x7vz7qywv9";

     

       287372
       287372
       +
              revision = "1";

     

       287373
       287373
       +
              editedCabalFile = "16qfl1bz7c8a34xvs5fzs5r421309xpw9gfsiv2szivd5hcp9f9r";

     

       286635
       287374
        
              libraryHaskellDepends = [

     

       286636
       287375
        
                base containers deepseq megaparsec parser-combinators text time

     

       286637
       287376
        
              ];

     
···

       286643
       287382
        
              license = lib.licenses.bsd3;

     

       286644
       287383
        
            }) {};

     

       286645
       287384
        
       

     

       287385
       287385
       +
         "toml-reader-parse" = callPackage

     

       287386
       287386
       +
           ({ mkDerivation, base, comonad, containers, deepseq, dlist, mtl

     

       287387
       287387
       +
            , prettyprinter, prettyprinter-combinators, text, time, toml-reader

     

       287388
       287388
       +
            , vector

     

       287389
       287389
       +
            }:

     

       287390
       287390
       +
            mkDerivation {

     

       287391
       287391
       +
              pname = "toml-reader-parse";

     

       287392
       287392
       +
              version = "0.1.0.0";

     

       287393
       287393
       +
              sha256 = "1ddwk29isiq190fd025laq0g8js7ifcngph9acy8zlmppp3685w7";

     

       287394
       287394
       +
              libraryHaskellDepends = [

     

       287395
       287395
       +
                base comonad containers deepseq dlist mtl prettyprinter

     

       287396
       287396
       +
                prettyprinter-combinators text time toml-reader vector

     

       287397
       287397
       +
              ];

     

       287398
       287398
       +
              description = "Alternative parser for TOML values produced by the toml-reader package";

     

       287399
       287399
       +
              license = lib.licenses.asl20;

     

       287400
       287400
       +
            }) {};

     

       287401
       287401
       +
       

     

       286646
       287402
        
         "tomland" = callPackage

     

       286647
       287403
        
           ({ mkDerivation, base, bytestring, containers, deepseq, directory

     

       286648
       287404
        
            , hashable, hedgehog, hspec, hspec-hedgehog, hspec-megaparsec

     
···

       287257
       288013
        
            }:

     

       287258
       288014
        
            mkDerivation {

     

       287259
       288015
        
              pname = "toysolver";

     

       287260
       287260
       -
              version = "0.8.0";

     

       287261
       287261
       -
              sha256 = "1vlswvlnj8xsz2lqwl0z9mnmznqgjzi0595jlcr2lw4d4na1sxs7";

     

       288016
       288016
       +
              version = "0.8.1";

     

       288017
       288017
       +
              sha256 = "00f3x4rq8334g2923l338vzdz9jmf4amab16awr29bkj90h1ay5a";

     

       287262
       288018
        
              isLibrary = true;

     

       287263
       288019
        
              isExecutable = true;

     

       287264
       288020
        
              libraryHaskellDepends = [

     
···

       290264
       291020
        
            }:

     

       290265
       291021
        
            mkDerivation {

     

       290266
       291022
        
              pname = "twee";

     

       290267
       290267
       -
              version = "2.4.1";

     

       290268
       290268
       -
              sha256 = "0gh0cr3f19jsfq6025y1lq0mcg8cd920xd3x7jmd1cjlyjbkslsf";

     

       291023
       291023
       +
              version = "2.4.2";

     

       291024
       291024
       +
              sha256 = "1m6pfxna4nby2mxalx6wa4gnnszhxfj58pc1i1by53c5fixnl1n6";

     

       290269
       291025
        
              isLibrary = false;

     

       290270
       291026
        
              isExecutable = true;

     

       290271
       291027
        
              executableHaskellDepends = [

     
···

       290277
       291033
        
            }) {};

     

       290278
       291034
        
       

     

       290279
       291035
        
         "twee-lib" = callPackage

     

       290280
       290280
       -
           ({ mkDerivation, base, containers, dlist, ghc-prim, pretty

     

       290281
       290281
       -
            , primitive, random, transformers, uglymemo, vector

     

       291036
       291036
       +
           ({ mkDerivation, base, bytestring, cereal, containers, dlist

     

       291037
       291037
       +
            , ghc-prim, pretty, primitive, random, transformers, uglymemo

     

       290282
       291038
        
            }:

     

       290283
       291039
        
            mkDerivation {

     

       290284
       291040
        
              pname = "twee-lib";

     

       290285
       290285
       -
              version = "2.4.1";

     

       290286
       290286
       -
              sha256 = "14pvmxq0dp8lwbmkvch4c6v4rblc8a2ybkm7q3hhr1qaj2pyiv0b";

     

       290287
       290287
       -
              revision = "1";

     

       290288
       290288
       -
              editedCabalFile = "1d9z1ggiw23snn35nhbkj0rh2abha2ca1csr49x5a7lxc974mzc7";

     

       291041
       291041
       +
              version = "2.4.2";

     

       291042
       291042
       +
              sha256 = "1fncqc2abb9hhy5ncb7174gy7n7wp5c9ablq07pr7k61i8ngqwd9";

     

       290289
       291043
        
              libraryHaskellDepends = [

     

       290290
       290290
       -
                base containers dlist ghc-prim pretty primitive random transformers

     

       290291
       290291
       -
                uglymemo vector

     

       291044
       291044
       +
                base bytestring cereal containers dlist ghc-prim pretty primitive

     

       291045
       291045
       +
                random transformers uglymemo

     

       290292
       291046
        
              ];

     

       290293
       291047
        
              description = "An equational theorem prover";

     

       290294
       291048
        
              license = lib.licenses.bsd3;

     
···

       291536
       292290
        
              broken = true;

     

       291537
       292291
        
            }) {};

     

       291538
       292292
        
       

     

       292293
       292293
       +
         "type-rig" = callPackage

     

       292294
       292294
       +
           ({ mkDerivation, base, invariant }:

     

       292295
       292295
       +
            mkDerivation {

     

       292296
       292296
       +
              pname = "type-rig";

     

       292297
       292297
       +
              version = "0.1";

     

       292298
       292298
       +
              sha256 = "105p9mvcig9damgihywjjikxcgdqgzb08w721rc908kxnz6f5m38";

     

       292299
       292299
       +
              libraryHaskellDepends = [ base invariant ];

     

       292300
       292300
       +
              description = "Classes for the rig (sums and products) of types";

     

       292301
       292301
       +
              license = lib.licenses.bsd2;

     

       292302
       292302
       +
              hydraPlatforms = lib.platforms.none;

     

       292303
       292303
       +
              broken = true;

     

       292304
       292304
       +
            }) {};

     

       292305
       292305
       +
       

     

       291539
       292306
        
         "type-safe-avl" = callPackage

     

       291540
       292307
        
           ({ mkDerivation, base }:

     

       291541
       292308
        
            mkDerivation {

     
···

       292475
       293242
        
              license = lib.licenses.asl20;

     

       292476
       293243
        
            }) {};

     

       292477
       293244
        
       

     

       293245
       293245
       +
         "tztime" = callPackage

     

       293246
       293246
       +
           ({ mkDerivation, base, deepseq, directory, doctest-parallel

     

       293247
       293247
       +
            , filepath, mtl, safe-exceptions, tasty, tasty-discover

     

       293248
       293248
       +
            , tasty-hunit-compat, template-haskell, text, th-test-utils, time

     

       293249
       293249
       +
            , time-compat, tz

     

       293250
       293250
       +
            }:

     

       293251
       293251
       +
            mkDerivation {

     

       293252
       293252
       +
              pname = "tztime";

     

       293253
       293253
       +
              version = "0.1.0.0";

     

       293254
       293254
       +
              sha256 = "0d605i6q281cmr3zxrhh51cahlgc4v0sdbzzrzyjwzdnf8rhj5nl";

     

       293255
       293255
       +
              libraryHaskellDepends = [

     

       293256
       293256
       +
                base deepseq directory filepath mtl safe-exceptions

     

       293257
       293257
       +
                template-haskell text time time-compat tz

     

       293258
       293258
       +
              ];

     

       293259
       293259
       +
              testHaskellDepends = [

     

       293260
       293260
       +
                base doctest-parallel tasty tasty-hunit-compat template-haskell

     

       293261
       293261
       +
                th-test-utils time time-compat

     

       293262
       293262
       +
              ];

     

       293263
       293263
       +
              testToolDepends = [ tasty-discover ];

     

       293264
       293264
       +
              description = "Safe timezone-aware handling of time";

     

       293265
       293265
       +
              license = lib.licenses.mpl20;

     

       293266
       293266
       +
              hydraPlatforms = lib.platforms.none;

     

       293267
       293267
       +
              broken = true;

     

       293268
       293268
       +
            }) {};

     

       293269
       293269
       +
       

     

       292478
       293270
        
         "u2f" = callPackage

     

       292479
       293271
        
           ({ mkDerivation, aeson, asn1-encoding, asn1-types, base

     

       292480
       293272
        
            , base64-bytestring, binary, bytestring, cryptohash, cryptonite

     
···

       293628
       294420
        
              pname = "unicode-data";

     

       293629
       294421
        
              version = "0.3.0";

     

       293630
       294422
        
              sha256 = "0pwjjsk0gjkn73ghj10s603p84xr7h2kfg351c9grzngrcv9giq8";

     

       293631
       293631
       -
              revision = "1";

     

       293632
       293632
       -
              editedCabalFile = "1invxbc1f635rywnkcpap9s93z08mbdfi3rzi7882lssf1wy0i85";

     

       294423
       294423
       +
              revision = "2";

     

       294424
       294424
       +
              editedCabalFile = "1hvqizqk4v231iy9kj0g2yq3cxzd37bw2yrxr36201qsznc2kxxq";

     

       293633
       294425
        
              isLibrary = true;

     

       293634
       294426
        
              isExecutable = true;

     

       293635
       294427
        
              libraryHaskellDepends = [ base ];

     
···

       293760
       294552
        
              pname = "unicode-transforms";

     

       293761
       294553
        
              version = "0.4.0.1";

     

       293762
       294554
        
              sha256 = "1z29jvli2rqkynfxni1gibl81458j7h8lrb8fg6lpnj8svhy2y1j";

     

       294555
       294555
       +
              revision = "1";

     

       294556
       294556
       +
              editedCabalFile = "0ml5j3j3dan7fgbyd3vgmlrij7bgszgfh244b1sppciis1v4m94p";

     

       293763
       294557
        
              isLibrary = true;

     

       293764
       294558
        
              isExecutable = true;

     

       293765
       294559
        
              libraryHaskellDepends = [

     
···

       294964
       295758
        
            }:

     

       294965
       295759
        
            mkDerivation {

     

       294966
       295760
        
              pname = "unix-time";

     

       294967
       294967
       -
              version = "0.4.7";

     

       294968
       294968
       -
              sha256 = "02fyh298lm8jsg52i3z0ikazwz477ljqjmhnqr2d88grmn5ky8qr";

     

       294969
       294969
       -
              libraryHaskellDepends = [ base binary bytestring old-time ];

     

       294970
       294970
       -
              testHaskellDepends = [

     

       294971
       294971
       -
                base bytestring hspec old-locale old-time QuickCheck time

     

       294972
       294972
       -
              ];

     

       294973
       294973
       -
              testToolDepends = [ hspec-discover ];

     

       294974
       294974
       -
              description = "Unix time parser/formatter and utilities";

     

       294975
       294975
       -
              license = lib.licenses.bsd3;

     

       294976
       294976
       -
            }) {};

     

       294977
       294977
       -
       

     

       294978
       294978
       -
         "unix-time_0_4_8" = callPackage

     

       294979
       294979
       -
           ({ mkDerivation, base, binary, bytestring, hspec, hspec-discover

     

       294980
       294980
       -
            , old-locale, old-time, QuickCheck, time

     

       294981
       294981
       -
            }:

     

       294982
       294982
       -
            mkDerivation {

     

       294983
       294983
       -
              pname = "unix-time";

     

       294984
       295761
        
              version = "0.4.8";

     

       294985
       295762
        
              sha256 = "0hz8mi08kg84hiqnch5ycscgqmjyn1mnl5ih1bsrclyb3fhvdppy";

     

       294986
       295763
        
              libraryHaskellDepends = [ base binary bytestring old-time ];

     
···

       294990
       295767
        
              testToolDepends = [ hspec-discover ];

     

       294991
       295768
        
              description = "Unix time parser/formatter and utilities";

     

       294992
       295769
        
              license = lib.licenses.bsd3;

     

       294993
       294993
       -
              hydraPlatforms = lib.platforms.none;

     

       294994
       295770
        
            }) {};

     

       294995
       295771
        
       

     

       294996
       295772
        
         "unjson" = callPackage

     
···

       297029
       297805
        
              pname = "uuid";

     

       297030
       297806
        
              version = "1.3.15";

     

       297031
       297807
        
              sha256 = "0r05h16gd7fgfpq9iz43jcn9jzrgfa0gk4cv1xy0p4rli66rb1gq";

     

       297032
       297032
       -
              revision = "1";

     

       297033
       297033
       -
              editedCabalFile = "1wjcic98hvvz5xynlrk60dyfhw0nypv56sza24g2z3q62013rfrg";

     

       297808
       297808
       +
              revision = "2";

     

       297809
       297809
       +
              editedCabalFile = "06j1hk4alypnwd4v55w6lfm1jrsaqh85k350qmymw0sqbrd9rmx3";

     

       297034
       297810
        
              libraryHaskellDepends = [

     

       297035
       297811
        
                base binary bytestring cryptohash-md5 cryptohash-sha1 entropy

     

       297036
       297812
        
                network-info random text time uuid-types

     
···

       300532
       301308
        
              hydraPlatforms = lib.platforms.none;

     

       300533
       301309
        
            }) {};

     

       300534
       301310
        
       

     

       300535
       300535
       -
         "vty_5_36" = callPackage

     

       301311
       301311
       +
         "vty_5_37" = callPackage

     

       300536
       301312
        
           ({ mkDerivation, ansi-terminal, base, binary, blaze-builder

     

       300537
       301313
        
            , bytestring, Cabal, containers, deepseq, directory, filepath

     

       300538
       301314
        
            , hashable, HUnit, microlens, microlens-mtl, microlens-th, mtl

     
···

       300543
       301319
        
            }:

     

       300544
       301320
        
            mkDerivation {

     

       300545
       301321
        
              pname = "vty";

     

       300546
       300546
       -
              version = "5.36";

     

       300547
       300547
       -
              sha256 = "19841hwr0s1s05dlxw5386vnrxka9567bn309d002y263wb8vfzi";

     

       301322
       301322
       +
              version = "5.37";

     

       301323
       301323
       +
              sha256 = "1w6dc25npvlaflxcyzdssnymgi7x03zkwg7swyjw6cjjfdmkgqb7";

     

       300548
       301324
        
              isLibrary = true;

     

       300549
       301325
        
              isExecutable = true;

     

       300550
       301326
        
              libraryHaskellDepends = [

     
···

       300649
       301425
        
            }:

     

       300650
       301426
        
            mkDerivation {

     

       300651
       301427
        
              pname = "vulkan";

     

       300652
       300652
       -
              version = "3.21";

     

       300653
       300653
       -
              sha256 = "06j9di520ysv12xcd2yfdfscf1gfskfhn25ldwbp3vdx2hw9rjwp";

     

       301428
       301428
       +
              version = "3.21.1";

     

       301429
       301429
       +
              sha256 = "06yh0iw0yhs7kdgra3s39cl7fyvl2ys81ihw48k9jpravaal31xl";

     

       300654
       301430
        
              libraryHaskellDepends = [ base bytestring transformers vector ];

     

       300655
       301431
        
              libraryPkgconfigDepends = [ vulkan ];

     

       300656
       301432
        
              testHaskellDepends = [

     
···

       305086
       305862
        
              license = lib.licenses.bsd3;

     

       305087
       305863
        
            }) {};

     

       305088
       305864
        
       

     

       305865
       305865
       +
         "welford-online-mean-variance" = callPackage

     

       305866
       305866
       +
           ({ mkDerivation, base, cereal, deepseq, QuickCheck, tasty

     

       305867
       305867
       +
            , tasty-discover, tasty-quickcheck, vector

     

       305868
       305868
       +
            }:

     

       305869
       305869
       +
            mkDerivation {

     

       305870
       305870
       +
              pname = "welford-online-mean-variance";

     

       305871
       305871
       +
              version = "0.1.0.0";

     

       305872
       305872
       +
              sha256 = "0px7b1jbz5wn3zvmj0y4nrwy9m99615nw06hd3snaa60z4m88blm";

     

       305873
       305873
       +
              libraryHaskellDepends = [ base cereal deepseq vector ];

     

       305874
       305874
       +
              testHaskellDepends = [

     

       305875
       305875
       +
                base cereal deepseq QuickCheck tasty tasty-discover

     

       305876
       305876
       +
                tasty-quickcheck vector

     

       305877
       305877
       +
              ];

     

       305878
       305878
       +
              testToolDepends = [ tasty-discover ];

     

       305879
       305879
       +
              description = "Online computation of mean and variance using the Welford algorithm";

     

       305880
       305880
       +
              license = lib.licenses.bsd3;

     

       305881
       305881
       +
            }) {};

     

       305882
       305882
       +
       

     

       305089
       305883
        
         "welshy" = callPackage

     

       305090
       305884
        
           ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit

     

       305091
       305885
        
            , http-types, lifted-base, resourcet, text, transformers

     
···

       305846
       306640
        
       

     

       305847
       306641
        
         "witch" = callPackage

     

       305848
       306642
        
           ({ mkDerivation, base, bytestring, containers, HUnit

     

       305849
       305849
       -
            , template-haskell, text, time

     

       305850
       305850
       -
            }:

     

       305851
       305851
       -
            mkDerivation {

     

       305852
       305852
       -
              pname = "witch";

     

       305853
       305853
       -
              version = "1.0.0.3";

     

       305854
       305854
       -
              sha256 = "1d6wn4ykafq3hi439pf9ap55vjrcv668qq5wmxm5fiq6r78ndn0b";

     

       305855
       305855
       -
              libraryHaskellDepends = [

     

       305856
       305856
       -
                base bytestring containers template-haskell text time

     

       305857
       305857
       -
              ];

     

       305858
       305858
       -
              testHaskellDepends = [

     

       305859
       305859
       -
                base bytestring containers HUnit template-haskell text time

     

       305860
       305860
       -
              ];

     

       305861
       305861
       -
              description = "Convert values from one type into another";

     

       305862
       305862
       -
              license = lib.licenses.mit;

     

       305863
       305863
       -
              maintainers = [ lib.maintainers.maralorn ];

     

       305864
       305864
       -
            }) {};

     

       305865
       305865
       -
       

     

       305866
       305866
       -
         "witch_1_0_0_4" = callPackage

     

       305867
       305867
       -
           ({ mkDerivation, base, bytestring, containers, HUnit

     

       305868
       306643
        
            , template-haskell, text, time, transformers

     

       305869
       306644
        
            }:

     

       305870
       306645
        
            mkDerivation {

     
···

       305879
       306654
        
              ];

     

       305880
       306655
        
              description = "Convert values from one type into another";

     

       305881
       306656
        
              license = lib.licenses.mit;

     

       305882
       305882
       -
              hydraPlatforms = lib.platforms.none;

     

       305883
       306657
        
              maintainers = [ lib.maintainers.maralorn ];

     

       305884
       306658
        
            }) {};

     

       305885
       306659
        
       

     
···

       305999
       306773
        
            }) {};

     

       306000
       306774
        
       

     

       306001
       306775
        
         "witness" = callPackage

     

       306002
       306002
       -
           ({ mkDerivation, base, constraints, countable }:

     

       306776
       306776
       +
           ({ mkDerivation, base, constraints, containers, countable }:

     

       306003
       306777
        
            mkDerivation {

     

       306004
       306778
        
              pname = "witness";

     

       306005
       306005
       -
              version = "0.6";

     

       306006
       306006
       -
              sha256 = "1y8scf6a061s8gnx38sfwn88ramakjr0h54qwlwcjrjpf0y6024l";

     

       306007
       306007
       -
              libraryHaskellDepends = [ base constraints countable ];

     

       306779
       306779
       +
              version = "0.6.1";

     

       306780
       306780
       +
              sha256 = "02ky1qc4ar8iy3rzjp2j89mp3k7skz5jp65vn7lilmwrvm1b2vcx";

     

       306781
       306781
       +
              libraryHaskellDepends = [ base constraints containers countable ];

     

       306008
       306782
        
              description = "values that witness types";

     

       306009
       306783
        
              license = lib.licenses.bsd2;

     

       306010
       306784
        
              hydraPlatforms = lib.platforms.none;

     
···

       311392
       312166
        
            }:

     

       311393
       312167
        
            mkDerivation {

     

       311394
       312168
        
              pname = "yarl";

     

       311395
       311395
       -
              version = "0.1.0.1";

     

       311396
       311396
       -
              sha256 = "0qcfmvd3s18kz8g5sg7f4jaf2ai5dacszbk2nlnd1q3mafhz2cia";

     

       312169
       312169
       +
              version = "0.1.1.0";

     

       312170
       312170
       +
              sha256 = "188dxv2pncq6x54n679ia86pl3ym8h6zgczs6zzcrd3w78ph0vmh";

     

       311397
       312171
        
              libraryHaskellDepends = [ base ];

     

       311398
       312172
        
              testHaskellDepends = [ base hspec hspec-core hspec-discover ];

     

       311399
       312173
        
              testToolDepends = [ hspec-discover ];

     
···

       312482
       313256
        
              pname = "yesod-bin";

     

       312483
       313257
        
              version = "1.6.2.2";

     

       312484
       313258
        
              sha256 = "18bnr7wjcb5w8v62gfkrx7ky35agbkwl8f8vn2cdbjksa6wsllvr";

     

       313259
       313259
       +
              revision = "1";

     

       313260
       313260
       +
              editedCabalFile = "07zc0jf8gpv1zhyglgq2xj89jl6rc22mjv2v2k8lywlm8i5vjvdm";

     

       312485
       313261
        
              isLibrary = false;

     

       312486
       313262
        
              isExecutable = true;

     

       312487
       313263
        
              executableHaskellDepends = [

     
···

       312910
       313686
        
            }:

     

       312911
       313687
        
            mkDerivation {

     

       312912
       313688
        
              pname = "yesod-form";

     

       312913
       312913
       -
              version = "1.7.0";

     

       312914
       312914
       -
              sha256 = "170gby381h5pg9njn908cyx2931yiv79x3rc5npg2rd74kif06vi";

     

       313689
       313689
       +
              version = "1.7.2";

     

       313690
       313690
       +
              sha256 = "1f50vhp1ggmh7ja1rw71d10cwzyqxzhkgjwwy2vwp9r4x6fkb836";

     

       312915
       313691
        
              libraryHaskellDepends = [

     

       312916
       313692
        
                aeson attoparsec base blaze-builder blaze-html blaze-markup

     

       312917
       313693
        
                byteable bytestring containers data-default email-validate

+3 -2

pkgs/development/libraries/openssl/default.nix

···

       67
       67
        
             !(stdenv.hostPlatform.useLLVM or false) &&

     

       68
       68
        
             stdenv.cc.isGNU;

     

       69
       69
        
       

     

       70
       70
       -
           nativeBuildInputs = [ perl ];

     

       70
       70
       +
           nativeBuildInputs = [ perl ]

     

       71
       71
       +
             ++ lib.optionals static [ removeReferencesTo ];

     

       71
       72
        
           buildInputs = lib.optional withCryptodev cryptodev

     

       72
       73
        
             # perl is included to allow the interpreter path fixup hook to set the

     

       73
       74
        
             # correct interpreter in c_rehash.

     
···

       155
       156
        
           postInstall =

     

       156
       157
        
           (if static then ''

     

       157
       158
        
             # OPENSSLDIR has a reference to self

     

       158
       158
       -
             ${removeReferencesTo}/bin/remove-references-to -t $out $out/lib/*.a

     

       159
       159
       +
             remove-references-to -t $out $out/lib/*.a

     

       159
       160
        
           '' else ''

     

       160
       161
        
             # If we're building dynamic libraries, then don't install static

     

       161
       162
        
             # libraries.

pkgs/development/libraries/qt-6/default.nix

···

       49
       49
        
               withGtk3 = true;

     

       50
       50
        
               inherit (srcs.qtbase) src version;

     

       51
       51
        
               inherit bison cups harfbuzz libGL dconf gtk3 developerBuild cmake;

     

       52
       52
       +
               patches = [ ./patches/0007-qtbase-xcursor.patch ];

     

       52
       53
        
             };

     

       53
       54
        
       

     

       54
       55
        
             qt3d = callPackage ./modules/qt3d.nix { };

pkgs/development/libraries/qt-6/modules/qtbase.nix

···

       201
       201
        
           "-DQT_FEATURE_openssl_linked=ON"

     

       202
       202
        
         ];

     

       203
       203
        
       

     

       204
       204
       +
         NIX_CFLAGS_COMPILE = [

     

       205
       205
       +
           ''-DNIXPKGS_LIBXCURSOR="${libXcursor.out}/lib/libXcursor"''

     

       206
       206
       +
         ];

     

       207
       207
       +
       

     

       204
       208
        
         outputs = [ "out" "dev" ];

     

       205
       209
        
       

     

       206
       210
        
         postInstall = ''

+29

pkgs/development/libraries/qt-6/patches/0007-qtbase-xcursor.patch

···

       1
       1
       +
       From cc953cc3f736fabef1f5c211964f30be719fb35e Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: Thomas Tuegel <ttuegel@mailbox.org>

     

       3
       3
       +
       Date: Tue, 17 Sep 2019 05:35:58 -0500

     

       4
       4
       +
       Subject: [PATCH 07/10] qtbase-xcursor

     

       5
       5
       +
       

     

       6
       6
       +
       ---

     

       7
       7
       +
        src/plugins/platforms/xcb/qxcbcursor.cpp | 4 ++--

     

       8
       8
       +
        1 file changed, 2 insertions(+), 2 deletions(-)

     

       9
       9
       +
       

     

       10
       10
       +
       diff --git a/src/plugins/platforms/xcb/qxcbcursor.cpp b/src/plugins/platforms/xcb/qxcbcursor.cpp

     

       11
       11
       +
       index fbadab4d50..c83ce0af5b 100644

     

       12
       12
       +
       --- a/src/plugins/platforms/xcb/qxcbcursor.cpp

     

       13
       13
       +
       +++ b/src/plugins/platforms/xcb/qxcbcursor.cpp

     

       14
       14
       +
       @@ -317,10 +317,10 @@ QXcbCursor::QXcbCursor(QXcbConnection *conn, QXcbScreen *screen)

     

       15
       15
       +
        #if QT_CONFIG(xcb_xlib) && QT_CONFIG(library)

     

       16
       16
       +
            static bool function_ptrs_not_initialized = true;

     

       17
       17
       +
            if (function_ptrs_not_initialized) {

     

       18
       18
       +
       -        QLibrary xcursorLib(QLatin1String("Xcursor"), 1);

     

       19
       19
       +
       +        QLibrary xcursorLib(QLatin1String(NIXPKGS_LIBXCURSOR), 1);

     

       20
       20
       +
                bool xcursorFound = xcursorLib.load();

     

       21
       21
       +
                if (!xcursorFound) { // try without the version number

     

       22
       22
       +
       -            xcursorLib.setFileName(QLatin1String("Xcursor"));

     

       23
       23
       +
       +            xcursorLib.setFileName(QLatin1String(NIXPKGS_LIBXCURSOR));

     

       24
       24
       +
                    xcursorFound = xcursorLib.load();

     

       25
       25
       +
                }

     

       26
       26
       +
                if (xcursorFound) {

     

       27
       27
       +
       -- 

     

       28
       28
       +
       2.25.1

     

       29
       29
       +

+2 -1

pkgs/development/ocaml-modules/dns/cli.nix

···

       1
       1
       -
       { buildDunePackage, dns, dns-tsig, dns-client, dns-server, dns-certify

     

       1
       1
       +
       { buildDunePackage, dns, dns-tsig, dns-client, dns-server, dns-certify, dnssec

     

       2
       2
        
       , bos, cmdliner, fpath, x509, mirage-crypto, mirage-crypto-pk

     

       3
       3
        
       , mirage-crypto-rng, hex, ptime, mtime, logs, fmt, ipaddr, lwt

     

       4
       4
        
       , randomconv, alcotest

     
···

       19
       19
        
           dns-client

     

       20
       20
        
           dns-server

     

       21
       21
        
           dns-certify

     

       22
       22
       +
           dnssec

     

       22
       23
        
           bos

     

       23
       24
        
           cmdliner

     

       24
       25
        
           fpath

+4 -3

pkgs/development/ocaml-modules/dns/default.nix

···

       1
       1
        
       { lib, buildDunePackage, fetchurl, alcotest

     

       2
       2
        
       , cstruct, domain-name, duration, gmap, ipaddr, logs, lru, metrics, ptime, fmt

     

       3
       3
       +
       , base64

     

       3
       4
        
       }:

     

       4
       5
        
       

     

       5
       6
        
       buildDunePackage rec {

     

       6
       7
        
         pname = "dns";

     

       7
       7
       -
         version = "6.1.4";

     

       8
       8
       +
         version = "6.3.0";

     

       8
       9
        
       

     

       9
       10
        
         minimalOCamlVersion = "4.08";

     

       10
       11
        
       

     

       11
       12
        
         src = fetchurl {

     

       12
       13
        
           url = "https://github.com/mirage/ocaml-dns/releases/download/v${version}/dns-${version}.tbz";

     

       13
       13
       -
           sha256 = "sha256-nO9hRFOQzm3j57S1xTUC/j8ejSB+aDcsw/pOi893kHY=";

     

       14
       14
       +
           sha256 = "sha256-3EAjenN9EIi4PsXCZDevmEPDaS4xbESbcbB7pFgwc1E=";

     

       14
       15
        
         };

     

       15
       16
        
       

     

       16
       16
       -
         propagatedBuildInputs = [ fmt logs ptime domain-name gmap cstruct ipaddr lru duration metrics ];

     

       17
       17
       +
         propagatedBuildInputs = [ fmt logs ptime domain-name gmap cstruct ipaddr lru duration metrics base64 ];

     

       17
       18
        
       

     

       18
       19
        
         doCheck = true;

     

       19
       20
        
         checkInputs = [ alcotest ];

+30

pkgs/development/ocaml-modules/dns/dnssec.nix

···

       1
       1
       +
       { buildDunePackage, cstruct, dns, mirage-crypto, mirage-crypto-pk, mirage-crypto-ec

     

       2
       2
       +
       , domain-name, logs

     

       3
       3
       +
       , alcotest, base64

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildDunePackage {

     

       7
       7
       +
         pname = "dnssec";

     

       8
       8
       +
       

     

       9
       9
       +
         inherit (dns) version src;

     

       10
       10
       +
       

     

       11
       11
       +
         propagatedBuildInputs = [

     

       12
       12
       +
           cstruct

     

       13
       13
       +
           dns

     

       14
       14
       +
           mirage-crypto

     

       15
       15
       +
           mirage-crypto-pk

     

       16
       16
       +
           mirage-crypto-ec

     

       17
       17
       +
           domain-name

     

       18
       18
       +
           logs

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         doCheck = true;

     

       22
       22
       +
         checkInputs = [

     

       23
       23
       +
           alcotest

     

       24
       24
       +
           base64

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         meta = dns.meta // {

     

       28
       28
       +
           description = "DNSSec support for OCaml-DNS";

     

       29
       29
       +
         };

     

       30
       30
       +
       }

+2 -1

pkgs/development/ocaml-modules/dns/resolver.nix

···

       1
       1
        
       { buildDunePackage, dns, dns-server, dns-mirage, lru, duration

     

       2
       2
        
       , randomconv, lwt, mirage-time, mirage-clock, mirage-random

     

       3
       3
       -
       , tcpip, tls, tls-mirage

     

       3
       3
       +
       , tcpip, tls, tls-mirage, dnssec

     

       4
       4
        
       , alcotest

     

       5
       5
        
       }:

     

       6
       6
        
       

     
···

       13
       13
        
           dns

     

       14
       14
        
           dns-server

     

       15
       15
        
           dns-mirage

     

       16
       16
       +
           dnssec

     

       16
       17
        
           lru

     

       17
       18
        
           duration

     

       18
       19
        
           randomconv

-5

pkgs/development/python-modules/elasticsearch/default.nix

···

       7
       7
        
       

     

       8
       8
        
       buildPythonPackage (rec {

     

       9
       9
        
         pname = "elasticsearch";

     

       10
       10
       -
         # In 7.14.0, the package was intentionally made incompatible with

     

       11
       11
       -
         # the OSS version of elasticsearch - don't update past 7.13.x until

     

       12
       12
       -
         # there's a clear path forward. See

     

       13
       13
       -
         # https://github.com/elastic/elasticsearch-py/issues/1639 for more

     

       14
       14
       -
         # info.

     

       15
       10
        
         version = "7.16.3";

     

       16
       11
        
       

     

       17
       12
        
         src = fetchPypi {

pkgs/development/python-modules/watchdog/default.nix

···

       41
       41
        
           substituteInPlace setup.cfg \

     

       42
       42
        
             --replace "--cov=watchdog" "" \

     

       43
       43
        
             --replace "--cov-report=term-missing" ""

     

       44
       44
       +
         '' + lib.optionalString stdenv.hostPlatform.isMusl

     

       45
       45
       +
         # https://github.com/gorakhargosh/watchdog/issues/920

     

       46
       46
       +
         ''

     

       47
       47
       +
           substituteInPlace tests/test_inotify_c.py \

     

       48
       48
       +
             --replace "Unknown error -1" "No error information"

     

       44
       49
        
         '';

     

       45
       50
        
       

     

       46
       51
        
         disabledTests = [

+3 -3

pkgs/development/tools/changie/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "changie";

     

       5
       5
       -
         version = "1.9.0";

     

       5
       5
       +
         version = "1.9.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           rev = "v${version}";

     

       9
       9
        
           owner = "miniscruff";

     

       10
       10
        
           repo = pname;

     

       11
       11
       -
           sha256 = "sha256-3i+GInsxGeHXdFYfI664sOshHFsEIVXgXolzPhc9eoM=";

     

       11
       11
       +
           sha256 = "sha256-3AGz84z0YmDiLxlbDO0f9ny75hyLB4fnYQSICElJVK4=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-/tYhoHk4+gbdfeBNqcBSM0y4V3tVH67Xta3+e+Sctsg=";

     

       14
       14
       +
         vendorSha256 = "sha256-9Cpyemq/f62rVMvGwOtgDGd9XllvICXL2dqNwUoFQmg=";

     

       15
       15
        
       

     

       16
       16
        
         meta = with lib; {

     

       17
       17
        
           homepage = "https://changie.dev";

+2 -2

pkgs/development/tools/doctl/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "doctl";

     

       5
       5
       -
         version = "1.79.0";

     

       5
       5
       +
         version = "1.81.0";

     

       6
       6
        
       

     

       7
       7
        
         vendorSha256 = null;

     

       8
       8
        
       

     
···

       31
       31
        
           owner = "digitalocean";

     

       32
       32
        
           repo = "doctl";

     

       33
       33
        
           rev = "v${version}";

     

       34
       34
       -
           sha256 = "sha256-0tl79nVvnY2KECrfgEXQ8tOHnwEX+34uiJ/jshK5oFA=";

     

       34
       34
       +
           sha256 = "sha256-9sBuuRDbd44XH/DJVQrwiw+MhhQ8pl8uKcnsAa8nXGM=";

     

       35
       35
        
         };

     

       36
       36
        
       

     

       37
       37
        
         meta = with lib; {

+4 -5

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , stdenv

     

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

     

       4
       4
       -
       , dynamic ? false

     

       3
       3
       +
       , supportedGhcVersions ? [ "90" ]

     

       4
       4
       +
       , dynamic ? true

     

       5
       5
        
       , haskellPackages

     

       6
       6
        
       , haskell

     

       7
       7
        
       }:

     

       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" "92"]; }

     

       12
       12
        
       #

     

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

     

       14
       14
        
       #

     
···

       57
       57
        
               concatMapStringsSep ", " (x: concatStringsSep ", " (targets x))

     

       58
       58
        
               supportedGhcVersions

     

       59
       59
        
             }.

     

       60
       60
       -
       

     

       61
       61
       -
             You can override the list supportedGhcVersions.

     

       60
       60
       +
             You can choose for which ghc versions to install hls with pkgs.haskell-language-server.override { supportedGhcVersions = [ "90" "92" ]; }.

     

       62
       61
        
           '';

     

       63
       62
        
         };

     

       64
       63
        
       }

+2 -1

pkgs/games/hedgewars/default.nix

···

       82
       82
        
              hedgehog or hedgehogs after a player's or CPU turn is shown only when

     

       83
       83
        
              all movement on the battlefield has ceased).'';

     

       84
       84
        
           maintainers = with maintainers; [ kragniz fpletz ];

     

       85
       85
       -
           inherit (fpc.meta) platforms;

     

       85
       85
       +
           broken = stdenv.isDarwin;

     

       86
       86
       +
           platforms = platforms.linux;

     

       86
       87
        
         };

     

       87
       88
        
       }

+5 -5

pkgs/os-specific/linux/nvidia-x11/default.nix

···

       27
       27
        
         stable = if stdenv.hostPlatform.system == "i686-linux" then legacy_390 else latest;

     

       28
       28
        
       

     

       29
       29
        
         production = generic {

     

       30
       30
       -
           version = "515.65.01";

     

       31
       31
       -
           sha256_64bit = "sha256-BJLdxbXmWqAMvHYujWaAIFyNCOEDtxMQh6FRJq7klek=";

     

       32
       32
       -
           openSha256 = "sha256-GCCDnaDsbXTmbCYZBCM3fpHmOSWti/DkBJwYrRGAMPI=";

     

       33
       33
       -
           settingsSha256 = "sha256-kBELMJCIWD9peZba14wfCoxsi3UXO3ehFYcVh4nvzVg=";

     

       34
       34
       -
           persistencedSha256 = "sha256-P8oT7g944HvNk2Ot/0T0sJM7dZs+e0d+KwbwRrmsuDY=";

     

       30
       30
       +
           version = "515.76";

     

       31
       31
       +
           sha256_64bit = "sha256-xqKhjOuWX0mAvOTlzqNv1iLNwaXzGg6xu9NZqen2v0Q=";

     

       32
       32
       +
           openSha256 = "sha256-843l42atzaTm4pX5UC/JZjXAvhwmBpE8k3SQFEFdcdY=";

     

       33
       33
       +
           settingsSha256 = "sha256-2GdqmuvROLa8xFfyFY/F4YzEBq+SlVIYM4CVEARh9MI=";

     

       34
       34
       +
           persistencedSha256 = "sha256-nIfP7xBIVy+BUa9VBCNQ9v5RT4l4S9X0GHLpNiN/WRg=";

     

       35
       35
        
       

     

       36
       36
        
           brokenOpen = kernelModVersion == "5.4" && kernel.isHardened;

     

       37
       37
        
         };

+2 -2

pkgs/servers/dns/pdns-recursor/default.nix

···

       5
       5
        
       

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
        
         pname = "pdns-recursor";

     

       8
       8
       -
         version = "4.7.2";

     

       8
       8
       +
         version = "4.7.3";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchurl {

     

       11
       11
        
           url = "https://downloads.powerdns.com/releases/pdns-recursor-${version}.tar.bz2";

     

       12
       12
       -
           sha256 = "sha256-vbQZB5D+dZd41vBRWvu8wKKLPn4bg8Vwyq84QZ1Xgg0=";

     

       12
       12
       +
           sha256 = "sha256-IG12bMjwGJ951pr2TY2TfsxhpNE+jqZZTXj+MOYUBfI=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         nativeBuildInputs = [ pkg-config ];

+2 -2

pkgs/servers/geospatial/mapserver/default.nix

···

       6
       6
        
       

     

       7
       7
        
       stdenv.mkDerivation rec {

     

       8
       8
        
         pname = "mapserver";

     

       9
       9
       -
         version = "7.6.4";

     

       9
       9
       +
         version = "8.0.0";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "MapServer";

     

       13
       13
        
           repo = "MapServer";

     

       14
       14
        
           rev = "rel-${lib.replaceStrings [ "." ] [ "-" ] version}";

     

       15
       15
       -
           sha256 = "sha256-NMo/7CtWYIP1oPKki09oDWLCbj2vPk3xCU4rkHq8YKY=";

     

       15
       15
       +
           sha256 = "sha256-t9tthHszqtbFEh50IhQMtBb9rD9tU3QbDlUsVRVkQ6U=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         nativeBuildInputs = [

+2 -2

pkgs/servers/http/lighttpd/default.nix

···

       15
       15
        
       

     

       16
       16
        
       stdenv.mkDerivation rec {

     

       17
       17
        
         pname = "lighttpd";

     

       18
       18
       -
         version = "1.4.66";

     

       18
       18
       +
         version = "1.4.67";

     

       19
       19
        
       

     

       20
       20
        
         src = fetchurl {

     

       21
       21
        
           url = "https://download.lighttpd.net/lighttpd/releases-${lib.versions.majorMinor version}.x/${pname}-${version}.tar.xz";

     

       22
       22
       -
           sha256 = "sha256-R6xuYCcaoBluZUctAtAZVW3HxtCd87Zd8sGraGY0jjs=";

     

       22
       22
       +
           sha256 = "sha256-fgTXZ/UajYJLMuJIPvKVCYKSDUJ9EnLvRmf0nW+J81g=";

     

       23
       23
        
         };

     

       24
       24
        
       

     

       25
       25
        
         postPatch = ''

+2 -2

pkgs/servers/monitoring/nagios/plugins/check_ssl_cert.nix

···

       10
       10
        
       

     

       11
       11
        
       stdenv.mkDerivation rec {

     

       12
       12
        
         pname = "check_ssl_cert";

     

       13
       13
       -
         version = "2.45.0";

     

       13
       13
       +
         version = "2.46.0";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchFromGitHub {

     

       16
       16
        
           owner = "matteocorti";

     

       17
       17
        
           repo = "check_ssl_cert";

     

       18
       18
        
           rev = "v${version}";

     

       19
       19
       -
           hash = "sha256-JmSSGt6rm4eSOVIT9eDN8FmQogG8kevHE2jgZfCzmgU=";

     

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

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         nativeBuildInputs = [

+6 -4

pkgs/servers/nosql/eventstore/default.nix

···

       11
       11
        
       

     

       12
       12
        
       buildDotnetModule rec {

     

       13
       13
        
         pname = "EventStore";

     

       14
       14
       -
         version = "21.10.5";

     

       14
       14
       +
         version = "22.6.0";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "EventStore";

     

       18
       18
        
           repo = "EventStore";

     

       19
       19
        
           rev = "oss-v${version}";

     

       20
       20
       -
           sha256 = "sha256-uUDjTGCiQgXmvOUsujIA0JkGQGuw9U4zLKDP1WIFq1o=";

     

       20
       20
       +
           sha256 = "sha256-+s/FjHKBpcpxFecuPrc26fA6WW20Uurxx1RunRY3JWI=";

     

       21
       21
        
           leaveDotGit = true;

     

       22
       22
        
         };

     

       23
       23
        
       

     
···

       32
       32
        
         runtimeDeps = [ mono ];

     

       33
       33
        
       

     

       34
       34
        
         nugetBinariesToPatch = lib.optionals stdenv.isLinux [

     

       35
       35
       -
           "grpc.tools/2.39.1/tools/linux_x64/protoc"

     

       36
       36
       -
           "grpc.tools/2.39.1/tools/linux_x64/grpc_csharp_plugin"

     

       35
       35
       +
           "grpc.tools/2.41.0/tools/linux_x64/protoc"

     

       36
       36
       +
           "grpc.tools/2.41.0/tools/linux_x64/grpc_csharp_plugin"

     

       37
       37
        
         ];

     

       38
       38
        
       

     

       39
       39
        
         postConfigure = ''

     
···

       70
       70
        
           sleep 30s;

     

       71
       71
        
           kill "$PID";

     

       72
       72
        
         '';

     

       73
       73
       +
       

     

       74
       74
       +
         passthru.updateScript = ./updater.sh;

     

       73
       75
        
       

     

       74
       76
        
         meta = with lib; {

     

       75
       77
        
           homepage = "https://geteventstore.com/";

+18 -11

pkgs/servers/nosql/eventstore/deps.nix

···

       1
       1
       +
       # This file was automatically generated by passthru.fetch-deps.

     

       2
       2
       +
       # Please dont edit it manually, your changes might get overwritten!

     

       3
       3
       +
       

     

       1
       4
        
       { fetchNuGet }: [

     

       2
       5
        
         (fetchNuGet { pname = "CompareNETObjects"; version = "4.65.0"; sha256 = "09p4xs6f7y8dykxx369ycp7z0jl7ai9bx23nazn8yxs5s38d9x2g"; })

     

       3
       6
        
         (fetchNuGet { pname = "ConfigureAwaitChecker.Analyzer"; version = "4.0.0"; sha256 = "013pzi7f4hf68wjswg0pzamjjsj63rl6jr1ivpd15v86y7vs6r9g"; })

     
···

       5
       8
        
         (fetchNuGet { pname = "EventStore.Client"; version = "21.2.0"; sha256 = "1crnk0nbwcz4l2dv3ia96skmfn274nbyh5j1p0g9rjbzyy7kzf5j"; })

     

       6
       9
        
         (fetchNuGet { pname = "EventStore.Plugins"; version = "21.2.0"; sha256 = "0fn2c2xi6yrwznnff3xpkhv5z5rnpka6wsaq1hb1jpxlxfscp670"; })

     

       7
       10
        
         (fetchNuGet { pname = "GitHubActionsTestLogger"; version = "1.2.0"; sha256 = "0kndl162zas1ic185v10bm23hmrai54ng7wqlk3sp39gmdqhmyf5"; })

     

       11
       11
       +
         (fetchNuGet { pname = "GitHubActionsTestLogger"; version = "2.0.0"; sha256 = "0579akfqnb6r3jrr5x6fi5c2pm58m00pjl0g74mxf0xp10sslg5b"; })

     

       8
       12
        
         (fetchNuGet { pname = "GitInfo"; version = "2.0.26"; sha256 = "050l74vkamvbsp8f02b8aknizcknk4fr26dvwvw86mm8iw1dlvrv"; })

     

       9
       9
       -
         (fetchNuGet { pname = "Google.Protobuf"; version = "3.15.8"; sha256 = "0k7hiijdrjw2y37yadd0jxx6hm4cd969v8svvddhksh6yqwnzh08"; })

     

       10
       10
       -
         (fetchNuGet { pname = "Grpc.AspNetCore"; version = "2.39.0"; sha256 = "05im3lh8ar47m2zciwykjn6yqh2m4791pfzqr26408027wjm9vya"; })

     

       11
       11
       -
         (fetchNuGet { pname = "Grpc.AspNetCore.Server"; version = "2.39.0"; sha256 = "17dhi75q2q0ra5n8qp0dlpgq1vqh186hgs3pqda60ya6hyc1fa45"; })

     

       12
       12
       -
         (fetchNuGet { pname = "Grpc.AspNetCore.Server.ClientFactory"; version = "2.39.0"; sha256 = "0n21bfk1gabqpy9wpyzrzmilz4p8r1b4h0nq9waiqphkbv8g6frh"; })

     

       13
       13
       -
         (fetchNuGet { pname = "Grpc.Core"; version = "2.39.1"; sha256 = "1c302krbhy063lpd52mgg9xx9ripp17314mfhym78r1q3nwrp15l"; })

     

       14
       14
       -
         (fetchNuGet { pname = "Grpc.Core.Api"; version = "2.39.1"; sha256 = "014b57zhflycsvdc2gmyv2a1vji7qzj1c7l4d1vgksb3ndwaxzrx"; })

     

       15
       15
       -
         (fetchNuGet { pname = "Grpc.Net.Client"; version = "2.39.0"; sha256 = "0km3zlkm3yq14yzcyq9g62i7a9qfihg1mczhbm6g8v5xkwbf667l"; })

     

       16
       16
       -
         (fetchNuGet { pname = "Grpc.Net.ClientFactory"; version = "2.39.0"; sha256 = "115iky8qcazzl993mdf34v6hxzvhk9mpnk7kgxlw4cc1cf0iv16q"; })

     

       17
       17
       -
         (fetchNuGet { pname = "Grpc.Net.Common"; version = "2.39.0"; sha256 = "19mghqpgvr5slnlmjvv8hxhq3v9wq7bzab3bcg2b7623z0yxylr4"; })

     

       18
       18
       -
         (fetchNuGet { pname = "Grpc.Tools"; version = "2.39.1"; sha256 = "1i5x4sm4rqfs8hc3vgwj05nlhqf0zx9vp72na65z2xyfabc0ybgc"; })

     

       13
       13
       +
         (fetchNuGet { pname = "Google.Protobuf"; version = "3.18.0"; sha256 = "0ldfgw6zjjwdw66y3mbq4db54bsbqkklqanm78c8gij3pbvd223z"; })

     

       14
       14
       +
         (fetchNuGet { pname = "Grpc.AspNetCore"; version = "2.41.0"; sha256 = "0sh9406vs7qfq852b24qxy4ivgxww0paf8rxsn7gs943si6dvj0n"; })

     

       15
       15
       +
         (fetchNuGet { pname = "Grpc.AspNetCore.Server"; version = "2.41.0"; sha256 = "1ij5wvk3147jdmlybal59xbmlyr50xmzrxsnn77rj2l8g54ajyk2"; })

     

       16
       16
       +
         (fetchNuGet { pname = "Grpc.AspNetCore.Server.ClientFactory"; version = "2.41.0"; sha256 = "0pb4vnc6dfwhrmgraicvqjf3gfz6d9g0qdhicahzsm1ngcj36klc"; })

     

       17
       17
       +
         (fetchNuGet { pname = "Grpc.Core"; version = "2.41.0"; sha256 = "1caavhi66r9a0nwyk4vm8mhaayg899d6l0p71cv9n5qgc5xhkwqs"; })

     

       18
       18
       +
         (fetchNuGet { pname = "Grpc.Core.Api"; version = "2.41.0"; sha256 = "0524fv8mkdszhblfp1v2d5azdb1vg1rpy30yqpsfn00m7qr3smbv"; })

     

       19
       19
       +
         (fetchNuGet { pname = "Grpc.Net.Client"; version = "2.41.0"; sha256 = "0skn1sinkfk8fjpjd2qwr13x62pvk50n8nyy0nwb75n1bp9n8rwc"; })

     

       20
       20
       +
         (fetchNuGet { pname = "Grpc.Net.ClientFactory"; version = "2.41.0"; sha256 = "08rin624q0w1vk59naxhnn20236yix7g7xb7jfciyv851b4ib1b4"; })

     

       21
       21
       +
         (fetchNuGet { pname = "Grpc.Net.Common"; version = "2.41.0"; sha256 = "0cp9xav7bzzy31s1xx221kzslrahnqmcj967lwrk6h949b2g552v"; })

     

       22
       22
       +
         (fetchNuGet { pname = "Grpc.Tools"; version = "2.41.0"; sha256 = "153c994q14pyj6dyw8k3ckjkawn8m2ja34fv0w9wnxv4g2b6i4qd"; })

     

       19
       23
        
         (fetchNuGet { pname = "HdrHistogram"; version = "2.5.0"; sha256 = "1s2np7m3pp17rgambax9a3x5pd2grx74cr325q3xapjz2gd58sj1"; })

     

       20
       24
        
         (fetchNuGet { pname = "HostStat.NET"; version = "1.0.2"; sha256 = "1khxpp1fy36njjcmikr0xnxk7zv9d3rcnm6f7x2s94agins23hg7"; })

     

       21
       25
        
         (fetchNuGet { pname = "Jint"; version = "3.0.0-beta-2038"; sha256 = "0gnp5pqsxd9lr7b4i73mpq5lyq16vzn0pr8rcyvnjjf3fanls8kc"; })

     
···

       77
       81
        
         (fetchNuGet { pname = "Microsoft.NETFramework.ReferenceAssemblies"; version = "1.0.0"; sha256 = "0na724xhvqm63vq9y18fl9jw9q2v99bdwr353378s5fsi11qzxp9"; })

     

       78
       82
        
         (fetchNuGet { pname = "Microsoft.TestPlatform.ObjectModel"; version = "16.8.3"; sha256 = "0szyg2p18w9lhlp52iylrr97w3kdalab089imhc53x1850avddsg"; })

     

       79
       83
        
         (fetchNuGet { pname = "Microsoft.TestPlatform.ObjectModel"; version = "16.9.1"; sha256 = "1igpx7ldxqx9fkrbhakd2bybc0dgpvj86zr30vpfj31ncm6lp4id"; })

     

       84
       84
       +
         (fetchNuGet { pname = "Microsoft.TestPlatform.ObjectModel"; version = "17.2.0"; sha256 = "0l05smcgjzdfa5f60f9q5lylap3i21aswxbava92s19bgv46w2rv"; })

     

       80
       85
        
         (fetchNuGet { pname = "Microsoft.TestPlatform.TestHost"; version = "16.9.1"; sha256 = "1frx5r7l0jd3j6my4s2qas13fkljgfn87a84xk8l7sisafpfsvzp"; })

     

       81
       86
        
         (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.0.1"; sha256 = "1n8ap0cmljbqskxpf8fjzn7kh1vvlndsa75k01qig26mbw97k2q7"; })

     

       82
       87
        
         (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.3.0"; sha256 = "0j0c1wj4ndj21zsgivsc24whiya605603kxrbiw6wkfdync464wq"; })

     
···

       84
       89
        
         (fetchNuGet { pname = "Microsoft.Win32.Registry"; version = "4.3.0"; sha256 = "1gxyzxam8163vk1kb6xzxjj4iwspjsz9zhgn1w9rjzciphaz0ig7"; })

     

       85
       90
        
         (fetchNuGet { pname = "Microsoft.Win32.Registry"; version = "4.7.0"; sha256 = "0bx21jjbs7l5ydyw4p6cn07chryxpmchq2nl5pirzz4l3b0q4dgs"; })

     

       86
       91
        
         (fetchNuGet { pname = "Microsoft.Win32.SystemEvents"; version = "4.7.0"; sha256 = "0pjll2a62hc576hd4wgyasva0lp733yllmk54n37svz5ac7nfz0q"; })

     

       87
       87
       -
         (fetchNuGet { pname = "MinVer"; version = "2.3.0"; sha256 = "0h6mhh76jhmf60kyjrw8daxpsvprml814v7a8dc3vf5s1lvn2x4j"; })

     

       92
       92
       +
         (fetchNuGet { pname = "MinVer"; version = "2.5.0"; sha256 = "0p6b80f1xv7k53lpanhh2spcz3l1krvr1j7xaij2kcrp275zsjyk"; })

     

       88
       93
        
         (fetchNuGet { pname = "Mono.Posix.NETStandard"; version = "1.0.0"; sha256 = "0xlja36hwpjm837haq15mjh2prcf68lyrmn72nvgpz8qnf9vappw"; })

     

       89
       94
        
         (fetchNuGet { pname = "NETStandard.Library"; version = "2.0.0"; sha256 = "1bc4ba8ahgk15m8k4nd7x406nhi0kwqzbgjk2dmw52ss553xz7iy"; })

     

       90
       95
        
         (fetchNuGet { pname = "NETStandard.Library"; version = "2.0.3"; sha256 = "1fn9fxppfcg4jgypp2pmrpr6awl3qz1xmnri0cygpkwvyx27df1y"; })

     

       91
       96
        
         (fetchNuGet { pname = "Newtonsoft.Json"; version = "11.0.2"; sha256 = "1784xi44f4k8v1fr696hsccmwpy94bz7kixxqlri98zhcxn406b2"; })

     

       97
       97
       +
         (fetchNuGet { pname = "Newtonsoft.Json"; version = "13.0.1"; sha256 = "0fijg0w6iwap8gvzyjnndds0q4b8anwxxvik7y8vgq97dram4srb"; })

     

       92
       98
        
         (fetchNuGet { pname = "Newtonsoft.Json"; version = "9.0.1"; sha256 = "0mcy0i7pnfpqm4pcaiyzzji4g0c8i3a5gjz28rrr28110np8304r"; })

     

       93
       99
        
         (fetchNuGet { pname = "NuGet.Frameworks"; version = "5.0.0"; sha256 = "18ijvmj13cwjdrrm52c8fpq021531zaz4mj4b4zapxaqzzxf2qjr"; })

     

       100
       100
       +
         (fetchNuGet { pname = "NuGet.Frameworks"; version = "5.11.0"; sha256 = "0wv26gq39hfqw9md32amr5771s73f5zn1z9vs4y77cgynxr73s4z"; })

     

       94
       101
        
         (fetchNuGet { pname = "NUnit"; version = "3.13.2"; sha256 = "00bkjgarkwbj497da9d7lajala1ns67h1kx53w4bapwkf32jlcvn"; })

     

       95
       102
        
         (fetchNuGet { pname = "NUnit3TestAdapter"; version = "3.17.0"; sha256 = "0kxc6z3b8ccdrcyqz88jm5yh5ch9nbg303v67q8sp5hhs8rl8nk6"; })

     

       96
       103
        
         (fetchNuGet { pname = "protobuf-net"; version = "2.4.0"; sha256 = "106lxm9afga7ihlknyy7mlfplyq40mrndksqrsn8ia2a47fbqqld"; })

+23

pkgs/servers/nosql/eventstore/updater.sh

···

       1
       1
       +
       #! /usr/bin/env nix-shell

     

       2
       2
       +
       #! nix-shell -I nixpkgs=./. -i bash -p curl jq common-updater-scripts

     

       3
       3
       +
       # shellcheck shell=bash

     

       4
       4
       +
       

     

       5
       5
       +
       set -euo pipefail

     

       6
       6
       +
       

     

       7
       7
       +
       cd "$(dirname "${BASH_SOURCE[0]}")"

     

       8
       8
       +
       

     

       9
       9
       +
       deps_file="$(realpath "./deps.nix")"

     

       10
       10
       +
       

     

       11
       11
       +
       new_version="$(curl -s "https://api.github.com/repos/EventStore/EventStore/releases/latest" | jq -r '.name')"

     

       12
       12
       +
       new_version="${new_version#oss-v}"

     

       13
       13
       +
       old_version="$(sed -nE 's/\s*version = "(.*)".*/\1/p' ./default.nix)"

     

       14
       14
       +
       

     

       15
       15
       +
       if [[ "$new_version" == "$old_version" ]]; then

     

       16
       16
       +
         echo "Already up to date!"

     

       17
       17
       +
         exit 0

     

       18
       18
       +
       fi

     

       19
       19
       +
       

     

       20
       20
       +
       cd ../../../..

     

       21
       21
       +
       update-source-version eventstore "${new_version//v}"

     

       22
       22
       +
       

     

       23
       23
       +
       $(nix-build -A eventstore.fetch-deps --no-out-link) "$deps_file"

+11 -61

pkgs/tools/games/minecraft/optifine/default.nix

···

       1
       1
        
       { recurseIntoAttrs

     

       2
       2
        
       , callPackage

     

       3
       3
       +
       , lib

     

       3
       4
        
       }:

     

       4
       5
        
       

     

       5
       5
       -
       recurseIntoAttrs rec {

     

       6
       6
       -
         optifine-latest = optifine_1_18_1;

     

       7
       7
       -
       

     

       8
       8
       -
         optifine_1_18_1 = callPackage ./generic.nix {

     

       9
       9
       -
           version = "1.18.1_HD_U_H4";

     

       10
       10
       -
           sha256 = "sha256-MlFoVpshotzegpmYdvaeydivdSAqcCFpHyq+3k2B3Ow=";

     

       11
       11
       -
         };

     

       12
       12
       -
       

     

       13
       13
       -
         optifine_1_17_1 = callPackage ./generic.nix {

     

       14
       14
       -
           version = "1.17.1_HD_U_H1";

     

       15
       15
       -
           sha256 = "sha256-HHt747bIHYY/WNAx19mNgvnLrLCqaKIqwXmmB7A895M=";

     

       16
       16
       -
         };

     

       17
       17
       -
       

     

       18
       18
       -
         optifine_1_16_5 = callPackage ./generic.nix {

     

       19
       19
       -
           version = "1.16.5_HD_U_G8";

     

       20
       20
       -
           sha256 = "sha256-PHa8kO1EvOVnzufCDrLENhkm8jqG5TZ9WW9uYk0LSU8=";

     

       21
       21
       -
         };

     

       22
       22
       -
       

     

       23
       23
       -
         optifine_1_15_2 = callPackage ./generic.nix {

     

       24
       24
       -
           version = "1.16.5_HD_U_G8";

     

       25
       25
       -
           sha256 = "sha256-PHa8kO1EvOVnzufCDrLENhkm8jqG5TZ9WW9uYk0LSU8=";

     

       26
       26
       -
         };

     

       27
       27
       -
       

     

       28
       28
       -
         optifine_1_14_4 = callPackage ./generic.nix {

     

       29
       29
       -
           version = "1.14.4_HD_U_G5";

     

       30
       30
       -
           sha256 = "sha256-I+65vQO6yG4AQ0ZLAfX73ImsFKAQkTyrIOnQHldTibs=";

     

       31
       31
       -
         };

     

       32
       32
       -
       

     

       33
       33
       -
         optifine_1_13_2 = callPackage ./generic.nix {

     

       34
       34
       -
           version = "1.13.2_HD_U_G5";

     

       35
       35
       -
           sha256 = "sha256-sjUQot8fPdbZTiLqt+exbF5T8kI5bLQevu7atW9Xu3E=";

     

       36
       36
       -
         };

     

       37
       37
       -
       

     

       38
       38
       -
         optifine_1_12_2 = callPackage ./generic.nix {

     

       39
       39
       -
           version = "1.12.2_HD_U_G5";

     

       40
       40
       -
           sha256 = "sha256-OwAGeXdx/rl/LQ0pCK58mnjO+y5zCvHC6F0IqDm6Jx4=";

     

       41
       41
       -
         };

     

       42
       42
       -
       

     

       43
       43
       -
         optifine_1_11_2 = callPackage ./generic.nix {

     

       44
       44
       -
           version = "1.11.2_HD_U_G5";

     

       45
       45
       -
           sha256 = "sha256-1sLUBtM5e5LDTUFCRZf9UeH6WOA8zY6TAmB9PCS5iv4=";

     

       46
       46
       -
         };

     

       47
       47
       -
       

     

       48
       48
       -
         optifine_1_10 = callPackage ./generic.nix {

     

       49
       49
       -
           version = "1.10_HD_U_I5";

     

       50
       50
       -
           sha256 = "sha256-oKOsaNFnOKfhWLDDYG/0Z4h/ZCDtyJWS9LXPaKAApc0=";

     

       51
       51
       -
         };

     

       52
       52
       -
       

     

       53
       53
       -
         optifine_1_9_4 = callPackage ./generic.nix {

     

       54
       54
       -
           version = "1.9.4_HD_U_I5";

     

       55
       55
       -
           sha256 = "sha256-t+OxIf0Tl/NZxUTl+LGnWRUhEwZ+vxiZfhclxEAf6yI=";

     

       56
       56
       -
         };

     

       6
       6
       +
       # All versions are taken from `version.json` created by `update.py`, and realised with `generic.nix`.

     

       7
       7
       +
       # The `update.py` is a web scraper script that writes the latest versions into `version.json`.

     

       57
       8
        
       

     

       58
       58
       -
         optifine_1_8_9 = callPackage ./generic.nix {

     

       59
       59
       -
           version = "1.8.9_HD_U_M5";

     

       60
       60
       -
           sha256 = "sha256-Jzl2CnD8pq5cfcgXvMYoPxj1Xjj6I3eNp/OHprckssQ=";

     

       61
       61
       -
         };

     

       9
       9
       +
       # The `versions.json` can be automatically updated and committed with a commit summary.

     

       10
       10
       +
       # To do so, change directory to nixpkgs root, and do:

     

       11
       11
       +
       # $ nix-shell ./maintainers/scripts/update.nix --argstr package optifinePackages.optifine-latest --argstr commit true

     

       62
       12
        
       

     

       63
       63
       -
         optifine_1_7_10 = callPackage ./generic.nix {

     

       64
       64
       -
           version = "1.7.10_HD_U_E7";

     

       65
       65
       -
           sha256 = "sha256-i82dg94AGgWR9JgQXzafBwxH0skZJ3TVpbafZG5E+rQ=";

     

       66
       66
       -
         };

     

       67
       67
       -
       }

     

       13
       13
       +
       recurseIntoAttrs (

     

       14
       14
       +
         lib.mapAttrs

     

       15
       15
       +
           (name: value: callPackage ./generic.nix value)

     

       16
       16
       +
           (lib.importJSON ./versions.json)

     

       17
       17
       +
       )

pkgs/tools/games/minecraft/optifine/generic.nix

···

       22
       22
        
       

     

       23
       23
        
         nativeBuildInputs = [ jre makeWrapper ];

     

       24
       24
        
       

     

       25
       25
       +
         passthru.updateScript = {

     

       26
       26
       +
           command = [ ./update.py ];

     

       27
       27
       +
           supportedFeatures = [ "commit" ];

     

       28
       28
       +
         };

     

       29
       29
       +
       

     

       25
       30
        
         meta = with lib; {

     

       26
       31
        
           homepage = "https://optifine.net/";

     

       27
       32
        
           description = "A Minecraft ${mcVersion} optimization mod";

+60

pkgs/tools/games/minecraft/optifine/update.py

···

       1
       1
       +
       #!/usr/bin/env nix-shell

     

       2
       2
       +
       #!nix-shell -I nixpkgs=./. -i python3 -p python3.pkgs.requests python3.pkgs.lxml nix

     

       3
       3
       +
       

     

       4
       4
       +
       from lxml import html

     

       5
       5
       +
       import json

     

       6
       6
       +
       import os.path

     

       7
       7
       +
       import re

     

       8
       8
       +
       import requests

     

       9
       9
       +
       import subprocess

     

       10
       10
       +
       

     

       11
       11
       +
       def nix_prefetch_sha256(name):

     

       12
       12
       +
           return subprocess.run(['nix-prefetch-url', '--type', 'sha256', 'https://optifine.net/download?f=' + name], capture_output=True, text=True).stdout.strip()

     

       13
       13
       +
       

     

       14
       14
       +
       # fetch download page

     

       15
       15
       +
       sess = requests.session()

     

       16
       16
       +
       page = sess.get('https://optifine.net/downloads')

     

       17
       17
       +
       tree = html.fromstring(page.content)

     

       18
       18
       +
       

     

       19
       19
       +
       # parse and extract main jar file names

     

       20
       20
       +
       href = tree.xpath('//tr[@class="downloadLine downloadLineMain"]/td[@class="colMirror"]/a/@href')

     

       21
       21
       +
       expr = re.compile('(OptiFine_)([0-9.]*)(.*)\.jar')

     

       22
       22
       +
       result = [ expr.search(x) for x in href ]

     

       23
       23
       +
       

     

       24
       24
       +
       # format name, version and hash for each file

     

       25
       25
       +
       catalogue = {}

     

       26
       26
       +
       for i, r in enumerate(result):

     

       27
       27
       +
           index = r.group(1).lower() + r.group(2).replace('.', '_')

     

       28
       28
       +
           version = r.group(2) + r.group(3)

     

       29
       29
       +
           catalogue[index] = {

     

       30
       30
       +
               "version": version,

     

       31
       31
       +
               "sha256": nix_prefetch_sha256(r.group(0))

     

       32
       32
       +
           }

     

       33
       33
       +
       

     

       34
       34
       +
       # latest version should be the first entry

     

       35
       35
       +
       if len(catalogue) > 0:

     

       36
       36
       +
           catalogue['optifine-latest'] = list(catalogue.values())[0]

     

       37
       37
       +
       

     

       38
       38
       +
       # read previous versions

     

       39
       39
       +
       d = os.path.dirname(os.path.abspath(__file__))

     

       40
       40
       +
       with open(os.path.join(d, 'versions.json'), 'r') as f:

     

       41
       41
       +
           prev = json.load(f)

     

       42
       42
       +
       

     

       43
       43
       +
       # `maintainers/scripts/update.py` will extract stdout to write commit message

     

       44
       44
       +
       # embed the commit message in json and print it

     

       45
       45
       +
       changes = [ { 'commitMessage': 'optifinePackages: update versions\n\n' } ]

     

       46
       46
       +
       

     

       47
       47
       +
       # build a longest common subsequence, natural sorted by keys

     

       48
       48
       +
       for key, value in sorted({**prev, **catalogue}.items(), key=lambda item: [int(s) if s.isdigit() else s for s in re.split(r'(\d+)', item[0])]):

     

       49
       49
       +
           if key not in prev:

     

       50
       50
       +
               changes[0]['commitMessage'] += 'optifinePackages.{}: init at {}\n'.format(key, value['version'])

     

       51
       51
       +
           elif value['version'] != prev[key]['version']:

     

       52
       52
       +
               changes[0]['commitMessage'] += 'optifinePackages.{}: {} -> {}\n'.format(key, prev[key]['version'], value['version'])

     

       53
       53
       +
       

     

       54
       54
       +
       # print the changes in stdout

     

       55
       55
       +
       print(json.dumps(changes))

     

       56
       56
       +
       

     

       57
       57
       +
       # write catalogue to file

     

       58
       58
       +
       with open(os.path.join(d, 'versions.json'), 'w') as f:

     

       59
       59
       +
           json.dump(catalogue, f, indent=4)

     

       60
       60
       +
           f.write('\n')

+142

pkgs/tools/games/minecraft/optifine/versions.json

···

       1
       1
       +
       {

     

       2
       2
       +
           "optifine_1_19_2": {

     

       3
       3
       +
               "version": "1.19.2_HD_U_H9",

     

       4
       4
       +
               "sha256": "1xyg98i7zar5x3xbgpn2nm48mc3r9q6yqisxnqk3g254ghjcy4xx"

     

       5
       5
       +
           },

     

       6
       6
       +
           "optifine_1_19_1": {

     

       7
       7
       +
               "version": "1.19.1_HD_U_H9",

     

       8
       8
       +
               "sha256": "1p5a3i383ca2l3snsm36dyngfz9a1f9xffaxk439149h0i2d0nlj"

     

       9
       9
       +
           },

     

       10
       10
       +
           "optifine_1_19": {

     

       11
       11
       +
               "version": "1.19_HD_U_H9",

     

       12
       12
       +
               "sha256": "19zjvwg0sr6279plj5qxj7hdlw9w8q3qd78dg6911m356z6g87ah"

     

       13
       13
       +
           },

     

       14
       14
       +
           "optifine_1_18_2": {

     

       15
       15
       +
               "version": "1.18.2_HD_U_H7",

     

       16
       16
       +
               "sha256": "169ajvw3zrb0xrz2h1z3x6vdr4122s8m3rxb461s8y2fk6i4y9kr"

     

       17
       17
       +
           },

     

       18
       18
       +
           "optifine_1_18_1": {

     

       19
       19
       +
               "version": "1.18.1_HD_U_H6",

     

       20
       20
       +
               "sha256": "0nh8ls306rs1qcbyibb6idapws4z5cyaqrgh9ipvm1vcwvxxj9ys"

     

       21
       21
       +
           },

     

       22
       22
       +
           "optifine_1_18": {

     

       23
       23
       +
               "version": "1.18_HD_U_H3",

     

       24
       24
       +
               "sha256": "11zqiwmqj4ja6l87acwzs7cnabsgn2x36510hap8gj139l3vbrvb"

     

       25
       25
       +
           },

     

       26
       26
       +
           "optifine_1_17_1": {

     

       27
       27
       +
               "version": "1.17.1_HD_U_H1",

     

       28
       28
       +
               "sha256": "14zp7jq0g9krq4ma4s5an2ncpyc2ipcxfcfhb0zqc7f8nvipnyqw"

     

       29
       29
       +
           },

     

       30
       30
       +
           "optifine_1_16_5": {

     

       31
       31
       +
               "version": "1.16.5_HD_U_G8",

     

       32
       32
       +
               "sha256": "0ks91d6n4vkgb5ykdrc67br2c69nqjr0xhp7rrkybg24xn8bqxiw"

     

       33
       33
       +
           },

     

       34
       34
       +
           "optifine_1_16_4": {

     

       35
       35
       +
               "version": "1.16.4_HD_U_G7",

     

       36
       36
       +
               "sha256": "063zdfmhzq5jgfdy27c8b0008sribl8rbvfxa7nkk86qwpvz6v8h"

     

       37
       37
       +
           },

     

       38
       38
       +
           "optifine_1_16_3": {

     

       39
       39
       +
               "version": "1.16.3_HD_U_G5",

     

       40
       40
       +
               "sha256": "0pipr77jrva5wrllil40myansyrxxvcckxlvf4k2vhqf2g1mfigl"

     

       41
       41
       +
           },

     

       42
       42
       +
           "optifine_1_16_2": {

     

       43
       43
       +
               "version": "1.16.2_HD_U_G5",

     

       44
       44
       +
               "sha256": "1iav08qqk7wb43ars9nilbgm4ybdi02pd0ahb0xy7clkxvlnjcx2"

     

       45
       45
       +
           },

     

       46
       46
       +
           "optifine_1_16_1": {

     

       47
       47
       +
               "version": "1.16.1_HD_U_G2",

     

       48
       48
       +
               "sha256": "1gwbxv3dx82lxkbp9gaf1nqczkcxdzlfsspxlrv6gcn7w8vvwf5v"

     

       49
       49
       +
           },

     

       50
       50
       +
           "optifine_1_15_2": {

     

       51
       51
       +
               "version": "1.15.2_HD_U_G6",

     

       52
       52
       +
               "sha256": "10qz6y3h80s56wsk3f5wwg52d0d7mkklhhhvgp6y84zlzq6xdbq4"

     

       53
       53
       +
           },

     

       54
       54
       +
           "optifine_1_14_4": {

     

       55
       55
       +
               "version": "1.14.4_HD_U_G5",

     

       56
       56
       +
               "sha256": "1fw9adbixl7942mkr48hl0aar2fwzgsh2js68c06xj5s0fyvkvi3"

     

       57
       57
       +
           },

     

       58
       58
       +
           "optifine_1_14_3": {

     

       59
       59
       +
               "version": "1.14.3_HD_U_F2",

     

       60
       60
       +
               "sha256": "00wys29pmgfsc4j2jy2mpfl493vy52jdxprxl92hcg2xz77ipqjh"

     

       61
       61
       +
           },

     

       62
       62
       +
           "optifine_1_14_2": {

     

       63
       63
       +
               "version": "1.14.2_HD_U_F1",

     

       64
       64
       +
               "sha256": "0645d38z8llnnv546zfkflqp441kxvf8vd0l3zjsls81w3bpc6n8"

     

       65
       65
       +
           },

     

       66
       66
       +
           "optifine_1_13_2": {

     

       67
       67
       +
               "version": "1.13.2_HD_U_G5",

     

       68
       68
       +
               "sha256": "0wdvaxpvbnpfpqgb8v1r8br56pkcn7kvgsi29vcxcg8zvyi10ddj"

     

       69
       69
       +
           },

     

       70
       70
       +
           "optifine_1_13_1": {

     

       71
       71
       +
               "version": "1.13.1_HD_U_E4",

     

       72
       72
       +
               "sha256": "0r5x703pgwi8vakii0nhlij7j24zkq1xvyscqd8lv6w3yq7xd5b3"

     

       73
       73
       +
           },

     

       74
       74
       +
           "optifine_1_13": {

     

       75
       75
       +
               "version": "1.13_HD_U_E4",

     

       76
       76
       +
               "sha256": "0x8ynnm9dglzrajb3ffmvmwkx6ipzs306qadwhcp0ah148wiz1l3"

     

       77
       77
       +
           },

     

       78
       78
       +
           "optifine_1_12_2": {

     

       79
       79
       +
               "version": "1.12.2_HD_U_G5",

     

       80
       80
       +
               "sha256": "07i7p8wsh22xx31g22kk5vxwwy4sgjp0ha8d5mzvkzkifxwhc01v"

     

       81
       81
       +
           },

     

       82
       82
       +
           "optifine_1_12_1": {

     

       83
       83
       +
               "version": "1.12.1_HD_U_G5",

     

       84
       84
       +
               "sha256": "1jn02mknpf622q6i942v63x3kzs9q7n394x188nfh508rn9fpipn"

     

       85
       85
       +
           },

     

       86
       86
       +
           "optifine_1_12": {

     

       87
       87
       +
               "version": "1.12_HD_U_G5",

     

       88
       88
       +
               "sha256": "1slbz0ss670gwlzv4dw362cc5wlpxjv81004n04vcsip8l491pdb"

     

       89
       89
       +
           },

     

       90
       90
       +
           "optifine_1_11_2": {

     

       91
       91
       +
               "version": "1.11.2_HD_U_G5",

     

       92
       92
       +
               "sha256": "1zlap4j3qzb00a9qxk9ww1cgmqaiznblahj19p1r4yrrsc3d9hnn"

     

       93
       93
       +
           },

     

       94
       94
       +
           "optifine_1_11": {

     

       95
       95
       +
               "version": "1.11_HD_U_G5",

     

       96
       96
       +
               "sha256": "1azgnsqbl71087i83dn6wyb7qdz2wa42f04cabnlhmdcmdd4kcsj"

     

       97
       97
       +
           },

     

       98
       98
       +
           "optifine_1_10_2": {

     

       99
       99
       +
               "version": "1.10.2_HD_U_I5",

     

       100
       100
       +
               "sha256": "0m05xqcmh8kaqvlb57yz0mslf22wr89wamlf1q1cma4fn385i57f"

     

       101
       101
       +
           },

     

       102
       102
       +
           "optifine_1_10": {

     

       103
       103
       +
               "version": "1.10_HD_U_I5",

     

       104
       104
       +
               "sha256": "1kd502h6ikxmyj99bj7d41j7z237yipn1hxhb3hsff37s5lar8x0"

     

       105
       105
       +
           },

     

       106
       106
       +
           "optifine_1_9_4": {

     

       107
       107
       +
               "version": "1.9.4_HD_U_I5",

     

       108
       108
       +
               "sha256": "08pb3x0c898pgsciigvy0q9j25arlyqzira4qmcz75qkzlhv3qxp"

     

       109
       109
       +
           },

     

       110
       110
       +
           "optifine_1_9_2": {

     

       111
       111
       +
               "version": "1.9.2_HD_U_E3",

     

       112
       112
       +
               "sha256": "1bgyxhs554wswavidsnmm6mahngndd5bc98jma6wgi7g5qrngcrp"

     

       113
       113
       +
           },

     

       114
       114
       +
           "optifine_1_9_0": {

     

       115
       115
       +
               "version": "1.9.0_HD_U_I5",

     

       116
       116
       +
               "sha256": "1nyiv91hm9765244xa6mh9cf62l329ppm8rdib35lb3ghgasid9n"

     

       117
       117
       +
           },

     

       118
       118
       +
           "optifine_1_8_9": {

     

       119
       119
       +
               "version": "1.8.9_HD_U_M5",

     

       120
       120
       +
               "sha256": "1i5j4jvsd1zkly6pf8zs71gga61z533bq5y8gmfax9pwf057cf97"

     

       121
       121
       +
           },

     

       122
       122
       +
           "optifine_1_8_8": {

     

       123
       123
       +
               "version": "1.8.8_HD_U_I7",

     

       124
       124
       +
               "sha256": "0x4aambs2kww9lanm4kp2jw4h3cwk25fa6xwsm9r7a1jv42jlyay"

     

       125
       125
       +
           },

     

       126
       126
       +
           "optifine_1_8_0": {

     

       127
       127
       +
               "version": "1.8.0_HD_U_I7",

     

       128
       128
       +
               "sha256": "1ig013l61f7yj061ncnvmjsp9j2nd8fy8j03f8ry045d0s7idnfk"

     

       129
       129
       +
           },

     

       130
       130
       +
           "optifine_1_7_10": {

     

       131
       131
       +
               "version": "1.7.10_HD_U_E7",

     

       132
       132
       +
               "sha256": "1d7s8ip697xnlpap89qrr794f307kwv5y44qyj8ha6h0vs1rvkcb"

     

       133
       133
       +
           },

     

       134
       134
       +
           "optifine_1_7_2": {

     

       135
       135
       +
               "version": "1.7.2_HD_U_F7",

     

       136
       136
       +
               "sha256": "18lzyh639mi7r2hzwnmxv0a6v1ay7dk9bzasvwff82dxq0y9zi7m"

     

       137
       137
       +
           },

     

       138
       138
       +
           "optifine-latest": {

     

       139
       139
       +
               "version": "1.19.2_HD_U_H9",

     

       140
       140
       +
               "sha256": "1xyg98i7zar5x3xbgpn2nm48mc3r9q6yqisxnqk3g254ghjcy4xx"

     

       141
       141
       +
           }

     

       142
       142
       +
       }

+28

pkgs/tools/misc/nitch/default.nix

···

       1
       1
       +
       { lib, nimPackages, fetchFromGitHub, fetchpatch }:

     

       2
       2
       +
       nimPackages.buildNimPackage rec {

     

       3
       3
       +
         pname = "nitch";

     

       4
       4
       +
         version = "0.1.6";

     

       5
       5
       +
         nimBinOnly = true;

     

       6
       6
       +
         src = fetchFromGitHub {

     

       7
       7
       +
           owner = "unxsh";

     

       8
       8
       +
           repo = "nitch";

     

       9
       9
       +
           rev = "42ad6899931dd5e0cec7b021c2b7e383fcc891f3";

     

       10
       10
       +
           hash = "sha256-QI7CbP0lvvjD+g29FR/YJjuZboZ+PoHynsNbpYC9SvE=";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         patches = [

     

       14
       14
       +
           (fetchpatch {

     

       15
       15
       +
             url = "https://github.com/unxsh/nitch/commit/6831cf96144f58c4da298a0bc9b50d33056f6c08.patch";

     

       16
       16
       +
             sha256 = "sha256-uZUzUBLHBsssNqDxZ0NuTRMN9/gBxIlIiGgQkqCqEFc=";

     

       17
       17
       +
           })

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with lib; {

     

       21
       21
       +
           description = "Incredibly fast system fetch written in nim";

     

       22
       22
       +
           homepage = "https://github.com/unxsh/nitch";

     

       23
       23
       +
           license = licenses.mit;

     

       24
       24
       +
           platforms = platforms.linux;

     

       25
       25
       +
           maintainers = with maintainers; [ quasigod-io ];

     

       26
       26
       +
           mainProgram = "nitch";

     

       27
       27
       +
         };

     

       28
       28
       +
       }

pkgs/tools/misc/yubikey-manager/default.nix

···

       68
       68
        
           license = licenses.bsd2;

     

       69
       69
        
           platforms = platforms.unix;

     

       70
       70
        
           maintainers = with maintainers; [ benley lassulus pinpox ];

     

       71
       71
       +
           mainProgram = "ykman";

     

       71
       72
        
         };

     

       72
       73
        
       }

-29

pkgs/tools/virtualization/aws/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, perl, curl }:

     

       2
       2
       -
       

     

       3
       3
       -
       stdenv.mkDerivation {

     

       4
       4
       -
         pname = "aws";

     

       5
       5
       -
         version = "2019.06.18";

     

       6
       6
       -
       

     

       7
       7
       -
         src = fetchurl {

     

       8
       8
       -
           url = "https://raw.github.com/timkay/aws/ac68eb5191c52f069b9aa0c9a99808f8a4430833/aws";

     

       9
       9
       -
           sha256 = "02bym9wicqpdr7mdim13zw5ssh97xfswzab9q29rsbg7058ddbil";

     

       10
       10
       -
         };

     

       11
       11
       -
       

     

       12
       12
       -
         buildInputs = [ perl ];

     

       13
       13
       -
       

     

       14
       14
       -
         dontUnpack = true;

     

       15
       15
       -
       

     

       16
       16
       -
         installPhase =

     

       17
       17
       -
           ''

     

       18
       18
       -
             mkdir -p $out/bin

     

       19
       19
       -
             sed 's|\[curl|[${curl.bin}/bin/curl|g' $src > $out/bin/aws

     

       20
       20
       -
             chmod +x $out/bin/aws

     

       21
       21
       -
           '';

     

       22
       22
       -
       

     

       23
       23
       -
         meta = {

     

       24
       24
       -
           homepage = "https://www.timkay.com/aws/";

     

       25
       25
       -
           description = "Command-line utility for working with Amazon EC2, S3, SQS, ELB, IAM and SDB";

     

       26
       26
       -
           license = lib.licenses.gpl3Plus;

     

       27
       27
       -
           platforms = lib.platforms.unix;

     

       28
       28
       -
         };

     

       29
       29
       -
       }

+2 -2

pkgs/tools/virtualization/kubevirt/default.nix

···

       8
       8
        
       

     

       9
       9
        
       buildGoModule rec {

     

       10
       10
        
         pname = "kubevirt";

     

       11
       11
       -
         version = "0.56.1";

     

       11
       11
       +
         version = "0.57.0";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "kubevirt";

     

       15
       15
        
           repo = "kubevirt";

     

       16
       16
        
           rev = "v${version}";

     

       17
       17
       -
           sha256 = "sha256-PYVV/0qCBhR2l+rLuoPTe3FvLX9NmHHcA9gOeUj1IVw=";

     

       17
       17
       +
           sha256 = "sha256-+35z953dgb6lJpC/8+VcrHLY6yXINoDxq6GxkEEVOgU=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         vendorSha256 = null;

pkgs/top-level/aliases.nix

···

       97
       97
        
         avldrums-lv2 = x42-avldrums; # Added 2020-03-29

     

       98
       98
        
         avxsynth = throw "avxsynth was removed because it was broken"; # Added 2021-05-18

     

       99
       99
        
         awesome-4-0 = awesome; # Added 2022-05-05

     

       100
       100
       +
         aws = throw "aws has been removed: abandoned by upstream. For the AWS CLI maintained by Amazon, see 'awscli' or 'awscli2'"; # Added 2022-09-21

     

       100
       101
        
         awless = throw "awless has been dropped due to the lack of maintenance from upstream since 2018"; # Added 2022-05-30

     

       101
       102
        
         aws-okta = throw "aws-okta is on indefinite hiatus. See https://github.com/segmentio/aws-okta/issues/278"; # Added 2022-04-05;

     

       102
       103
        
         axoloti = throw "axoloti has been removed: abandoned by upstream"; # Added 2022-05-13

+13 -13

pkgs/top-level/all-packages.nix

···

       2899
       2899
        
       

     

       2900
       2900
        
         avro-cpp = callPackage ../development/libraries/avro-c++ { };

     

       2901
       2901
        
       

     

       2902
       2902
       -
         aws = callPackage ../tools/virtualization/aws { };

     

       2903
       2903
       -
       

     

       2904
       2902
        
         aws_mturk_clt = callPackage ../tools/misc/aws-mturk-clt { };

     

       2905
       2903
        
       

     

       2906
       2904
        
         awsls = callPackage ../tools/admin/awsls { };

     
···

       4450
       4448
        
         nfdump = callPackage ../tools/networking/nfdump { };

     

       4451
       4449
        
       

     

       4452
       4450
        
         nfstrace = callPackage ../tools/networking/nfstrace { };

     

       4451
       4451
       +
       

     

       4452
       4452
       +
         nitch = callPackage ../tools/misc/nitch { };

     

       4453
       4453
        
       

     

       4454
       4454
        
         nix-direnv = callPackage ../tools/misc/nix-direnv { };

     

       4455
       4455
        
       

     
···

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

     

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

     

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

     

       9820
       9820
       -
           haskellPackages = haskell.packages.ghc8107;

     

       9820
       9820
       +
           haskellPackages = haskell.packages.ghc810;

     

       9821
       9821
        
         };

     

       9822
       9822
        
       

     

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

     
···

       12735
       12735
        
       

     

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

     

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

     

       12738
       12738
       -
           haskellPackages = haskell.packages.ghc8107;

     

       12738
       12738
       +
           haskellPackages = haskell.packages.ghc810;

     

       12739
       12739
        
         };

     

       12740
       12740
        
       

     

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

     
···

       13852
       13852
        
         haskellPackages = dontRecurseIntoAttrs

     

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

     

       13854
       13854
        
           (if stdenv.hostPlatform.isStatic

     

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

     

       13856
       13856
       -
              else haskell.packages.ghc902);

     

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

     

       13856
       13856
       +
              else haskell.packages.ghc90);

     

       13857
       13857
        
       

     

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

     

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

     
···

       13866
       13866
        
         ghc = targetPackages.haskellPackages.ghc or

     

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

     

       13868
       13868
        
           (if stdenv.targetPlatform.isStatic

     

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

     

       13870
       13870
       -
              else haskell.compiler.ghc902);

     

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

     

       13870
       13870
       +
              else haskell.compiler.ghc90);

     

       13871
       13871
        
       

     

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

     

       13873
       13873
        
       

     
···

       15151
       15151
        
           stdenv = clangStdenv;

     

       15152
       15152
        
         };

     

       15153
       15153
        
       

     

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

     

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

     

       15155
       15155
        
       

     

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

     

       15157
       15157
        
       

     
···

       18296
       18296
        
         galer = callPackage ../tools/security/galer { };

     

       18297
       18297
        
       

     

       18298
       18298
        
         gamenetworkingsockets = callPackage ../development/libraries/gamenetworkingsockets { };

     

       18299
       18299
       +
       

     

       18300
       18300
       +
         game-music-emu = callPackage ../development/libraries/audio/game-music-emu { };

     

       18299
       18301
        
       

     

       18300
       18302
        
         gamin = callPackage ../development/libraries/gamin { };

     

       18301
       18303
        
         fam = gamin; # added 2018-04-25

     
···

       23007
       23009
        
       

     

       23008
       23010
        
         hashi-ui = callPackage ../servers/hashi-ui {};

     

       23009
       23011
        
       

     

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

     

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

     

       23011
       23013
        
       

     

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

     

       23013
       23015
        
       

     
···

       28081
       28083
        
       

     

       28082
       28084
        
         g933-utils = callPackage ../tools/misc/g933-utils { };

     

       28083
       28085
        
       

     

       28084
       28084
       -
         game-music-emu = callPackage ../applications/audio/game-music-emu { };

     

       28085
       28085
       -
       

     

       28086
       28086
        
         gavrasm = callPackage ../development/compilers/gavrasm { };

     

       28087
       28087
        
       

     

       28088
       28088
        
         gcalcli = callPackage ../applications/misc/gcalcli { };

     
···

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

     

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

     

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

     

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

     

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

     

       31400
       31400
        
         };

     

       31401
       31401
        
       

     

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

+21 -5

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 = [

     

       27
       27
       +
           "ghc90"

     

       24
       28
        
           "ghc902"

     

       29
       29
       +
           "ghc92"

     

       25
       30
        
           "ghc924"

     

       31
       31
       +
           "ghc94"

     

       26
       32
        
           "ghc942"

     

       27
       33
        
           "ghcHEAD"

     

       28
       34
        
         ];

     
···

       56
       62
        
       

     

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

     

       58
       64
        
       

     

       59
       59
       -
         compiler = {

     

       65
       65
       +
         compiler = rec {

     

       60
       66
        
       

     

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

     

       62
       68
        
             llvmPackages = pkgs.llvmPackages_6;

     
···

       103
       109
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_7;

     

       104
       110
        
             llvmPackages = pkgs.llvmPackages_7;

     

       105
       111
        
           };

     

       112
       112
       +
           ghc88 = ghc884;

     

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

     

       107
       114
        
             bootPkgs =

     

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

     
···

       123
       130
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       124
       131
        
             llvmPackages = pkgs.llvmPackages_12;

     

       125
       132
        
           };

     

       133
       133
       +
           ghc810 = ghc8107;

     

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

     

       127
       135
        
             bootPkgs =

     

       128
       136
        
               # aarch64 ghc8107Binary exceeds max output size on hydra

     
···

       130
       138
        
               if stdenv.hostPlatform.isAarch then

     

       131
       139
        
                 packages.ghc8107BinaryMinimal

     

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

     

       133
       133
       -
                 packages.ghc8107

     

       141
       141
       +
                 packages.ghc810

     

       134
       142
        
               else

     

       135
       143
        
                 packages.ghc8107Binary;

     

       136
       144
        
             inherit (buildPackages.python3Packages) sphinx;

     
···

       138
       146
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       139
       147
        
             llvmPackages = pkgs.llvmPackages_12;

     

       140
       148
        
           };

     

       149
       149
       +
           ghc90 = ghc902;

     

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

     

       142
       151
        
             bootPkgs =

     

       143
       152
        
               # aarch64 ghc8107Binary exceeds max output size on hydra

     

       144
       153
        
               if stdenv.hostPlatform.isAarch then

     

       145
       154
        
                 packages.ghc8107BinaryMinimal

     

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

     

       147
       147
       -
                 packages.ghc8107

     

       156
       156
       +
                 packages.ghc810

     

       148
       157
        
               else

     

       149
       158
        
                 packages.ghc8107Binary;

     

       150
       159
        
             inherit (buildPackages.python3Packages) sphinx;

     
···

       155
       164
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       156
       165
        
             llvmPackages = pkgs.llvmPackages_12;

     

       157
       166
        
           };

     

       167
       167
       +
           ghc92 = ghc924;

     

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

     

       159
       169
        
             bootPkgs =

     

       160
       170
        
               # Building with 9.2 is broken due to

     
···

       179
       189
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       180
       190
        
             llvmPackages = pkgs.llvmPackages_12;

     

       181
       191
        
           };

     

       192
       192
       +
           ghc94 = ghc942;

     

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

     

       183
       194
        
             bootPkgs =

     

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

     
···

       197
       208
        
       

     

       198
       209
        
           ghcjs = compiler.ghcjs810;

     

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

     

       200
       200
       -
             bootPkgs = packages.ghc8107;

     

       211
       211
       +
             bootPkgs = packages.ghc810;

     

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

     

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

     

       203
       214
        
           };

     
···

       227
       238
        
         packageOverrides = self : super : {};

     

       228
       239
        
       

     

       229
       240
        
         # Always get compilers from `buildPackages`

     

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

     

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

     

       231
       242
        
       

     

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

     

       233
       244
        
             buildHaskellPackages = bh.packages.ghc865Binary;

     
···

       276
       287
        
             ghc = bh.compiler.ghc884;

     

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

     

       278
       289
        
           };

     

       290
       290
       +
           ghc88 = ghc884;

     

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

     

       280
       292
        
             buildHaskellPackages = bh.packages.ghc8107;

     

       281
       293
        
             ghc = bh.compiler.ghc8107;

     

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

     

       283
       295
        
           };

     

       296
       296
       +
           ghc810 = ghc8107;

     

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

     

       285
       298
        
             buildHaskellPackages = bh.packages.ghc902;

     

       286
       299
        
             ghc = bh.compiler.ghc902;

     

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

     

       288
       301
        
           };

     

       302
       302
       +
           ghc90 = ghc902;

     

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

     

       290
       304
        
             buildHaskellPackages = bh.packages.ghc924;

     

       291
       305
        
             ghc = bh.compiler.ghc924;

     

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

     

       293
       307
        
           };

     

       308
       308
       +
           ghc92 = ghc924;

     

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

     

       295
       310
        
             buildHaskellPackages = bh.packages.ghc942;

     

       296
       311
        
             ghc = bh.compiler.ghc942;

     

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

     

       298
       313
        
           };

     

       314
       314
       +
           ghc94= ghc942;

     

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

     

       300
       316
        
             buildHaskellPackages = bh.packages.ghcHEAD;

     

       301
       317
        
             ghc = bh.compiler.ghcHEAD;

pkgs/top-level/ocaml-packages.nix

···

       319
       319
        
       

     

       320
       320
        
           dns-tsig = callPackage ../development/ocaml-modules/dns/tsig.nix { };

     

       321
       321
        
       

     

       322
       322
       +
           dnssec = callPackage ../development/ocaml-modules/dns/dnssec.nix { };

     

       323
       323
       +
       

     

       322
       324
        
           dolmen =  callPackage ../development/ocaml-modules/dolmen { };

     

       323
       325
        
       

     

       324
       326
        
           dolog = callPackage ../development/ocaml-modules/dolog { };

+2 -1

pkgs/top-level/release-haskell.nix

···

       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.

     
···

       332
       333
        
                   };

     

       333
       334
        
       

     

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

     

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

     

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

     

       336
       337
        
                       hello

     

       337
       338
        
                       lens

     

       338
       339
        
                       random