commit 071a7a4583a58b4b1454df4dad85981428a8dfc1 · pyrox.dev/nixpkgs

+1 -1

doc/languages-frameworks/javascript.section.md

···

       2
       2
        
       

     

       3
       3
        
       ## Introduction {#javascript-introduction}

     

       4
       4
        
       

     

       5
       5
       -
       This contains instructions on how to package javascript applications. For instructions on how to add a cli package from npm please consult the #node.js section

     

       5
       5
       +
       This contains instructions on how to package javascript applications.

     

       6
       6
        
       

     

       7
       7
        
       The various tools available will be listed in the [tools-overview](#javascript-tools-overview). Some general principles for packaging will follow. Finally some tool specific instructions will be given.

     

       8
       8

+12

maintainers/maintainer-list.nix

···

       80
       80
        
           githubId = 791309;

     

       81
       81
        
           name = "Jan Hrnko";

     

       82
       82
        
         };

     

       83
       83
       +
         _1000teslas = {

     

       84
       84
       +
           name = "Kevin Tran";

     

       85
       85
       +
           email = "47207223+1000teslas@users.noreply.github.com";

     

       86
       86
       +
           github = "1000teslas";

     

       87
       87
       +
           githubId = 47207223;

     

       88
       88
       +
         };

     

       83
       89
        
         _3699n = {

     

       84
       90
        
           email = "nicholas@nvk.pm";

     

       85
       91
        
           github = "3699n";

     
···

       3620
       3626
        
             longkeyid = "rsa4096/0xECC755EE583C1672";

     

       3621
       3627
        
             fingerprint = "2F93 661D AC17 EA98 A104  F780 ECC7 55EE 583C 1672";

     

       3622
       3628
        
           }];

     

       3629
       3629
       +
         };

     

       3630
       3630
       +
         flexagoon = {

     

       3631
       3631
       +
           email = "flexagoon@pm.me";

     

       3632
       3632
       +
           github = "flexagoon";

     

       3633
       3633
       +
           githubId = 66178592;

     

       3634
       3634
       +
           name = "Pavel Zolotarevskiy";

     

       3623
       3635
        
         };

     

       3624
       3636
        
         flexw = {

     

       3625
       3637
        
           email = "felix.weilbach@t-online.de";

+1 -1

nixos/modules/misc/crashdump.nix

···

       50
       50
        
           boot = {

     

       51
       51
        
             postBootCommands = ''

     

       52
       52
        
               echo "loading crashdump kernel...";

     

       53
       53
       -
               ${pkgs.kexectools}/sbin/kexec -p /run/current-system/kernel \

     

       53
       53
       +
               ${pkgs.kexec-tools}/sbin/kexec -p /run/current-system/kernel \

     

       54
       54
        
               --initrd=/run/current-system/initrd \

     

       55
       55
        
               --reset-vga --console-vga \

     

       56
       56
        
               --command-line="init=$(readlink -f /run/current-system/init) irqpoll maxcpus=1 reset_devices ${kernelParams}"

+1 -1

nixos/modules/services/desktops/pipewire/pipewire.nix

···

       194
       194
        
           };

     

       195
       195
        
       

     

       196
       196
        
           environment.sessionVariables.LD_LIBRARY_PATH =

     

       197
       197
       -
             lib.optional cfg.jack.enable "/run/current-system/sw/lib/pipewire";

     

       197
       197
       +
             lib.optional cfg.jack.enable "${cfg.package.jack}/lib";

     

       198
       198
        
       

     

       199
       199
        
           # https://gitlab.freedesktop.org/pipewire/pipewire/-/issues/464#note_723554

     

       200
       200
        
           systemd.user.services.pipewire.environment."PIPEWIRE_LINK_PASSIVE" = "1";

+3 -3

nixos/modules/system/boot/kexec.nix

···

       1
       1
        
       { pkgs, lib, ... }:

     

       2
       2
        
       

     

       3
       3
        
       {

     

       4
       4
       -
         config = lib.mkIf (lib.meta.availableOn pkgs.stdenv.hostPlatform pkgs.kexectools) {

     

       5
       5
       -
           environment.systemPackages = [ pkgs.kexectools ];

     

       4
       4
       +
         config = lib.mkIf (lib.meta.availableOn pkgs.stdenv.hostPlatform pkgs.kexec-tools) {

     

       5
       5
       +
           environment.systemPackages = [ pkgs.kexec-tools ];

     

       6
       6
        
       

     

       7
       7
        
           systemd.services.prepare-kexec =

     

       8
       8
        
             { description = "Preparation for kexec";

     
···

       10
       10
        
               before = [ "systemd-kexec.service" ];

     

       11
       11
        
               unitConfig.DefaultDependencies = false;

     

       12
       12
        
               serviceConfig.Type = "oneshot";

     

       13
       13
       -
               path = [ pkgs.kexectools ];

     

       13
       13
       +
               path = [ pkgs.kexec-tools ];

     

       14
       14
        
               script =

     

       15
       15
        
                 ''

     

       16
       16
        
                   # Don't load the current system profile if we already have a kernel loaded

+2 -2

pkgs/applications/editors/emacs/elisp-packages/ebuild-mode/default.nix

···

       2
       2
        
       

     

       3
       3
        
       trivialBuild rec {

     

       4
       4
        
         pname = "ebuild-mode";

     

       5
       5
       -
         version = "1.52";

     

       5
       5
       +
         version = "1.53";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "https://dev.gentoo.org/~ulm/emacs/${pname}-${version}.tar.xz";

     

       9
       9
       -
           sha256 = "10nikbbwh612qlnms2i31963a0h3ccyg85vrxlizdpsqs4cjpg6h";

     

       9
       9
       +
           sha256 = "1l740qp71df9ids0c49kvp942rk8k1rfkg1hyv7ysfns5shk7b9l";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         meta = with lib; {

+8 -1

pkgs/applications/editors/vscode/generic.nix

···

       1
       1
        
       { stdenv, lib, makeDesktopItem

     

       2
       2
        
       , unzip, libsecret, libXScrnSaver, libxshmfence, wrapGAppsHook

     

       3
       3
        
       , gtk2, atomEnv, at-spi2-atk, autoPatchelfHook

     

       4
       4
       -
       , systemd, fontconfig, libdbusmenu, buildFHSUserEnvBubblewrap

     

       4
       4
       +
       , systemd, fontconfig, libdbusmenu, glib, buildFHSUserEnvBubblewrap

     

       5
       5
        
       , writeShellScriptBin

     

       6
       6
        
       

     

       7
       7
        
       # Populate passthru.tests

     
···

       99
       99
        
             grep -q "VSCODE_PATH='$out/lib/vscode'" $out/bin/${executableName} # check if sed succeeded

     

       100
       100
        
           '') + ''

     

       101
       101
        
             runHook postInstall

     

       102
       102
       +
           '';

     

       103
       103
       +
       

     

       104
       104
       +
           preFixup = ''

     

       105
       105
       +
             gappsWrapperArgs+=(

     

       106
       106
       +
               # Add gio to PATH so that moving files to the trash works when not using a desktop environment

     

       107
       107
       +
               --prefix PATH : ${glib.bin}/bin

     

       108
       108
       +
             )

     

       102
       109
        
           '';

     

       103
       110
        
       

     

       104
       111
        
           inherit meta;

+6 -2

pkgs/applications/terminal-emulators/termonad/default.nix

···

       1
       1
       -
       { stdenv, ghcWithPackages, makeWrapper, packages ? (pkgSet: []) }:

     

       1
       1
       +
       { stdenv, haskellPackages, makeWrapper, packages ? (pkgSet: []) }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         termonadEnv = ghcWithPackages (self: [ self.termonad ] ++ packages self);

     

       4
       4
       +
         termonadEnv = haskellPackages.ghcWithPackages (self: [ self.termonad ] ++ packages self);

     

       5
       5
        
       in stdenv.mkDerivation {

     

       6
       6
        
         name = "termonad-with-packages-${termonadEnv.version}";

     

       7
       7
        
       

     
···

       16
       16
        
         # trivial derivation

     

       17
       17
        
         preferLocalBuild = true;

     

       18
       18
        
         allowSubstitutes = false;

     

       19
       19
       +
       

     

       20
       20
       +
         meta = haskellPackages.termonad.meta // {

     

       21
       21
       +
           mainProgram = "termonad";

     

       22
       22
       +
         };

     

       19
       23
        
       }

+5 -5

pkgs/applications/version-management/gitlab/data.json

···

       1
       1
        
       {

     

       2
       2
       -
         "version": "14.2.1",

     

       3
       3
       -
         "repo_hash": "0ivymkqcwl2lrnv0lkcw2ch26iyz9ixklrkc2jq38pbwc0igf89z",

     

       2
       2
       +
         "version": "14.2.3",

     

       3
       3
       +
         "repo_hash": "06fr8srz5ii0h65b1h2zfm8kzqz9g8jy2aq4g5js6kmv44zjya1p",

     

       4
       4
        
         "owner": "gitlab-org",

     

       5
       5
        
         "repo": "gitlab",

     

       6
       6
       -
         "rev": "v14.2.1-ee",

     

       6
       6
       +
         "rev": "v14.2.3-ee",

     

       7
       7
        
         "passthru": {

     

       8
       8
       -
           "GITALY_SERVER_VERSION": "14.2.1",

     

       8
       8
       +
           "GITALY_SERVER_VERSION": "14.2.3",

     

       9
       9
        
           "GITLAB_PAGES_VERSION": "1.42.0",

     

       10
       10
        
           "GITLAB_SHELL_VERSION": "13.19.1",

     

       11
       11
       -
           "GITLAB_WORKHORSE_VERSION": "14.2.1"

     

       11
       11
       +
           "GITLAB_WORKHORSE_VERSION": "14.2.3"

     

       12
       12
        
         }

     

       13
       13
        
       }

pkgs/applications/version-management/gitlab/default.nix

···

       22
       22
        
           gemset =

     

       23
       23
        
             let x = import (gemdir + "/gemset.nix");

     

       24
       24
        
             in x // {

     

       25
       25
       +
               # grpc expects the AR environment variable to contain `ar rpc`. See the

     

       26
       26
       +
               # discussion in nixpkgs #63056.

     

       27
       27
       +
               grpc = x.grpc // {

     

       28
       28
       +
                 patches = [ ./fix-grpc-ar.patch ];

     

       29
       29
       +
                 dontBuild = false;

     

       30
       30
       +
               };

     

       25
       31
        
               # the openssl needs the openssl include files

     

       26
       32
        
               openssl = x.openssl // {

     

       27
       33
        
                 buildInputs = [ openssl ];

+10

pkgs/applications/version-management/gitlab/fix-grpc-ar.patch

···

       1
       1
       +
       --- a/src/ruby/ext/grpc/extconf.rb

     

       2
       2
       +
       +++ b/src/ruby/ext/grpc/extconf.rb

     

       3
       3
       +
       @@ -27,6 +27,7 @@ ENV['MACOSX_DEPLOYMENT_TARGET'] = '10.7'

     

       4
       4
       +
        if ENV['AR'].nil? || ENV['AR'].size == 0

     

       5
       5
       +
            ENV['AR'] = RbConfig::CONFIG['AR'] + ' rcs'

     

       6
       6
       +
        end

     

       7
       7
       +
       +ENV['AR'] = ENV['AR'] + ' rcs'

     

       8
       8
       +
        if ENV['CC'].nil? || ENV['CC'].size == 0

     

       9
       9
       +
            ENV['CC'] = RbConfig::CONFIG['CC']

     

       10
       10
       +
        end

+2 -2

pkgs/applications/version-management/gitlab/gitaly/Gemfile

···

       7
       7
        
       gem 'rdoc', '~> 6.0'

     

       8
       8
        
       gem 'gitlab-gollum-lib', '~> 4.2.7.10.gitlab.1', require: false

     

       9
       9
        
       gem 'gitlab-gollum-rugged_adapter', '~> 0.4.4.4.gitlab.1', require: false

     

       10
       10
       -
       gem 'grpc', '~> 1.38.0'

     

       10
       10
       +
       gem 'grpc', '~> 1.30.2'

     

       11
       11
        
       gem 'sentry-raven', '~> 3.0', require: false

     

       12
       12
        
       gem 'faraday', '~> 1.0'

     

       13
       13
        
       gem 'rbtrace', require: false

     
···

       29
       29
        
         gem 'factory_bot', require: false

     

       30
       30
        
         gem 'pry', '~> 0.12.2', require: false

     

       31
       31
        
       

     

       32
       32
       -
         gem 'grpc-tools', '= 1.38.0'

     

       32
       32
       +
         gem 'grpc-tools', '= 1.30.2'

     

       33
       33
        
       end

+5 -5

pkgs/applications/version-management/gitlab/gitaly/Gemfile.lock

···

       77
       77
        
           google-protobuf (3.17.3)

     

       78
       78
        
           googleapis-common-protos-types (1.1.0)

     

       79
       79
        
             google-protobuf (~> 3.14)

     

       80
       80
       -
           grpc (1.38.0)

     

       81
       81
       -
             google-protobuf (~> 3.15)

     

       80
       80
       +
           grpc (1.30.2)

     

       81
       81
       +
             google-protobuf (~> 3.12)

     

       82
       82
        
             googleapis-common-protos-types (~> 1.0)

     

       83
       83
       -
           grpc-tools (1.38.0)

     

       83
       83
       +
           grpc-tools (1.30.2)

     

       84
       84
        
           i18n (1.8.10)

     

       85
       85
        
             concurrent-ruby (~> 1.0)

     

       86
       86
        
           ice_nine (0.11.2)

     
···

       225
       225
        
         gitlab-labkit (~> 0.20.0)

     

       226
       226
        
         gitlab-markup (~> 1.7.1)

     

       227
       227
        
         google-protobuf (~> 3.17.0)

     

       228
       228
       -
         grpc (~> 1.38.0)

     

       229
       229
       -
         grpc-tools (= 1.38.0)

     

       228
       228
       +
         grpc (~> 1.30.2)

     

       229
       229
       +
         grpc-tools (= 1.30.2)

     

       230
       230
        
         licensee (~> 9.14.1)

     

       231
       231
        
         pry (~> 0.12.2)

     

       232
       232
        
         rbtrace

+12 -2

pkgs/applications/version-management/gitlab/gitaly/default.nix

···

       9
       9
        
           inherit ruby;

     

       10
       10
        
           copyGemFiles = true;

     

       11
       11
        
           gemdir = ./.;

     

       12
       12
       +
           gemset =

     

       13
       13
       +
             let x = import (gemdir + "/gemset.nix");

     

       14
       14
       +
             in x // {

     

       15
       15
       +
               # grpc expects the AR environment variable to contain `ar rpc`. See the

     

       16
       16
       +
               # discussion in nixpkgs #63056.

     

       17
       17
       +
               grpc = x.grpc // {

     

       18
       18
       +
                 patches = [ ../fix-grpc-ar.patch ];

     

       19
       19
       +
                 dontBuild = false;

     

       20
       20
       +
               };

     

       21
       21
       +
             };

     

       12
       22
        
         };

     

       13
       13
       -
         version = "14.2.1";

     

       23
       23
       +
         version = "14.2.3";

     

       14
       24
        
         gitaly_package = "gitlab.com/gitlab-org/gitaly/v${lib.versions.major version}";

     

       15
       25
        
       in

     

       16
       26
        
       

     
···

       22
       32
        
           owner = "gitlab-org";

     

       23
       33
        
           repo = "gitaly";

     

       24
       34
        
           rev = "v${version}";

     

       25
       25
       -
           sha256 = "sha256-B3NtdS1UcT+nYIdoXs+tW2gnXZ0ew+NiIcCNi5z5fOc=";

     

       35
       35
       +
           sha256 = "sha256-TSA5CoNaLeMu7O02rsaR/rNciLwzxSIUUQsCo40Z15c=";

     

       26
       36
        
         };

     

       27
       37
        
       

     

       28
       38
        
         vendorSha256 = "sha256-WhkNK+V7yXK+le1u8StAKajZIBzVKqV/WIau27oZBXE=";

+4 -4

pkgs/applications/version-management/gitlab/gitaly/gemset.nix

···

       311
       311
        
           platforms = [];

     

       312
       312
        
           source = {

     

       313
       313
        
             remotes = ["https://rubygems.org"];

     

       314
       314
       -
             sha256 = "16qxl287kkf34h71djlf9x3wxmd5ylcm83y2zhnrv81gbrhn8k12";

     

       314
       314
       +
             sha256 = "1rsglf7ag17n465iff7vlw83pn2rpl4kv9sb1rpf17nx6xpi7yl5";

     

       315
       315
        
             type = "gem";

     

       316
       316
        
           };

     

       317
       317
       -
           version = "1.38.0";

     

       317
       317
       +
           version = "1.30.2";

     

       318
       318
        
         };

     

       319
       319
        
         grpc-tools = {

     

       320
       320
        
           groups = ["development" "test"];

     

       321
       321
        
           platforms = [];

     

       322
       322
        
           source = {

     

       323
       323
        
             remotes = ["https://rubygems.org"];

     

       324
       324
       -
             sha256 = "0sfbf5s19nfgznlb7m2sfw9l0ppvypj46ijjvq5p35fc6b8by5aq";

     

       324
       324
       +
             sha256 = "0k9zhsqhamp02ryzgfb4y2bbick151vlhrhj0kqbbz9lyhms0bd4";

     

       325
       325
        
             type = "gem";

     

       326
       326
        
           };

     

       327
       327
       -
           version = "1.38.0";

     

       327
       327
       +
           version = "1.30.2";

     

       328
       328
        
         };

     

       329
       329
        
         i18n = {

     

       330
       330
        
           dependencies = ["concurrent-ruby"];

+1 -1

pkgs/applications/version-management/gitlab/gitlab-workhorse/default.nix

···

       5
       5
        
       buildGoModule rec {

     

       6
       6
        
         pname = "gitlab-workhorse";

     

       7
       7
        
       

     

       8
       8
       -
         version = "14.2.1";

     

       8
       8
       +
         version = "14.2.3";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitLab {

     

       11
       11
        
           owner = data.owner;

+3 -3

pkgs/applications/version-management/gitlab/rubyEnv/Gemfile

···

       101
       101
        
       # TODO: remove app/views/graphiql/rails/editors/show.html.erb when https://github.com/rmosolgo/graphiql-rails/pull/71 is released:

     

       102
       102
        
       # https://gitlab.com/gitlab-org/gitlab/issues/31747

     

       103
       103
        
       gem 'graphiql-rails', '~> 1.4.10'

     

       104
       104
       -
       gem 'apollo_upload_server', '~> 2.0.2'

     

       104
       104
       +
       gem 'apollo_upload_server', '~> 2.1.0'

     

       105
       105
        
       gem 'graphql-docs', '~> 1.6.0', group: [:development, :test]

     

       106
       106
        
       gem 'graphlient', '~> 0.4.0' # Used by BulkImport feature (group::import)

     

       107
       107
        
       

     
···

       310
       310
        
       gem 'premailer-rails', '~> 1.10.3'

     

       311
       311
        
       

     

       312
       312
        
       # LabKit: Tracing and Correlation

     

       313
       313
       -
       gem 'gitlab-labkit', '~> 0.21.0'

     

       313
       313
       +
       gem 'gitlab-labkit', '~> 0.21.1'

     

       314
       314
        
       # Thrift is a dependency of gitlab-labkit, we want a version higher than 0.14.0

     

       315
       315
        
       # because of https://gitlab.com/gitlab-org/gitlab/-/issues/321900

     

       316
       316
        
       gem 'thrift', '>= 0.14.0'

     
···

       479
       479
        
       # KAS GRPC protocol definitions

     

       480
       480
        
       gem 'kas-grpc', '~> 0.0.2'

     

       481
       481
        
       

     

       482
       482
       -
       gem 'grpc', '~> 1.38.0'

     

       482
       482
       +
       gem 'grpc', '~> 1.30.2'

     

       483
       483
        
       

     

       484
       484
        
       gem 'google-protobuf', '~> 3.17.1'

     

       485
       485

+9 -9

pkgs/applications/version-management/gitlab/rubyEnv/Gemfile.lock

···

       73
       73
        
           aes_key_wrap (1.1.0)

     

       74
       74
        
           akismet (3.0.0)

     

       75
       75
        
           android_key_attestation (0.3.0)

     

       76
       76
       -
           apollo_upload_server (2.0.2)

     

       76
       76
       +
           apollo_upload_server (2.1.0)

     

       77
       77
       +
             actionpack (>= 4.2)

     

       77
       78
        
             graphql (>= 1.8)

     

       78
       78
       -
             rails (>= 4.2)

     

       79
       79
        
           asana (0.10.3)

     

       80
       80
        
             faraday (~> 1.0)

     

       81
       81
        
             faraday_middleware (~> 1.0)

     
···

       468
       468
        
             fog-json (~> 1.2.0)

     

       469
       469
        
             mime-types

     

       470
       470
        
             ms_rest_azure (~> 0.12.0)

     

       471
       471
       -
           gitlab-labkit (0.21.0)

     

       471
       471
       +
           gitlab-labkit (0.21.1)

     

       472
       472
        
             actionpack (>= 5.0.0, < 7.0.0)

     

       473
       473
        
             activesupport (>= 5.0.0, < 7.0.0)

     

       474
       474
       -
             grpc (~> 1.38)

     

       474
       474
       +
             grpc (~> 1.30.2)

     

       475
       475
        
             jaeger-client (~> 1.1)

     

       476
       476
        
             opentracing (~> 0.4)

     

       477
       477
        
             pg_query (~> 2.1)

     
···

       566
       566
        
             graphql (~> 1.6)

     

       567
       567
        
             html-pipeline (~> 2.8)

     

       568
       568
        
             sass (~> 3.4)

     

       569
       569
       -
           grpc (1.38.0)

     

       570
       570
       -
             google-protobuf (~> 3.15)

     

       569
       569
       +
           grpc (1.30.2)

     

       570
       570
       +
             google-protobuf (~> 3.12)

     

       571
       571
        
             googleapis-common-protos-types (~> 1.0)

     

       572
       572
        
           gssapi (1.2.0)

     

       573
       573
        
             ffi (>= 1.0.1)

     
···

       1385
       1385
        
         acts-as-taggable-on (~> 7.0)

     

       1386
       1386
        
         addressable (~> 2.8)

     

       1387
       1387
        
         akismet (~> 3.0)

     

       1388
       1388
       -
         apollo_upload_server (~> 2.0.2)

     

       1388
       1388
       +
         apollo_upload_server (~> 2.1.0)

     

       1389
       1389
        
         asana (~> 0.10.3)

     

       1390
       1390
        
         asciidoctor (~> 2.0.10)

     

       1391
       1391
        
         asciidoctor-include-ext (~> 0.3.1)

     
···

       1471
       1471
        
         gitlab-dangerfiles (~> 2.3.0)

     

       1472
       1472
        
         gitlab-experiment (~> 0.6.4)

     

       1473
       1473
        
         gitlab-fog-azure-rm (~> 1.1.1)

     

       1474
       1474
       -
         gitlab-labkit (~> 0.21.0)

     

       1474
       1474
       +
         gitlab-labkit (~> 0.21.1)

     

       1475
       1475
        
         gitlab-license (~> 2.0)

     

       1476
       1476
        
         gitlab-mail_room (~> 0.0.9)

     

       1477
       1477
        
         gitlab-markup (~> 1.7.1)

     
···

       1493
       1493
        
         graphlient (~> 0.4.0)

     

       1494
       1494
        
         graphql (~> 1.11.8)

     

       1495
       1495
        
         graphql-docs (~> 1.6.0)

     

       1496
       1496
       -
         grpc (~> 1.38.0)

     

       1496
       1496
       +
         grpc (~> 1.30.2)

     

       1497
       1497
        
         gssapi

     

       1498
       1498
        
         guard-rspec

     

       1499
       1499
        
         haml_lint (~> 0.36.0)

+7 -7

pkgs/applications/version-management/gitlab/rubyEnv/gemset.nix

···

       195
       195
        
           version = "0.3.0";

     

       196
       196
        
         };

     

       197
       197
        
         apollo_upload_server = {

     

       198
       198
       -
           dependencies = ["graphql" "rails"];

     

       198
       198
       +
           dependencies = ["actionpack" "graphql"];

     

       199
       199
        
           groups = ["default"];

     

       200
       200
        
           platforms = [];

     

       201
       201
        
           source = {

     

       202
       202
        
             remotes = ["https://rubygems.org"];

     

       203
       203
       -
             sha256 = "0xk54h9mmzhrbgbmk33v38pavb8w6421mx2yrgsdarkfl9fr90y3";

     

       203
       203
       +
             sha256 = "0klhppx4vjfdvgz12wb63bcxy5ymk0mp8wkh01fpgjn2l3fwkwz5";

     

       204
       204
        
             type = "gem";

     

       205
       205
        
           };

     

       206
       206
       -
           version = "2.0.2";

     

       206
       206
       +
           version = "2.1.0";

     

       207
       207
        
         };

     

       208
       208
        
         asana = {

     

       209
       209
        
           dependencies = ["faraday" "faraday_middleware" "faraday_middleware-multi_json" "oauth2"];

     
···

       1987
       1987
        
           platforms = [];

     

       1988
       1988
        
           source = {

     

       1989
       1989
        
             remotes = ["https://rubygems.org"];

     

       1990
       1990
       -
             sha256 = "0dzdxrn2ra21nyfnabj44fbwbccjkp3i7cjpym99pzbsx8dkna8z";

     

       1990
       1990
       +
             sha256 = "09xci7jw5sckagnwfjlglz4cywylrf16r83f82asnnngvxadvvmq";

     

       1991
       1991
        
             type = "gem";

     

       1992
       1992
        
           };

     

       1993
       1993
       -
           version = "0.21.0";

     

       1993
       1993
       +
           version = "0.21.1";

     

       1994
       1994
        
         };

     

       1995
       1995
        
         gitlab-license = {

     

       1996
       1996
        
           groups = ["default"];

     
···

       2278
       2278
        
           platforms = [];

     

       2279
       2279
        
           source = {

     

       2280
       2280
        
             remotes = ["https://rubygems.org"];

     

       2281
       2281
       -
             sha256 = "16qxl287kkf34h71djlf9x3wxmd5ylcm83y2zhnrv81gbrhn8k12";

     

       2281
       2281
       +
             sha256 = "1rsglf7ag17n465iff7vlw83pn2rpl4kv9sb1rpf17nx6xpi7yl5";

     

       2282
       2282
        
             type = "gem";

     

       2283
       2283
        
           };

     

       2284
       2284
       -
           version = "1.38.0";

     

       2284
       2284
       +
           version = "1.30.2";

     

       2285
       2285
        
         };

     

       2286
       2286
        
         gssapi = {

     

       2287
       2287
        
           dependencies = ["ffi"];

+8 -8

pkgs/data/fonts/helvetica-neue-lt-std/default.nix

···

       1
       1
        
       { lib, fetchzip }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         version = "2013.06.07"; # date of most recent file in distribution

     

       4
       4
       +
         version = "2014.08.16"; # date of most recent file in distribution

     

       5
       5
        
       in fetchzip {

     

       6
       6
        
         name = "helvetica-neue-lt-std-${version}";

     

       7
       7
        
       

     

       8
       8
       -
         url = "http://www.ephifonts.com/downloads/helvetica-neue-lt-std.zip";

     

       8
       8
       +
         url = "https://web.archive.org/web/20190823153624/http://ephifonts.com/downloads/helvetica-neue-lt-std.zip";

     

       9
       9
        
       

     

       10
       10
        
         postFetch = ''

     

       11
       11
        
           mkdir -p $out/share/fonts

     

       12
       12
       -
           unzip -j $downloadedFile Helvetica\ Neue\ LT\ Std/\*.otf -d $out/share/fonts/opentype

     

       12
       12
       +
           unzip -j $downloadedFile "Helvetica Neue LT Std/*.otf" -d $out/share/fonts/opentype

     

       13
       13
        
         '';

     

       14
       14
        
       

     

       15
       15
        
         sha256 = "0ampp9vf9xw0sdppl4lb9i9h75ywljhdcqmzh45mx2x9m7h6xgg9";

     

       16
       16
        
       

     

       17
       17
       -
         meta = {

     

       18
       18
       -
           homepage = "http://www.ephifonts.com/free-helvetica-font-helvetica-neue-lt-std.html";

     

       17
       17
       +
         meta = with lib; {

     

       18
       18
       +
           homepage = "https://web.archive.org/web/20190926040940/http://www.ephifonts.com/free-helvetica-font-helvetica-neue-lt-std.html";

     

       19
       19
        
           description = "Helvetica Neue LT Std font";

     

       20
       20
        
           longDescription = ''

     

       21
       21
        
             Helvetica Neue Lt Std is one of the most highly rated and complete

     
···

       28
       28
        
             font. The numbers are well spaced and defined with high accuracy. The

     

       29
       29
        
             punctuation marks are heavily detailed as well.

     

       30
       30
        
           '';

     

       31
       31
       -
           license = lib.licenses.unfree;

     

       32
       32
       -
           maintainers = [ lib.maintainers.romildo ];

     

       33
       33
       -
           platforms = lib.platforms.all;

     

       31
       31
       +
           license = licenses.unfree;

     

       32
       32
       +
           platforms = platforms.all;

     

       33
       33
       +
           maintainers = with maintainers; [ romildo ];

     

       34
       34
        
         };

     

       35
       35
        
       }

+4 -4

pkgs/data/misc/hackage/pin.json

···

       1
       1
        
       {

     

       2
       2
       -
         "commit": "23315eb3220b0748c3aa71a9027dc39e5416ce9e",

     

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

     

       4
       4
       -
         "sha256": "0pgcyfb3lnl7kxpj87sbj50ljlg2l05v4kgcdwy568pcf24bh764",

     

       5
       5
       -
         "msg": "Update from Hackage at 2021-08-17T22:21:14Z"

     

       2
       2
       +
         "commit": "193a13be44c51ebfc8e991b7bb53a4065129ff4d",

     

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

     

       4
       4
       +
         "sha256": "08j6qx3jqcw7ydwnpjr132l2mlpq6dqvwqgm3gq0ym4kjzrbdwsd",

     

       5
       5
       +
         "msg": "Update from Hackage at 2021-08-23T13:50:03Z"

     

       6
       6
        
       }

+1 -1

pkgs/development/compilers/ghc/8.10.2-binary.nix

···

       374
       374
        
           # `pkgsMusl`.

     

       375
       375
        
           platforms = builtins.attrNames ghcBinDists.${distSetName};

     

       376
       376
        
           hydraPlatforms = builtins.filter (p: minimal || p != "aarch64-linux") platforms;

     

       377
       377
       -
           maintainers = with lib.maintainers; [ lostnet ];

     

       377
       377
       +
           maintainers = with lib.maintainers; [ lostnet guibou ];

     

       378
       378
        
         };

     

       379
       379
        
       }

+9 -8

pkgs/development/compilers/ghc/8.10.5-binary.nix pkgs/development/compilers/ghc/8.10.7-binary.nix

···

       17
       17
        
       let

     

       18
       18
        
         downloadsUrl = "https://downloads.haskell.org/ghc";

     

       19
       19
        
       

     

       20
       20
       -
         version = "8.10.5";

     

       20
       20
       +
         # Copy sha256 from https://downloads.haskell.org/~ghc/8.10.7/SHA256SUMS

     

       21
       21
       +
         version = "8.10.7";

     

       21
       22
        
       

     

       22
       23
        
         # Information about available bindists that we use in the build.

     

       23
       24
        
         #

     
···

       42
       43
        
             i686-linux = {

     

       43
       44
        
               src = {

     

       44
       45
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-i386-deb9-linux.tar.xz";

     

       45
       45
       -
                 sha256 = "17cwmhhyz952psmp4j3pkdj0yrfxah3l2dawg5s4hdr228n5pjqc";

     

       46
       46
       +
                 sha256 = "fbfc1ef194f4e7a4c0da8c11cc69b17458a4b928b609b3622c97acc4acd5c5ab";

     

       46
       47
        
               };

     

       47
       48
        
               exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";

     

       48
       49
        
               archSpecificLibraries = [

     
···

       55
       56
        
             x86_64-linux = {

     

       56
       57
        
               src = {

     

       57
       58
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-deb10-linux.tar.xz";

     

       58
       58
       -
                 sha256 = "11v76wgljyszc6mgz6r16i6wkifgl15a26q7ablihp2cr8h3qqmw";

     

       59
       59
       +
                 sha256 = "a13719bca87a0d3ac0c7d4157a4e60887009a7f1a8dbe95c4759ec413e086d30";

     

       59
       60
        
               };

     

       60
       61
        
               exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";

     

       61
       62
        
               archSpecificLibraries = [

     
···

       65
       66
        
             armv7l-linux = {

     

       66
       67
        
               src = {

     

       67
       68
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-armv7-deb10-linux.tar.xz";

     

       68
       68
       -
                 sha256 = "0v5bvhb2z9j26yr0n9gc4xdq2lm37mr98g62p5z8pqahhhd0s5sn";

     

       69
       69
       +
                 sha256 = "3949c31bdf7d3b4afb765ea8246bca4ca9707c5d988d9961a244f0da100956a2";

     

       69
       70
        
               };

     

       70
       71
        
               exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";

     

       71
       72
        
               archSpecificLibraries = [

     
···

       75
       76
        
             aarch64-linux = {

     

       76
       77
        
               src = {

     

       77
       78
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-deb10-linux.tar.xz";

     

       78
       78
       -
                 sha256 = "1p0dgyn1m2nd8ax1g25lchaz9z2nk9jvyzf63biarq7qlzc5q24s";

     

       79
       79
       +
                 sha256 = "fad2417f9b295233bf8ade79c0e6140896359e87be46cb61cd1d35863d9d0e55";

     

       79
       80
        
               };

     

       80
       81
        
               exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";

     

       81
       82
        
               archSpecificLibraries = [

     
···

       86
       87
        
             x86_64-darwin = {

     

       87
       88
        
               src = {

     

       88
       89
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";

     

       89
       89
       -
                 sha256 = "08javwfqd21kglbr1bnhnbjw2cggz1n668vi8kx5hbcnz3plf3zg";

     

       90
       90
       +
                 sha256 = "287db0f9c338c9f53123bfa8731b0996803ee50f6ee847fe388092e5e5132047";

     

       90
       91
        
               };

     

       91
       92
        
               exePathForLibraryCheck = null; # we don't have a library check for darwin yet

     

       92
       93
        
               archSpecificLibraries = [

     
···

       97
       98
        
             aarch64-darwin = {

     

       98
       99
        
               src = {

     

       99
       100
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-apple-darwin.tar.xz";

     

       100
       100
       -
                 sha256 = "02fbcrzcc6m25z3ji867isml38jkg4blry70ljwl3l03zxq4ws03";

     

       101
       101
       +
                 sha256 = "dc469fc3c35fd2a33a5a575ffce87f13de7b98c2d349a41002e200a56d9bba1c";

     

       101
       102
        
               };

     

       102
       103
        
               exePathForLibraryCheck = null; # we don't have a library check for darwin yet

     

       103
       104
        
               archSpecificLibraries = [

     
···

       111
       112
        
             x86_64-linux = {

     

       112
       113
        
               src = {

     

       113
       114
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-alpine3.10-linux-integer-simple.tar.xz";

     

       114
       114
       -
                 sha256 = "1ql2qxywbbv0b9syvrm9kyh5d8midnl676lw4698ajras6gcvmzl";

     

       115
       115
       +
                 sha256 = "16903df850ef73d5246f2ff169cbf57ecab76c2ac5acfa9928934282cfad575c";

     

       115
       116
        
               };

     

       116
       117
        
               exePathForLibraryCheck = "bin/ghc";

     

       117
       118
        
               archSpecificLibraries = [

+7 -3

pkgs/development/compilers/ghc/8.10.6.nix pkgs/development/compilers/ghc/8.10.7.nix

···

       137
       137
        
       

     

       138
       138
        
       in

     

       139
       139
        
       stdenv.mkDerivation (rec {

     

       140
       140
       -
         version = "8.10.6";

     

       140
       140
       +
         version = "8.10.7";

     

       141
       141
        
         name = "${targetPrefix}ghc-${version}";

     

       142
       142
        
       

     

       143
       143
        
         src = fetchurl {

     

       144
       144
        
           url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";

     

       145
       145
       -
           sha256 = "43afba72a533408b42c1492bd047b5e37e5f7204e41a5cedd3182cc841610ce9";

     

       145
       145
       +
           sha256 = "e3eef6229ce9908dfe1ea41436befb0455fefb1932559e860ad4c606b0d03c9d";

     

       146
       146
        
         };

     

       147
       147
        
       

     

       148
       148
        
         enableParallelBuilding = true;

     
···

       285
       285
        
           # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580

     

       286
       286
        
           ++ lib.optional stdenv.targetPlatform.isMusl "pie";

     

       287
       287
        
       

     

       288
       288
       +
         # big-parallel allows us to build with more than 2 cores on

     

       289
       289
       +
         # Hydra which already warrants a significant speedup

     

       290
       290
       +
         requiredSystemFeatures = [ "big-parallel" ];

     

       291
       291
       +
       

     

       288
       292
        
         postInstall = ''

     

       289
       293
        
           # Install the bash completion file.

     

       290
       294
        
           install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

     
···

       310
       314
        
         meta = {

     

       311
       315
        
           homepage = "http://haskell.org/ghc";

     

       312
       316
        
           description = "The Glasgow Haskell Compiler";

     

       313
       313
       -
           maintainers = with lib.maintainers; [ marcweber andres peti ];

     

       317
       317
       +
           maintainers = with lib.maintainers; [ marcweber andres peti guibou ];

     

       314
       318
        
           timeout = 24 * 3600;

     

       315
       319
        
           inherit (ghc.meta) license platforms;

     

       316
       320

pkgs/development/compilers/ghc/8.6.5-binary.nix

···

       192
       192
        
           hydraPlatforms = builtins.filter (p: p != "aarch64-linux") platforms;

     

       193
       193
        
           # build segfaults, use ghc8102Binary which has proper musl support instead

     

       194
       194
        
           broken = stdenv.hostPlatform.isMusl;

     

       195
       195
       +
           maintainers = with lib.maintainers; [ guibou ];

     

       195
       196
        
         };

     

       196
       197
        
       }

+1 -1

pkgs/development/compilers/ghc/8.8.4.nix

···

       317
       317
        
         meta = {

     

       318
       318
        
           homepage = "http://haskell.org/ghc";

     

       319
       319
        
           description = "The Glasgow Haskell Compiler";

     

       320
       320
       -
           maintainers = with lib.maintainers; [ marcweber andres peti ];

     

       320
       320
       +
           maintainers = with lib.maintainers; [ marcweber andres peti guibou ];

     

       321
       321
        
           timeout = 24 * 3600;

     

       322
       322
        
           inherit (ghc.meta) license platforms;

     

       323
       323

+5 -1

pkgs/development/compilers/ghc/9.0.1.nix

···

       269
       269
        
           # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580

     

       270
       270
        
           ++ lib.optional stdenv.targetPlatform.isMusl "pie";

     

       271
       271
        
       

     

       272
       272
       +
         # big-parallel allows us to build with more than 2 cores on

     

       273
       273
       +
         # Hydra which already warrants a significant speedup

     

       274
       274
       +
         requiredSystemFeatures = [ "big-parallel" ];

     

       275
       275
       +
       

     

       272
       276
        
         postInstall = ''

     

       273
       277
        
           # Install the bash completion file.

     

       274
       278
        
           install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

     
···

       294
       298
        
         meta = {

     

       295
       299
        
           homepage = "http://haskell.org/ghc";

     

       296
       300
        
           description = "The Glasgow Haskell Compiler";

     

       297
       297
       -
           maintainers = with lib.maintainers; [ marcweber andres peti ];

     

       301
       301
       +
           maintainers = with lib.maintainers; [ marcweber andres peti guibou ];

     

       298
       302
        
           timeout = 24 * 3600;

     

       299
       303
        
           inherit (ghc.meta) license platforms;

     

       300
       304

+320

pkgs/development/compilers/ghc/9.2.1.nix

···

       1
       1
       +
       { lib, stdenv, pkgsBuildTarget, targetPackages

     

       2
       2
       +
       

     

       3
       3
       +
       # build-tools

     

       4
       4
       +
       , bootPkgs

     

       5
       5
       +
       , autoconf, automake, coreutils, fetchurl, perl, python3, m4, sphinx, xattr

     

       6
       6
       +
       , bash

     

       7
       7
       +
       

     

       8
       8
       +
       , libiconv ? null, ncurses

     

       9
       9
       +
       , glibcLocales ? null

     

       10
       10
       +
       

     

       11
       11
       +
       , # GHC can be built with system libffi or a bundled one.

     

       12
       12
       +
         libffi ? null

     

       13
       13
       +
       

     

       14
       14
       +
       , useLLVM ? !stdenv.targetPlatform.isx86

     

       15
       15
       +
       , # LLVM is conceptually a run-time-only depedendency, but for

     

       16
       16
       +
         # non-x86, we need LLVM to bootstrap later stages, so it becomes a

     

       17
       17
       +
         # build-time dependency too.

     

       18
       18
       +
         buildLlvmPackages, llvmPackages

     

       19
       19
       +
       

     

       20
       20
       +
       , # If enabled, GHC will be built with the GPL-free but slower integer-simple

     

       21
       21
       +
         # library instead of the faster but GPLed integer-gmp library.

     

       22
       22
       +
         enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp), gmp

     

       23
       23
       +
       

     

       24
       24
       +
       , # If enabled, use -fPIC when compiling static libs.

     

       25
       25
       +
         enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform

     

       26
       26
       +
       

     

       27
       27
       +
         # aarch64 outputs otherwise exceed 2GB limit

     

       28
       28
       +
       , enableProfiledLibs ? !stdenv.targetPlatform.isAarch64

     

       29
       29
       +
       

     

       30
       30
       +
       , # Whether to build dynamic libs for the standard library (on the target

     

       31
       31
       +
         # platform). Static libs are always built.

     

       32
       32
       +
         enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt

     

       33
       33
       +
       

     

       34
       34
       +
       , # Whether to build terminfo.

     

       35
       35
       +
         enableTerminfo ? !stdenv.targetPlatform.isWindows

     

       36
       36
       +
       

     

       37
       37
       +
       , # What flavour to build. An empty string indicates no

     

       38
       38
       +
         # specific flavour and falls back to ghc default values.

     

       39
       39
       +
         ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)

     

       40
       40
       +
           (if useLLVM then "perf-cross" else "perf-cross-ncg")

     

       41
       41
       +
       

     

       42
       42
       +
       , #  Whether to build sphinx documentation.

     

       43
       43
       +
         enableDocs ? (

     

       44
       44
       +
           # Docs disabled for musl and cross because it's a large task to keep

     

       45
       45
       +
           # all `sphinx` dependencies building in those environments.

     

       46
       46
       +
           # `sphinx` pullls in among others:

     

       47
       47
       +
           # Ruby, Python, Perl, Rust, OpenGL, Xorg, gtk, LLVM.

     

       48
       48
       +
           (stdenv.targetPlatform == stdenv.hostPlatform)

     

       49
       49
       +
           && !stdenv.hostPlatform.isMusl

     

       50
       50
       +
         )

     

       51
       51
       +
       

     

       52
       52
       +
       , enableHaddockProgram ?

     

       53
       53
       +
           # Disabled for cross; see note [HADDOCK_DOCS].

     

       54
       54
       +
           (stdenv.targetPlatform == stdenv.hostPlatform)

     

       55
       55
       +
       

     

       56
       56
       +
       , # Whether to disable the large address space allocator

     

       57
       57
       +
         # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/

     

       58
       58
       +
         disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64

     

       59
       59
       +
       }:

     

       60
       60
       +
       

     

       61
       61
       +
       assert !enableIntegerSimple -> gmp != null;

     

       62
       62
       +
       

     

       63
       63
       +
       # Cross cannot currently build the `haddock` program for silly reasons,

     

       64
       64
       +
       # see note [HADDOCK_DOCS].

     

       65
       65
       +
       assert (stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram;

     

       66
       66
       +
       

     

       67
       67
       +
       let

     

       68
       68
       +
         inherit (stdenv) buildPlatform hostPlatform targetPlatform;

     

       69
       69
       +
       

     

       70
       70
       +
         inherit (bootPkgs) ghc;

     

       71
       71
       +
       

     

       72
       72
       +
         # TODO(@Ericson2314) Make unconditional

     

       73
       73
       +
         targetPrefix = lib.optionalString

     

       74
       74
       +
           (targetPlatform != hostPlatform)

     

       75
       75
       +
           "${targetPlatform.config}-";

     

       76
       76
       +
       

     

       77
       77
       +
         buildMK = ''

     

       78
       78
       +
           BuildFlavour = ${ghcFlavour}

     

       79
       79
       +
           ifneq \"\$(BuildFlavour)\" \"\"

     

       80
       80
       +
           include mk/flavours/\$(BuildFlavour).mk

     

       81
       81
       +
           endif

     

       82
       82
       +
           BUILD_SPHINX_HTML = ${if enableDocs then "YES" else "NO"}

     

       83
       83
       +
           BUILD_SPHINX_PDF = NO

     

       84
       84
       +
         '' +

     

       85
       85
       +
         # Note [HADDOCK_DOCS]:

     

       86
       86
       +
         # Unfortunately currently `HADDOCK_DOCS` controls both whether the `haddock`

     

       87
       87
       +
         # program is built (which we generally always want to have a complete GHC install)

     

       88
       88
       +
         # and whether it is run on the GHC sources to generate hyperlinked source code

     

       89
       89
       +
         # (which is impossible for cross-compilation); see:

     

       90
       90
       +
         # https://gitlab.haskell.org/ghc/ghc/-/issues/20077

     

       91
       91
       +
         # This implies that currently a cross-compiled GHC will never have a `haddock`

     

       92
       92
       +
         # program, so it can never generate haddocks for any packages.

     

       93
       93
       +
         # If this is solved in the future, we'd like to unconditionally

     

       94
       94
       +
         # build the haddock program (removing the `enableHaddockProgram` option).

     

       95
       95
       +
         ''

     

       96
       96
       +
           HADDOCK_DOCS = ${if enableHaddockProgram then "YES" else "NO"}

     

       97
       97
       +
           DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}

     

       98
       98
       +
           INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}

     

       99
       99
       +
         '' + lib.optionalString (targetPlatform != hostPlatform) ''

     

       100
       100
       +
           Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}

     

       101
       101
       +
           CrossCompilePrefix = ${targetPrefix}

     

       102
       102
       +
         '' + lib.optionalString (!enableProfiledLibs) ''

     

       103
       103
       +
           GhcLibWays = "v dyn"

     

       104
       104
       +
         '' + lib.optionalString enableRelocatedStaticLibs ''

     

       105
       105
       +
           GhcLibHcOpts += -fPIC

     

       106
       106
       +
           GhcRtsHcOpts += -fPIC

     

       107
       107
       +
         '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

     

       108
       108
       +
           EXTRA_CC_OPTS += -std=gnu99

     

       109
       109
       +
         '';

     

       110
       110
       +
       

     

       111
       111
       +
         # Splicer will pull out correct variations

     

       112
       112
       +
         libDeps = platform: lib.optional enableTerminfo ncurses

     

       113
       113
       +
           ++ [libffi]

     

       114
       114
       +
           ++ lib.optional (!enableIntegerSimple) gmp

     

       115
       115
       +
           ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;

     

       116
       116
       +
       

     

       117
       117
       +
         toolsForTarget = [

     

       118
       118
       +
           pkgsBuildTarget.targetPackages.stdenv.cc

     

       119
       119
       +
         ] ++ lib.optional useLLVM buildLlvmPackages.llvm;

     

       120
       120
       +
       

     

       121
       121
       +
         targetCC = builtins.head toolsForTarget;

     

       122
       122
       +
       

     

       123
       123
       +
         # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues.

     

       124
       124
       +
         # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856

     

       125
       125
       +
         # see #84670 and #49071 for more background.

     

       126
       126
       +
         useLdGold = targetPlatform.linker == "gold" || (targetPlatform.linker == "bfd" && !targetPlatform.isMusl);

     

       127
       127
       +
       

     

       128
       128
       +
         runtimeDeps = [

     

       129
       129
       +
           targetPackages.stdenv.cc.bintools

     

       130
       130
       +
           coreutils

     

       131
       131
       +
         ]

     

       132
       132
       +
         # On darwin, we need unwrapped bintools as well (for otool)

     

       133
       133
       +
         ++ lib.optionals (stdenv.targetPlatform.linker == "cctools") [

     

       134
       134
       +
           targetPackages.stdenv.cc.bintools.bintools

     

       135
       135
       +
         ];

     

       136
       136
       +
       

     

       137
       137
       +
       in

     

       138
       138
       +
       stdenv.mkDerivation (rec {

     

       139
       139
       +
         version = "9.2.0.20210821";

     

       140
       140
       +
         name = "${targetPrefix}ghc-${version}";

     

       141
       141
       +
       

     

       142
       142
       +
         src = fetchurl {

     

       143
       143
       +
           url = "https://downloads.haskell.org/ghc/9.2.1-rc1/ghc-${version}-src.tar.xz";

     

       144
       144
       +
           sha256 = "1q2pppxv2avhykyxvyq72r5p97rkkiqp19b77yhp85ralbcp4ivw";

     

       145
       145
       +
         };

     

       146
       146
       +
       

     

       147
       147
       +
         enableParallelBuilding = true;

     

       148
       148
       +
       

     

       149
       149
       +
         outputs = [ "out" "doc" ];

     

       150
       150
       +
       

     

       151
       151
       +
         postPatch = "patchShebangs .";

     

       152
       152
       +
       

     

       153
       153
       +
         # GHC needs the locale configured during the Haddock phase.

     

       154
       154
       +
         LANG = "en_US.UTF-8";

     

       155
       155
       +
       

     

       156
       156
       +
         # GHC is a bit confused on its cross terminology.

     

       157
       157
       +
         preConfigure = ''

     

       158
       158
       +
           for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do

     

       159
       159
       +
             export "''${env#TARGET_}=''${!env}"

     

       160
       160
       +
           done

     

       161
       161
       +
           # GHC is a bit confused on its cross terminology, as these would normally be

     

       162
       162
       +
           # the *host* tools.

     

       163
       163
       +
           export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

     

       164
       164
       +
           export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

     

       165
       165
       +
           # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

     

       166
       166
       +
           export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"

     

       167
       167
       +
           export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

     

       168
       168
       +
           export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

     

       169
       169
       +
           export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

     

       170
       170
       +
           export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"

     

       171
       171
       +
           export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"

     

       172
       172
       +
           export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"

     

       173
       173
       +
       

     

       174
       174
       +
           echo -n "${buildMK}" > mk/build.mk

     

       175
       175
       +
           sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure

     

       176
       176
       +
         '' + lib.optionalString (stdenv.isLinux && hostPlatform.libc == "glibc") ''

     

       177
       177
       +
           export LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive"

     

       178
       178
       +
         '' + lib.optionalString (!stdenv.isDarwin) ''

     

       179
       179
       +
           export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"

     

       180
       180
       +
         '' + lib.optionalString stdenv.isDarwin ''

     

       181
       181
       +
           export NIX_LDFLAGS+=" -no_dtrace_dof"

     

       182
       182
       +
         '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

     

       183
       183
       +
           sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets

     

       184
       184
       +
         '' + lib.optionalString targetPlatform.isMusl ''

     

       185
       185
       +
             echo "patching llvm-targets for musl targets..."

     

       186
       186
       +
             echo "Cloning these existing '*-linux-gnu*' targets:"

     

       187
       187
       +
             grep linux-gnu llvm-targets | sed 's/^/  /'

     

       188
       188
       +
             echo "(go go gadget sed)"

     

       189
       189
       +
             sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets

     

       190
       190
       +
             echo "llvm-targets now contains these '*-linux-musl*' targets:"

     

       191
       191
       +
             grep linux-musl llvm-targets | sed 's/^/  /'

     

       192
       192
       +
       

     

       193
       193
       +
             echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"

     

       194
       194
       +
             # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)

     

       195
       195
       +
             for x in configure aclocal.m4; do

     

       196
       196
       +
               substituteInPlace $x \

     

       197
       197
       +
                 --replace '*-android*|*-gnueabi*)' \

     

       198
       198
       +
                           '*-android*|*-gnueabi*|*-musleabi*)'

     

       199
       199
       +
             done

     

       200
       200
       +
         '';

     

       201
       201
       +
       

     

       202
       202
       +
         # TODO(@Ericson2314): Always pass "--target" and always prefix.

     

       203
       203
       +
         configurePlatforms = [ "build" "host" ]

     

       204
       204
       +
           ++ lib.optional (targetPlatform != hostPlatform) "target";

     

       205
       205
       +
       

     

       206
       206
       +
         # `--with` flags for libraries needed for RTS linker

     

       207
       207
       +
         configureFlags = [

     

       208
       208
       +
           "--datadir=$doc/share/doc/ghc"

     

       209
       209
       +
           "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"

     

       210
       210
       +
         ] ++ lib.optionals (libffi != null) [

     

       211
       211
       +
           "--with-system-libffi"

     

       212
       212
       +
           "--with-ffi-includes=${targetPackages.libffi.dev}/include"

     

       213
       213
       +
           "--with-ffi-libraries=${targetPackages.libffi.out}/lib"

     

       214
       214
       +
         ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [

     

       215
       215
       +
           "--with-gmp-includes=${targetPackages.gmp.dev}/include"

     

       216
       216
       +
           "--with-gmp-libraries=${targetPackages.gmp.out}/lib"

     

       217
       217
       +
         ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [

     

       218
       218
       +
           "--with-iconv-includes=${libiconv}/include"

     

       219
       219
       +
           "--with-iconv-libraries=${libiconv}/lib"

     

       220
       220
       +
         ] ++ lib.optionals (targetPlatform != hostPlatform) [

     

       221
       221
       +
           "--enable-bootstrap-with-devel-snapshot"

     

       222
       222
       +
         ] ++ lib.optionals useLdGold [

     

       223
       223
       +
           "CFLAGS=-fuse-ld=gold"

     

       224
       224
       +
           "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

     

       225
       225
       +
           "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

     

       226
       226
       +
         ] ++ lib.optionals (disableLargeAddressSpace) [

     

       227
       227
       +
           "--disable-large-address-space"

     

       228
       228
       +
         ];

     

       229
       229
       +
       

     

       230
       230
       +
         # Make sure we never relax`$PATH` and hooks support for compatibility.

     

       231
       231
       +
         strictDeps = true;

     

       232
       232
       +
       

     

       233
       233
       +
         # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.

     

       234
       234
       +
         dontAddExtraLibs = true;

     

       235
       235
       +
       

     

       236
       236
       +
         nativeBuildInputs = [

     

       237
       237
       +
           perl autoconf automake m4 python3

     

       238
       238
       +
           ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

     

       239
       239
       +
         ] ++ lib.optionals enableDocs [

     

       240
       240
       +
           sphinx

     

       241
       241
       +
         ] ++ lib.optionals stdenv.isDarwin [

     

       242
       242
       +
           # TODO(@sternenseemann): use XATTR env var after backport of

     

       243
       243
       +
           # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/6447

     

       244
       244
       +
           xattr

     

       245
       245
       +
         ];

     

       246
       246
       +
       

     

       247
       247
       +
         # For building runtime libs

     

       248
       248
       +
         depsBuildTarget = toolsForTarget;

     

       249
       249
       +
       

     

       250
       250
       +
         buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

     

       251
       251
       +
       

     

       252
       252
       +
         propagatedBuildInputs = [ targetPackages.stdenv.cc ]

     

       253
       253
       +
           ++ lib.optional useLLVM llvmPackages.llvm;

     

       254
       254
       +
       

     

       255
       255
       +
         depsTargetTarget = map lib.getDev (libDeps targetPlatform);

     

       256
       256
       +
         depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);

     

       257
       257
       +
       

     

       258
       258
       +
         # required, because otherwise all symbols from HSffi.o are stripped, and

     

       259
       259
       +
         # that in turn causes GHCi to abort

     

       260
       260
       +
         stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";

     

       261
       261
       +
       

     

       262
       262
       +
         checkTarget = "test";

     

       263
       263
       +
       

     

       264
       264
       +
         hardeningDisable =

     

       265
       265
       +
           [ "format" ]

     

       266
       266
       +
           # In nixpkgs, musl based builds currently enable `pie` hardening by default

     

       267
       267
       +
           # (see `defaultHardeningFlags` in `make-derivation.nix`).

     

       268
       268
       +
           # But GHC cannot currently produce outputs that are ready for `-pie` linking.

     

       269
       269
       +
           # Thus, disable `pie` hardening, otherwise `recompile with -fPIE` errors appear.

     

       270
       270
       +
           # See:

     

       271
       271
       +
           # * https://github.com/NixOS/nixpkgs/issues/129247

     

       272
       272
       +
           # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580

     

       273
       273
       +
           ++ lib.optional stdenv.targetPlatform.isMusl "pie";

     

       274
       274
       +
       

     

       275
       275
       +
         # big-parallel allows us to build with more than 2 cores on

     

       276
       276
       +
         # Hydra which already warrants a significant speedup

     

       277
       277
       +
         requiredSystemFeatures = [ "big-parallel" ];

     

       278
       278
       +
       

     

       279
       279
       +
         postInstall = ''

     

       280
       280
       +
           # Install the bash completion file.

     

       281
       281
       +
           install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

     

       282
       282
       +
       

     

       283
       283
       +
           # Patch scripts to include "readelf" and "cat" in $PATH.

     

       284
       284
       +
           for i in "$out/bin/"*; do

     

       285
       285
       +
             test ! -h $i || continue

     

       286
       286
       +
             egrep --quiet '^#!' <(head -n 1 $i) || continue

     

       287
       287
       +
             sed -i -e '2i export PATH="$PATH:${lib.makeBinPath runtimeDeps}"' $i

     

       288
       288
       +
           done

     

       289
       289
       +
         '';

     

       290
       290
       +
       

     

       291
       291
       +
         passthru = {

     

       292
       292
       +
           inherit bootPkgs targetPrefix;

     

       293
       293
       +
       

     

       294
       294
       +
           inherit llvmPackages;

     

       295
       295
       +
           inherit enableShared;

     

       296
       296
       +
       

     

       297
       297
       +
           # Our Cabal compiler name

     

       298
       298
       +
           haskellCompilerName = "ghc-${version}";

     

       299
       299
       +
         };

     

       300
       300
       +
       

     

       301
       301
       +
         meta = {

     

       302
       302
       +
           homepage = "http://haskell.org/ghc";

     

       303
       303
       +
           description = "The Glasgow Haskell Compiler";

     

       304
       304
       +
           maintainers = with lib.maintainers; [ marcweber andres peti guibou ];

     

       305
       305
       +
           timeout = 24 * 3600;

     

       306
       306
       +
           inherit (ghc.meta) license platforms;

     

       307
       307
       +
       

     

       308
       308
       +
           # integer-simple builds are broken when GHC links against musl.

     

       309
       309
       +
           # See https://github.com/NixOS/nixpkgs/pull/129606#issuecomment-881323743.

     

       310
       310
       +
           # Linker failure on macOS:

     

       311
       311
       +
           # https://gitlab.haskell.org/ghc/ghc/-/issues/19950#note_373726

     

       312
       312
       +
           broken = (enableIntegerSimple && hostPlatform.isMusl)

     

       313
       313
       +
             || stdenv.hostPlatform.isDarwin;

     

       314
       314
       +
         };

     

       315
       315
       +
       

     

       316
       316
       +
       } // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

     

       317
       317
       +
         dontStrip = true;

     

       318
       318
       +
         dontPatchELF = true;

     

       319
       319
       +
         noAuditTmpdir = true;

     

       320
       320
       +
       })

+10 -2

pkgs/development/compilers/ghc/head.nix

···

       2
       2
        
       

     

       3
       3
        
       # build-tools

     

       4
       4
        
       , bootPkgs

     

       5
       5
       -
       , autoconf, autoreconfHook, automake, coreutils, fetchgit, perl, python3, m4, sphinx

     

       5
       5
       +
       , autoconf, autoreconfHook, automake, coreutils, fetchgit, perl, python3, m4, sphinx, xattr

     

       6
       6
        
       , bash

     

       7
       7
        
       

     

       8
       8
        
       , libiconv ? null, ncurses

     
···

       256
       256
        
           ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

     

       257
       257
        
         ] ++ lib.optionals enableDocs [

     

       258
       258
        
           sphinx

     

       259
       259
       +
         ] ++ lib.optionals stdenv.isDarwin [

     

       260
       260
       +
           # TODO(@sternenseemann): use XATTR env var once we have

     

       261
       261
       +
           # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/6447

     

       262
       262
       +
           xattr

     

       259
       263
        
         ];

     

       260
       264
        
       

     

       261
       265
        
         # For building runtime libs

     
···

       286
       290
        
           # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580

     

       287
       291
        
           ++ lib.optional stdenv.targetPlatform.isMusl "pie";

     

       288
       292
        
       

     

       293
       293
       +
         # big-parallel allows us to build with more than 2 cores on

     

       294
       294
       +
         # Hydra which already warrants a significant speedup

     

       295
       295
       +
         requiredSystemFeatures = [ "big-parallel" ];

     

       296
       296
       +
       

     

       289
       297
        
         postInstall = ''

     

       290
       298
        
           # Install the bash completion file.

     

       291
       299
        
           install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

     
···

       311
       319
        
         meta = {

     

       312
       320
        
           homepage = "http://haskell.org/ghc";

     

       313
       321
        
           description = "The Glasgow Haskell Compiler";

     

       314
       314
       -
           maintainers = with lib.maintainers; [ marcweber andres peti ];

     

       322
       322
       +
           maintainers = with lib.maintainers; [ marcweber andres peti guibou ];

     

       315
       323
        
           timeout = 24 * 3600;

     

       316
       324
        
           inherit (ghc.meta) license platforms;

     

       317
       325
        
           # ghcHEAD times out on aarch64-linux on Hydra.

+3 -3

pkgs/development/haskell-modules/cabal2nix-unstable.nix

···

       8
       8
        
       }:

     

       9
       9
        
       mkDerivation {

     

       10
       10
        
         pname = "cabal2nix";

     

       11
       11
       -
         version = "unstable-2021-08-21";

     

       11
       11
       +
         version = "unstable-2021-08-27";

     

       12
       12
        
         src = fetchzip {

     

       13
       13
       -
           url = "https://github.com/NixOS/cabal2nix/archive/51a4082fefad4642af67a0ae4bf3bb3a7d9b45e0.tar.gz";

     

       14
       14
       -
           sha256 = "1qd991ziv54drb0n655dg4ymknlfa0ndx9nq9wb5v00a15i4c04x";

     

       13
       13
       +
           url = "https://github.com/NixOS/cabal2nix/archive/05b1b404e20eb6252f93c821d4d7974ab7277d90.tar.gz";

     

       14
       14
       +
           sha256 = "03zvp3wwqph9niadgbvkfcqabafgyhnw12r09cw23hm69hsb64d5";

     

       15
       15
        
         };

     

       16
       16
        
         isLibrary = true;

     

       17
       17
        
         isExecutable = true;

+8 -8

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

···

       120
       120
        
         # Jailbreak is necessary for QuickCheck dependency.

     

       121
       121
        
         vector = doJailbreak (if pkgs.stdenv.isi686 then appendConfigureFlag super.vector "--ghc-options=-msse2" else super.vector);

     

       122
       122
        
       

     

       123
       123
       -
         # Test suite fails due golden tests checking text representation

     

       124
       124
       -
         # of normalized dhall expressions, and newer dhall versions format

     

       125
       125
       -
         # differently.

     

       126
       126
       -
         hpack-dhall =

     

       127
       127
       -
           if pkgs.lib.versionOlder "0.5.2" super.hpack-dhall.version

     

       128
       128
       -
           then throw "Drop dontCheck override for hpack-dhall > 0.5.2"

     

       129
       129
       -
           else dontCheck super.hpack-dhall;

     

       130
       130
       -
       

     

       131
       123
        
         inline-c-cpp = overrideCabal super.inline-c-cpp (drv: {

     

       132
       124
        
           postPatch = (drv.postPatch or "") + ''

     

       133
       125
        
             substituteInPlace inline-c-cpp.cabal --replace "-optc-std=c++11" ""

     
···

       1957
       1949
        
       

     

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

     

       1959
       1951
        
         streamly-posix = doJailbreak super.streamly-posix;

     

       1952
       1952
       +
       

     

       1953
       1953
       +
         distribution-nixpkgs = assert super.distribution-nixpkgs.version == "1.6.0";

     

       1954
       1954
       +
           overrideCabal super.distribution-nixpkgs {

     

       1955
       1955
       +
             version = "1.6.1";

     

       1956
       1956
       +
             revision = null;

     

       1957
       1957
       +
             sha256 = "136q893in07iw53m9pqr65h3mrnpvfda272bl4rq1b0z3hzpyhkm";

     

       1958
       1958
       +
             editedCabalFile = null;

     

       1959
       1959
       +
           };

     

       1960
       1960
        
       

     

       1961
       1961
        
       } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

+10 -2

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

···

       8
       8
        
       

     

       9
       9
        
       with haskellLib;

     

       10
       10
        
       

     

       11
       11
       -
       self: super: {

     

       11
       11
       +
       self: super: ({

     

       12
       12
        
       

     

       13
       13
        
         # the tests for shell-conduit on Darwin illegitimatey assume non-GNU echo

     

       14
       14
        
         # see: https://github.com/psibi/shell-conduit/issues/12

     
···

       196
       196
        
         hls-ormolu-plugin = dontCheck super.hls-ormolu-plugin;

     

       197
       197
        
         hls-pragmas-plugin = dontCheck super.hls-pragmas-plugin;

     

       198
       198
        
         hls-haddock-comments-plugin = dontCheck super.hls-haddock-comments-plugin;

     

       199
       199
       +
         hls-floskell-plugin = dontCheck super.hls-floskell-plugin;

     

       199
       200
        
       

     

       200
       201
        
         # We are lacking pure pgrep at the moment for tests to work

     

       201
       202
        
         tmp-postgres = dontCheck super.tmp-postgres;

     
···

       252
       253
        
         # Otherwise impure gcc is used, which is Apple's weird wrapper

     

       253
       254
        
         c2hsc = addTestToolDepends super.c2hsc [ pkgs.gcc ];

     

       254
       255
        
       

     

       255
       255
       -
       }

     

       256
       256
       +
       } // lib.optionalAttrs pkgs.stdenv.isAarch64 {  # aarch64-darwin

     

       257
       257
       +
       

     

       258
       258
       +
         # https://github.com/fpco/unliftio/issues/87

     

       259
       259
       +
         unliftio = dontCheck super.unliftio;

     

       260
       260
       +
       

     

       261
       261
       +
         # https://github.com/fpco/inline-c/issues/127

     

       262
       262
       +
         inline-c-cpp = dontCheck super.inline-c-cpp;

     

       263
       263
       +
       })

+115

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

···

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
       +
       

     

       3
       3
       +
       with haskellLib;

     

       4
       4
       +
       

     

       5
       5
       +
       self: super: {

     

       6
       6
       +
       

     

       7
       7
       +
         # This compiler version needs llvm 10.x.

     

       8
       8
       +
         llvmPackages = pkgs.lib.dontRecurseIntoAttrs pkgs.llvmPackages_10;

     

       9
       9
       +
       

     

       10
       10
       +
         # Disable GHC 9.2.x core libraries.

     

       11
       11
       +
         array = null;

     

       12
       12
       +
         base = null;

     

       13
       13
       +
         binary = null;

     

       14
       14
       +
         bytestring = null;

     

       15
       15
       +
         Cabal = null;

     

       16
       16
       +
         containers = null;

     

       17
       17
       +
         deepseq = null;

     

       18
       18
       +
         directory = null;

     

       19
       19
       +
         exceptions = null;

     

       20
       20
       +
         filepath = null;

     

       21
       21
       +
         ghc-bignum = null;

     

       22
       22
       +
         ghc-boot = null;

     

       23
       23
       +
         ghc-boot-th = null;

     

       24
       24
       +
         ghc-compact = null;

     

       25
       25
       +
         ghc-heap = null;

     

       26
       26
       +
         ghc-prim = null;

     

       27
       27
       +
         ghci = null;

     

       28
       28
       +
         haskeline = null;

     

       29
       29
       +
         hpc = null;

     

       30
       30
       +
         integer-gmp = null;

     

       31
       31
       +
         libiserv = null;

     

       32
       32
       +
         mtl = null;

     

       33
       33
       +
         parsec = null;

     

       34
       34
       +
         pretty = null;

     

       35
       35
       +
         process = null;

     

       36
       36
       +
         rts = null;

     

       37
       37
       +
         stm = null;

     

       38
       38
       +
         template-haskell = null;

     

       39
       39
       +
         terminfo = null;

     

       40
       40
       +
         text = null;

     

       41
       41
       +
         time = null;

     

       42
       42
       +
         transformers = null;

     

       43
       43
       +
         unix = null;

     

       44
       44
       +
         xhtml = null;

     

       45
       45
       +
       

     

       46
       46
       +
         # cabal-install needs more recent versions of Cabal and base16-bytestring.

     

       47
       47
       +
         cabal-install = (doJailbreak super.cabal-install).overrideScope (self: super: {

     

       48
       48
       +
           Cabal = null;

     

       49
       49
       +
           base16-bytestring = self.base16-bytestring_0_1_1_7;

     

       50
       50
       +
         });

     

       51
       51
       +
       

     

       52
       52
       +
         # Jailbreaks & Version Updates

     

       53
       53
       +
         async = doJailbreak super.async;

     

       54
       54
       +
         ChasingBottoms = markBrokenVersion "1.3.1.9" super.ChasingBottoms;

     

       55
       55
       +
         data-fix = doJailbreak super.data-fix;

     

       56
       56
       +
         dec = doJailbreak super.dec;

     

       57
       57
       +
         ed25519 = doJailbreak super.ed25519;

     

       58
       58
       +
         hackage-security = doJailbreak super.hackage-security;

     

       59
       59
       +
         hashable = overrideCabal (doJailbreak (dontCheck super.hashable)) (drv: { postPatch = "sed -i -e 's,integer-gmp .*<1.1,integer-gmp < 2,' hashable.cabal"; });

     

       60
       60
       +
         hashable-time = doJailbreak super.hashable-time;

     

       61
       61
       +
         HTTP = overrideCabal (doJailbreak super.HTTP) (drv: { postPatch = "sed -i -e 's,! Socket,!Socket,' Network/TCP.hs"; });

     

       62
       62
       +
         integer-logarithms = overrideCabal (doJailbreak super.integer-logarithms) (drv: { postPatch = "sed -i -e 's,integer-gmp <1.1,integer-gmp < 2,' integer-logarithms.cabal"; });

     

       63
       63
       +
         lukko = doJailbreak super.lukko;

     

       64
       64
       +
         parallel = doJailbreak super.parallel;

     

       65
       65
       +
         primitive = doJailbreak (dontCheck super.primitive);

     

       66
       66
       +
         regex-posix = doJailbreak super.regex-posix;

     

       67
       67
       +
         resolv = doJailbreak super.resolv;

     

       68
       68
       +
         singleton-bool = doJailbreak super.singleton-bool;

     

       69
       69
       +
         split = doJailbreak super.split;

     

       70
       70
       +
         tar = doJailbreak super.tar;

     

       71
       71
       +
         time-compat = doJailbreak super.time-compat;

     

       72
       72
       +
         vector = doJailbreak (dontCheck super.vector);

     

       73
       73
       +
         vector-binary-instances = doJailbreak super.vector-binary-instances;

     

       74
       74
       +
         vector-th-unbox = doJailbreak super.vector-th-unbox;

     

       75
       75
       +
         zlib = doJailbreak super.zlib;

     

       76
       76
       +
       

     

       77
       77
       +
         # Apply patches from head.hackage.

     

       78
       78
       +
         alex = appendPatch (dontCheck super.alex) (pkgs.fetchpatch {

     

       79
       79
       +
           url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/fe192e12b88b09499d4aff0e562713e820544bd6/patches/alex-3.2.6.patch";

     

       80
       80
       +
           sha256 = "1rzs764a0nhx002v4fadbys98s6qblw4kx4g46galzjf5f7n2dn4";

     

       81
       81
       +
         });

     

       82
       82
       +
         doctest = dontCheck (doJailbreak super.doctest_0_18_1);

     

       83
       83
       +
         language-haskell-extract = appendPatch (doJailbreak super.language-haskell-extract) (pkgs.fetchpatch {

     

       84
       84
       +
           url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/language-haskell-extract-0.2.4.patch";

     

       85
       85
       +
           sha256 = "0rgzrq0513nlc1vw7nw4km4bcwn4ivxcgi33jly4a7n3c1r32v1f";

     

       86
       86
       +
         });

     

       87
       87
       +
       

     

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

     

       89
       89
       +
         unordered-containers = dontCheck super.unordered-containers;

     

       90
       90
       +
       

     

       91
       91
       +
         # The test suite seems pretty broken.

     

       92
       92
       +
         base64-bytestring = dontCheck super.base64-bytestring;

     

       93
       93
       +
       

     

       94
       94
       +
         # 5 introduced support for GHC 9.0.x, but hasn't landed in stackage yet

     

       95
       95
       +
         lens = super.lens_5_0_1;

     

       96
       96
       +
       

     

       97
       97
       +
         # 0.16.0 introduced support for GHC 9.0.x, stackage has 0.15.0

     

       98
       98
       +
         memory = super.memory_0_16_0;

     

       99
       99
       +
       

     

       100
       100
       +
         # GHC 9.0.x doesn't like `import Spec (main)` in Main.hs

     

       101
       101
       +
         # https://github.com/snoyberg/mono-traversable/issues/192

     

       102
       102
       +
         mono-traversable = dontCheck super.mono-traversable;

     

       103
       103
       +
       

     

       104
       104
       +
         # Disable tests pending resolution of

     

       105
       105
       +
         # https://github.com/Soostone/retry/issues/71

     

       106
       106
       +
         retry = dontCheck super.retry;

     

       107
       107
       +
       

     

       108
       108
       +
         # hlint 3.3 needs a ghc-lib-parser newer than the one from stackage

     

       109
       109
       +
         hlint = super.hlint_3_3_1.overrideScope (self: super: {

     

       110
       110
       +
           ghc-lib-parser = overrideCabal self.ghc-lib-parser_9_0_1_20210324 {

     

       111
       111
       +
             doHaddock = false;

     

       112
       112
       +
           };

     

       113
       113
       +
           ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_0_0_4;

     

       114
       114
       +
         });

     

       115
       115
       +
       }

+5 -2

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

···

       632
       632
        
         - cio

     

       633
       633
        
         - cipher-blowfish

     

       634
       634
        
         - circlehs

     

       635
       635
       -
         - circular

     

       636
       635
        
         - citeproc-hs

     

       637
       636
        
         - cjk

     

       638
       637
        
         - cj-token

     
···

       1021
       1020
        
         - dgim

     

       1022
       1021
        
         - dgs

     

       1023
       1022
        
         - dhall-check

     

       1023
       1023
       +
         - dhall-csv

     

       1024
       1024
        
         - dhall-fly

     

       1025
       1025
        
         - dhall-text

     

       1026
       1026
        
         - dhall-to-cabal

     

       1027
       1027
       +
         - dhall-toml

     

       1027
       1028
        
         - dhcp-lease-parser

     

       1028
       1029
        
         - dhrun

     

       1029
       1030
        
         - dia-base

     
···

       2535
       2536
        
         - IsNull

     

       2536
       2537
        
         - iso8601-duration

     

       2537
       2538
        
         - isobmff

     

       2539
       2539
       +
         - isocline

     

       2538
       2540
        
         - isotope

     

       2539
       2541
        
         - itcli

     

       2540
       2542
        
         - itemfield

     
···

       3194
       3196
        
         - nanomsg-haskell

     

       3195
       3197
        
         - nanoparsec

     

       3196
       3198
        
         - NanoProlog

     

       3197
       3197
       -
         - nanovg

     

       3198
       3199
        
         - nanq

     

       3199
       3200
        
         - naperian

     

       3200
       3201
        
         - naqsha

     
···

       4802
       4803
        
         - th-traced

     

       4803
       4804
        
         - thumbnail-plus

     

       4804
       4805
        
         - tianbar

     

       4806
       4806
       +
         - ticket-management

     

       4805
       4807
        
         - TicTacToe

     

       4806
       4808
        
         - tictactoe3d

     

       4807
       4809
        
         - tidal-midi

     
···

       5329
       5331
        
         - yandex-translate

     

       5330
       5332
        
         - yaop

     

       5331
       5333
        
         - yap

     

       5334
       5334
       +
         - yapb

     

       5332
       5335
        
         - yarr

     

       5333
       5336
        
         - yaya-test

     

       5334
       5337
        
         - yaya-unsafe-test

+111 -110

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

···

       63
       63
        
       # available on Hackage, `hackage2nix` would generate two packages, `aeson`

     

       64
       64
        
       # at version 1.4.6.0 and `aeson_1_5_0_0` at version 1.5.0.0.

     

       65
       65
        
       #

     

       66
       66
       -
       # WARNING: This list is generated semiautomatically based on the most recent

     

       67
       67
       -
       # LTS package set. If you want to add entries to it, you must do so before the

     

       68
       68
       -
       # comment saying "# LTS Haskell x.y". Any changes after that comment will be

     

       69
       69
       -
       # lost the next time `update-stackage.sh` runs.

     

       66
       66
       +
       # WARNING: We import a list of default-package-overrides from stackage which is

     

       67
       67
       +
       # tracked in stackage.yaml. Adding conflicting overrides with stackage here will

     

       68
       68
       +
       # not work.

     

       70
       69
        
       default-package-overrides:

     

       71
       70
        
         # This was only intended for ghc-7.0.4, and has very old deps, one hidden behind a flag

     

       72
       71
        
         - MissingH ==1.4.2.0

     
···

       91
       90
        
         - streamly-bytestring < 0.1.3

     

       92
       91
        
         - streamly-lmdb < 0.3.0

     

       93
       92
        
         - streamly-process

     

       93
       93
       +
         # dhall-nix is not part of stackage, remove if dhall >= 1.40

     

       94
       94
       +
         - dhall-nix < 1.1.22

     

       94
       95
        
       

     

       95
       96
        
       extra-packages:

     

       96
       97
        
         - base16-bytestring < 1               # required for cabal-install etc.

     
···

       337
       338
        
           - nix-tree

     

       338
       339
        
       

     

       339
       340
        
       unsupported-platforms:

     

       340
       340
       -
         Allure:                                       [ x86_64-darwin ]

     

       341
       341
       -
         alsa-mixer:                                   [ x86_64-darwin ]

     

       342
       342
       -
         alsa-pcm:                                     [ x86_64-darwin ]

     

       343
       343
       -
         alsa-seq:                                     [ x86_64-darwin ]

     

       344
       344
       -
         AWin32Console:                                [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       341
       341
       +
         Allure:                                       [ x86_64-darwin, aarch64-darwin ]

     

       342
       342
       +
         alsa-mixer:                                   [ x86_64-darwin, aarch64-darwin ]

     

       343
       343
       +
         alsa-pcm:                                     [ x86_64-darwin, aarch64-darwin ]

     

       344
       344
       +
         alsa-seq:                                     [ x86_64-darwin, aarch64-darwin ]

     

       345
       345
       +
         AWin32Console:                                [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       345
       346
        
         barbly:                                       [ i686-linux, x86_64-linux, aarch64-linux, armv7l-linux ]

     

       346
       346
       -
         bdcs-api:                                     [ x86_64-darwin ]

     

       347
       347
       -
         bindings-directfb:                            [ x86_64-darwin ]

     

       348
       348
       -
         bindings-parport:                             [ x86_64-darwin ] # parport is a linux kernel component

     

       349
       349
       -
         bindings-sane:                                [ x86_64-darwin ]

     

       350
       350
       -
         btrfs:                                        [ x86_64-darwin ] # depends on linux

     

       351
       351
       -
         bustle:                                       [ x86_64-darwin ] # uses glibc-specific ptsname_r

     

       347
       347
       +
         bdcs-api:                                     [ x86_64-darwin, aarch64-darwin ]

     

       348
       348
       +
         bindings-directfb:                            [ x86_64-darwin, aarch64-darwin ]

     

       349
       349
       +
         bindings-parport:                             [ x86_64-darwin, aarch64-darwin ] # parport is a linux kernel component

     

       350
       350
       +
         bindings-sane:                                [ x86_64-darwin, aarch64-darwin ]

     

       351
       351
       +
         btrfs:                                        [ x86_64-darwin, aarch64-darwin ] # depends on linux

     

       352
       352
       +
         bustle:                                       [ x86_64-darwin, aarch64-darwin ] # uses glibc-specific ptsname_r

     

       352
       353
        
         charsetdetect:                                [ aarch64-linux ] # not supported by vendored lib / not configured properly https://github.com/batterseapower/libcharsetdetect/issues/3

     

       353
       354
        
         crackNum:                                     [ aarch64-linux ] # depends on sbv, which is not supported on aarch64-linux

     

       354
       354
       -
         cut-the-crap:                                 [ x86_64-darwin ]

     

       355
       355
       -
         d3d11binding:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       356
       356
       -
         DirectSound:                                  [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       357
       357
       -
         dx9base:                                      [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       358
       358
       -
         dx9d3d:                                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       359
       359
       -
         dx9d3dx:                                      [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       360
       360
       -
         Euterpea:                                     [ x86_64-darwin ]

     

       361
       361
       -
         follow-file:                                  [ x86_64-darwin ]

     

       362
       362
       -
         freenect:                                     [ x86_64-darwin ]

     

       363
       363
       -
         FTGL:                                         [ x86_64-darwin ]

     

       364
       364
       -
         fuzzytime:                                    [ x86_64-darwin ] # https://github.com/kamwitsta/fuzzytime/issues/2

     

       365
       365
       -
         ghcjs-dom-hello:                              [ x86_64-darwin ]

     

       366
       366
       -
         gi-dbusmenugtk3:                              [ x86_64-darwin ]

     

       367
       367
       -
         gi-dbusmenu:                                  [ x86_64-darwin ]

     

       368
       368
       -
         gi-ggit:                                      [ x86_64-darwin ]

     

       369
       369
       -
         gi-ibus:                                      [ x86_64-darwin ]

     

       370
       370
       -
         gi-ostree:                                    [ x86_64-darwin ]

     

       371
       371
       -
         gi-vte:                                       [ x86_64-darwin ]

     

       372
       372
       -
         gi-wnck:                                      [ x86_64-darwin ]

     

       373
       373
       -
         gnome-keyring:                                [ x86_64-darwin ]

     

       355
       355
       +
         cut-the-crap:                                 [ x86_64-darwin, aarch64-darwin ]

     

       356
       356
       +
         d3d11binding:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       357
       357
       +
         DirectSound:                                  [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       358
       358
       +
         dx9base:                                      [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       359
       359
       +
         dx9d3d:                                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       360
       360
       +
         dx9d3dx:                                      [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       361
       361
       +
         Euterpea:                                     [ x86_64-darwin, aarch64-darwin ]

     

       362
       362
       +
         follow-file:                                  [ x86_64-darwin, aarch64-darwin ]

     

       363
       363
       +
         freenect:                                     [ x86_64-darwin, aarch64-darwin ]

     

       364
       364
       +
         FTGL:                                         [ x86_64-darwin, aarch64-darwin ]

     

       365
       365
       +
         fuzzytime:                                    [ x86_64-darwin, aarch64-darwin ] # https://github.com/kamwitsta/fuzzytime/issues/2

     

       366
       366
       +
         ghcjs-dom-hello:                              [ x86_64-darwin, aarch64-darwin ]

     

       367
       367
       +
         gi-dbusmenugtk3:                              [ x86_64-darwin, aarch64-darwin ]

     

       368
       368
       +
         gi-dbusmenu:                                  [ x86_64-darwin, aarch64-darwin ]

     

       369
       369
       +
         gi-ggit:                                      [ x86_64-darwin, aarch64-darwin ]

     

       370
       370
       +
         gi-ibus:                                      [ x86_64-darwin, aarch64-darwin ]

     

       371
       371
       +
         gi-ostree:                                    [ x86_64-darwin, aarch64-darwin ]

     

       372
       372
       +
         gi-vte:                                       [ x86_64-darwin, aarch64-darwin ]

     

       373
       373
       +
         gi-wnck:                                      [ x86_64-darwin, aarch64-darwin ]

     

       374
       374
       +
         gnome-keyring:                                [ x86_64-darwin, aarch64-darwin ]

     

       374
       375
        
         gtk-mac-integration:                          [ i686-linux, x86_64-linux, aarch64-linux, armv7l-linux ]

     

       375
       375
       -
         gtk-sni-tray:                                 [ x86_64-darwin ]

     

       376
       376
       -
         haskell-snake:                                [ x86_64-darwin ]

     

       377
       377
       -
         hcwiid:                                       [ x86_64-darwin ]

     

       376
       376
       +
         gtk-sni-tray:                                 [ x86_64-darwin, aarch64-darwin ]

     

       377
       377
       +
         haskell-snake:                                [ x86_64-darwin, aarch64-darwin ]

     

       378
       378
       +
         hcwiid:                                       [ x86_64-darwin, aarch64-darwin ]

     

       378
       379
        
         hevm:                                         [ aarch64-linux ] # depends on sbv, which is not supported on aarch64-linux

     

       379
       379
       -
         HFuse:                                        [ x86_64-darwin ]

     

       380
       380
       -
         hidapi:                                       [ x86_64-darwin ]

     

       381
       381
       -
         hinotify-bytestring:                          [ x86_64-darwin ]

     

       382
       382
       -
         hommage-ds:                                   [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       383
       383
       -
         honk:                                         [ x86_64-darwin ]

     

       384
       384
       -
         hpapi:                                        [ x86_64-darwin ]

     

       380
       380
       +
         HFuse:                                        [ x86_64-darwin, aarch64-darwin ]

     

       381
       381
       +
         hidapi:                                       [ x86_64-darwin, aarch64-darwin ]

     

       382
       382
       +
         hinotify-bytestring:                          [ x86_64-darwin, aarch64-darwin ]

     

       383
       383
       +
         hommage-ds:                                   [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       384
       384
       +
         honk:                                         [ x86_64-darwin, aarch64-darwin ]

     

       385
       385
       +
         hpapi:                                        [ x86_64-darwin, aarch64-darwin ]

     

       385
       386
        
         HQu:                                          [ aarch64-linux, armv7l-linux ] # unsupported by vendored C++ library, TODO: explicitly list supported platforms

     

       386
       386
       -
         HSoM:                                         [ x86_64-darwin ]

     

       387
       387
       -
         iwlib:                                        [ x86_64-darwin ]

     

       388
       388
       -
         jsaddle-webkit2gtk:                           [ x86_64-darwin ]

     

       387
       387
       +
         HSoM:                                         [ x86_64-darwin, aarch64-darwin ]

     

       388
       388
       +
         iwlib:                                        [ x86_64-darwin, aarch64-darwin ]

     

       389
       389
       +
         jsaddle-webkit2gtk:                           [ x86_64-darwin, aarch64-darwin ]

     

       389
       390
        
         kqueue:                                       [ x86_64-linux, aarch64-linux, i686-linux, armv7l-linux ] # BSD / Darwin only API

     

       390
       390
       -
         LambdaHack:                                   [ x86_64-darwin ]

     

       391
       391
       +
         LambdaHack:                                   [ x86_64-darwin, aarch64-darwin ]

     

       391
       392
        
         large-hashable:                               [ aarch64-linux ] # https://github.com/factisresearch/large-hashable/issues/17

     

       392
       392
       -
         libmodbus:                                    [ x86_64-darwin ]

     

       393
       393
       -
         libsystemd-journal:                           [ x86_64-darwin ]

     

       394
       394
       -
         libtelnet:                                    [ x86_64-darwin ]

     

       395
       395
       -
         libzfs:                                       [ x86_64-darwin ]

     

       393
       393
       +
         libmodbus:                                    [ x86_64-darwin, aarch64-darwin ]

     

       394
       394
       +
         libsystemd-journal:                           [ x86_64-darwin, aarch64-darwin ]

     

       395
       395
       +
         libtelnet:                                    [ x86_64-darwin, aarch64-darwin ]

     

       396
       396
       +
         libzfs:                                       [ x86_64-darwin, aarch64-darwin ]

     

       396
       397
        
         linearEqSolver:                               [ aarch64-linux ]

     

       397
       397
       -
         linux-evdev:                                  [ x86_64-darwin ]

     

       398
       398
       -
         linux-file-extents:                           [ x86_64-darwin ]

     

       399
       399
       -
         linux-inotify:                                [ x86_64-darwin ]

     

       400
       400
       -
         linux-mount:                                  [ x86_64-darwin ]

     

       401
       401
       -
         linux-namespaces:                             [ x86_64-darwin ]

     

       402
       402
       -
         lio-fs:                                       [ x86_64-darwin ]

     

       403
       403
       -
         logging-facade-journald:                      [ x86_64-darwin ]

     

       404
       404
       -
         midi-alsa:                                    [ x86_64-darwin ]

     

       405
       405
       -
         mpi-hs:                                       [ aarch64-linux, x86_64-darwin ]

     

       406
       406
       -
         mpi-hs-binary:                                [ aarch64-linux, x86_64-darwin ]

     

       407
       407
       -
         mpi-hs-cereal:                                [ aarch64-linux, x86_64-darwin ]

     

       408
       408
       -
         mpi-hs-store:                                 [ aarch64-linux, x86_64-darwin ]

     

       398
       398
       +
         linux-evdev:                                  [ x86_64-darwin, aarch64-darwin ]

     

       399
       399
       +
         linux-file-extents:                           [ x86_64-darwin, aarch64-darwin ]

     

       400
       400
       +
         linux-inotify:                                [ x86_64-darwin, aarch64-darwin ]

     

       401
       401
       +
         linux-mount:                                  [ x86_64-darwin, aarch64-darwin ]

     

       402
       402
       +
         linux-namespaces:                             [ x86_64-darwin, aarch64-darwin ]

     

       403
       403
       +
         lio-fs:                                       [ x86_64-darwin, aarch64-darwin ]

     

       404
       404
       +
         logging-facade-journald:                      [ x86_64-darwin, aarch64-darwin ]

     

       405
       405
       +
         midi-alsa:                                    [ x86_64-darwin, aarch64-darwin ]

     

       406
       406
       +
         mpi-hs:                                       [ aarch64-linux, x86_64-darwin, aarch64-darwin ]

     

       407
       407
       +
         mpi-hs-binary:                                [ aarch64-linux, x86_64-darwin, aarch64-darwin ]

     

       408
       408
       +
         mpi-hs-cereal:                                [ aarch64-linux, x86_64-darwin, aarch64-darwin ]

     

       409
       409
       +
         mpi-hs-store:                                 [ aarch64-linux, x86_64-darwin, aarch64-darwin ]

     

       409
       410
        
         mplayer-spot:                                 [ aarch64-linux ]

     

       410
       410
       -
         mptcp-pm:                                     [ x86_64-darwin ]

     

       411
       411
       -
         netlink:                                      [ x86_64-darwin ]

     

       412
       412
       -
         notifications-tray-icon:                      [ x86_64-darwin ] # depends on gi-dbusmenu

     

       413
       413
       -
         oculus:                                       [ x86_64-darwin ]

     

       414
       414
       -
         pam:                                          [ x86_64-darwin ]

     

       415
       415
       -
         parport:                                      [ x86_64-darwin ]

     

       411
       411
       +
         mptcp-pm:                                     [ x86_64-darwin, aarch64-darwin ]

     

       412
       412
       +
         netlink:                                      [ x86_64-darwin, aarch64-darwin ]

     

       413
       413
       +
         notifications-tray-icon:                      [ x86_64-darwin, aarch64-darwin ] # depends on gi-dbusmenu

     

       414
       414
       +
         oculus:                                       [ x86_64-darwin, aarch64-darwin ]

     

       415
       415
       +
         pam:                                          [ x86_64-darwin, aarch64-darwin ]

     

       416
       416
       +
         parport:                                      [ x86_64-darwin, aarch64-darwin ]

     

       416
       417
        
         password:                                     [ aarch64-linux, armv7l-linux ] # uses scrypt, which requries x86

     

       417
       418
        
         password-instances:                           [ aarch64-linux, armv7l-linux ] # uses scrypt, which requries x86

     

       418
       419
        
         persist-state:                                [ aarch64-linux, armv7l-linux ] # https://github.com/minad/persist-state/blob/6fd68c0b8b93dec78218f6d5a1f4fa06ced4e896/src/Data/PersistState.hs#L122-L128

     

       419
       419
       -
         piyo:                                         [ x86_64-darwin ]

     

       420
       420
       -
         PortMidi-simple:                              [ x86_64-darwin ]

     

       421
       421
       -
         PortMidi:                                     [ x86_64-darwin ]

     

       422
       422
       -
         posix-api:                                    [ x86_64-darwin ]

     

       423
       423
       -
         Raincat:                                      [ x86_64-darwin ]

     

       424
       424
       -
         reactive-balsa:                               [ x86_64-darwin ] # depends on alsa-core

     

       425
       425
       -
         reactivity:                                   [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       426
       426
       -
         reflex-dom-fragment-shader-canvas:            [ x86_64-darwin, aarch64-linux ]

     

       427
       427
       -
         reflex-dom:                                   [ x86_64-darwin, aarch64-linux ]

     

       428
       428
       -
         reflex-localize-dom:                          [ x86_64-darwin, aarch64-linux ]

     

       429
       429
       -
         rtlsdr:                                       [ x86_64-darwin ]

     

       430
       430
       -
         rubberband:                                   [ x86_64-darwin ]

     

       420
       420
       +
         piyo:                                         [ x86_64-darwin, aarch64-darwin ]

     

       421
       421
       +
         PortMidi-simple:                              [ x86_64-darwin, aarch64-darwin ]

     

       422
       422
       +
         PortMidi:                                     [ x86_64-darwin, aarch64-darwin ]

     

       423
       423
       +
         posix-api:                                    [ x86_64-darwin, aarch64-darwin ]

     

       424
       424
       +
         Raincat:                                      [ x86_64-darwin, aarch64-darwin ]

     

       425
       425
       +
         reactive-balsa:                               [ x86_64-darwin, aarch64-darwin ] # depends on alsa-core

     

       426
       426
       +
         reactivity:                                   [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       427
       427
       +
         reflex-dom-fragment-shader-canvas:            [ x86_64-darwin, aarch64-darwin, aarch64-linux ]

     

       428
       428
       +
         reflex-dom:                                   [ x86_64-darwin, aarch64-darwin, aarch64-linux ]

     

       429
       429
       +
         reflex-localize-dom:                          [ x86_64-darwin, aarch64-darwin, aarch64-linux ]

     

       430
       430
       +
         rtlsdr:                                       [ x86_64-darwin, aarch64-darwin ]

     

       431
       431
       +
         rubberband:                                   [ x86_64-darwin, aarch64-darwin ]

     

       431
       432
        
         sbv:                                          [ aarch64-linux ]

     

       432
       433
        
         scat:                                         [ aarch64-linux, armv7l-linux ] # uses scrypt, which requries x86

     

       433
       434
        
         scrypt:                                       [ aarch64-linux, armv7l-linux ] # https://github.com/informatikr/scrypt/issues/8

     

       434
       434
       -
         sdl2-mixer:                                   [ x86_64-darwin ]

     

       435
       435
       -
         sdl2-ttf:                                     [ x86_64-darwin ]

     

       436
       436
       -
         synthesizer-alsa:                             [ x86_64-darwin ]

     

       437
       437
       -
         taffybar:                                     [ x86_64-darwin ]

     

       438
       438
       -
         termonad:                                     [ x86_64-darwin ]

     

       439
       439
       -
         tokyotyrant-haskell:                          [ x86_64-darwin ]

     

       440
       440
       -
         udev:                                         [ x86_64-darwin ]

     

       441
       441
       -
         Unixutils-shadow:                             [ x86_64-darwin ]

     

       435
       435
       +
         sdl2-mixer:                                   [ x86_64-darwin, aarch64-darwin ]

     

       436
       436
       +
         sdl2-ttf:                                     [ x86_64-darwin, aarch64-darwin ]

     

       437
       437
       +
         synthesizer-alsa:                             [ x86_64-darwin, aarch64-darwin ]

     

       438
       438
       +
         taffybar:                                     [ x86_64-darwin, aarch64-darwin ]

     

       439
       439
       +
         termonad:                                     [ x86_64-darwin, aarch64-darwin ]

     

       440
       440
       +
         tokyotyrant-haskell:                          [ x86_64-darwin, aarch64-darwin ]

     

       441
       441
       +
         udev:                                         [ x86_64-darwin, aarch64-darwin ]

     

       442
       442
       +
         Unixutils-shadow:                             [ x86_64-darwin, aarch64-darwin ]

     

       442
       443
        
         verifiable-expressions:                       [ aarch64-linux ]

     

       443
       443
       -
         vrpn:                                         [ x86_64-darwin ]

     

       444
       444
       -
         vulkan:                                       [ i686-linux, armv7l-linux, x86_64-darwin ]

     

       445
       445
       -
         VulkanMemoryAllocator:                        [ i686-linux, armv7l-linux, x86_64-darwin ]

     

       446
       446
       -
         vulkan-utils:                                 [ x86_64-darwin ]

     

       447
       447
       -
         webkit2gtk3-javascriptcore:                   [ x86_64-darwin ]

     

       448
       448
       -
         Win32-console:                                [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       449
       449
       -
         Win32-dhcp-server:                            [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       450
       450
       -
         Win32-errors:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       451
       451
       -
         Win32-extras:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       452
       452
       -
         Win32:                                        [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       453
       453
       -
         Win32-junction-point:                         [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       454
       454
       -
         Win32-notify:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       455
       455
       -
         Win32-security:                               [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       456
       456
       -
         Win32-services:                               [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       457
       457
       -
         Win32-services-wrapper:                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       458
       458
       -
         xattr:                                        [ x86_64-darwin ]

     

       444
       444
       +
         vrpn:                                         [ x86_64-darwin, aarch64-darwin ]

     

       445
       445
       +
         vulkan:                                       [ i686-linux, armv7l-linux, x86_64-darwin, aarch64-darwin ]

     

       446
       446
       +
         VulkanMemoryAllocator:                        [ i686-linux, armv7l-linux, x86_64-darwin, aarch64-darwin ]

     

       447
       447
       +
         vulkan-utils:                                 [ x86_64-darwin, aarch64-darwin ]

     

       448
       448
       +
         webkit2gtk3-javascriptcore:                   [ x86_64-darwin, aarch64-darwin ]

     

       449
       449
       +
         Win32-console:                                [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       450
       450
       +
         Win32-dhcp-server:                            [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       451
       451
       +
         Win32-errors:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       452
       452
       +
         Win32-extras:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       453
       453
       +
         Win32:                                        [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       454
       454
       +
         Win32-junction-point:                         [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       455
       455
       +
         Win32-notify:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       456
       456
       +
         Win32-security:                               [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       457
       457
       +
         Win32-services:                               [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       458
       458
       +
         Win32-services-wrapper:                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       459
       459
       +
         xattr:                                        [ x86_64-darwin, aarch64-darwin ]

     

       459
       460
        
         xgboost-haskell:                              [ aarch64-linux, armv7l-linux ]

     

       460
       460
       -
         XInput:                                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       461
       461
       -
         xmobar:                                       [ x86_64-darwin ]

     

       462
       462
       -
         xmonad-extras:                                [ x86_64-darwin ]

     

       463
       463
       -
         xmonad-volume:                                [ x86_64-darwin ]

     

       461
       461
       +
         XInput:                                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       462
       462
       +
         xmobar:                                       [ x86_64-darwin, aarch64-darwin ]

     

       463
       463
       +
         xmonad-extras:                                [ x86_64-darwin, aarch64-darwin ]

     

       464
       464
       +
         xmonad-volume:                                [ x86_64-darwin, aarch64-darwin ]

     

       464
       465
        
       

     

       465
       466
        
       dont-distribute-packages:

     

       466
       467
        
         # Depends on shine, which is a ghcjs project.

+59 -53

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

···

       1
       1
       -
       # Stackage LTS 18.5

     

       1
       1
       +
       # Stackage LTS 18.7

     

       2
       2
        
       # This file is auto-generated by

     

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

     

       4
       4
        
       default-package-overrides:

     
···

       11
       11
        
         - ad ==4.4.1

     

       12
       12
        
         - adjunctions ==4.4

     

       13
       13
        
         - adler32 ==0.1.2.0

     

       14
       14
       -
         - aern2-mp ==0.2.7.0

     

       15
       15
       -
         - aern2-real ==0.2.7.0

     

       14
       14
       +
         - aern2-mp ==0.2.8.0

     

       15
       15
       +
         - aern2-real ==0.2.8.0

     

       16
       16
        
         - aeson ==1.5.6.0

     

       17
       17
        
         - aeson-attoparsec ==0.0.0

     

       18
       18
        
         - aeson-better-errors ==0.9.1.0

     
···

       145
       145
        
         - ansi-terminal ==0.11

     

       146
       146
        
         - ansi-wl-pprint ==0.6.9

     

       147
       147
        
         - ANum ==0.2.0.2

     

       148
       148
       -
         - apecs ==0.9.2

     

       148
       148
       +
         - apecs ==0.9.3

     

       149
       149
        
         - apecs-gloss ==0.2.4

     

       150
       150
        
         - apecs-physics ==0.4.5

     

       151
       151
        
         - api-field-json-th ==0.1.0.2

     
···

       269
       269
        
         - blake2 ==0.3.0

     

       270
       270
        
         - blanks ==0.5.0

     

       271
       271
        
         - blas-carray ==0.1.0.1

     

       272
       272
       -
         - blas-comfort-array ==0.0.0.2

     

       272
       272
       +
         - blas-comfort-array ==0.0.0.3

     

       273
       273
        
         - blas-ffi ==0.1

     

       274
       274
        
         - blaze-bootstrap ==0.1.0.1

     

       275
       275
        
         - blaze-builder ==0.4.2.1

     
···

       288
       288
        
         - boots ==0.2.0.1

     

       289
       289
        
         - bordacount ==0.1.0.0

     

       290
       290
        
         - boring ==0.2

     

       291
       291
       -
         - both ==0.1.1.1

     

       291
       291
       +
         - both ==0.1.1.2

     

       292
       292
        
         - bound ==2.0.3

     

       293
       293
        
         - BoundedChan ==1.0.3.0

     

       294
       294
        
         - bounded-queue ==1.0.0

     
···

       311
       311
        
         - bv ==0.5

     

       312
       312
        
         - bv-little ==1.1.1

     

       313
       313
        
         - byteable ==0.1.1

     

       314
       314
       -
         - byte-count-reader ==0.10.1.3

     

       314
       314
       +
         - byte-count-reader ==0.10.1.5

     

       315
       315
        
         - bytedump ==1.0

     

       316
       316
        
         - byte-order ==0.1.2.0

     

       317
       317
        
         - byteorder ==1.0.4

     
···

       331
       331
        
         - c2hs ==0.28.8

     

       332
       332
        
         - cabal2spec ==2.6.2

     

       333
       333
        
         - cabal-appimage ==0.3.0.2

     

       334
       334
       +
         - cabal-clean ==0.1.20210815

     

       334
       335
        
         - cabal-debian ==5.1

     

       335
       336
        
         - cabal-doctest ==1.0.8

     

       336
       337
        
         - cabal-file ==0.1.1

     

       337
       338
        
         - cabal-flatpak ==0.1.0.2

     

       338
       339
        
         - cabal-plan ==0.7.2.0

     

       339
       339
       -
         - cabal-rpm ==2.0.9

     

       340
       340
       +
         - cabal-rpm ==2.0.10

     

       340
       341
        
         - cache ==0.1.3.0

     

       342
       342
       +
         - cached-json-file ==0.1.0

     

       341
       343
        
         - cacophony ==0.10.1

     

       342
       344
        
         - calendar-recycling ==0.0.0.1

     

       343
       345
        
         - call-stack ==0.3.0

     
···

       381
       383
        
         - cheapskate-lucid ==0.1.0.0

     

       382
       384
        
         - checkers ==0.5.6

     

       383
       385
        
         - checksum ==0.0

     

       384
       384
       -
         - chimera ==0.3.1.0

     

       386
       386
       +
         - chimera ==0.3.2.0

     

       385
       387
        
         - chiphunk ==0.1.4.0

     

       386
       388
        
         - choice ==0.2.2

     

       387
       389
        
         - chronologique ==0.3.1.3

     
···

       395
       397
        
         - circle-packing ==0.1.0.6

     

       396
       398
        
         - circular ==0.4.0.0

     

       397
       399
        
         - citeproc ==0.4.0.1

     

       398
       398
       -
         - clash-ghc ==1.4.2

     

       399
       399
       -
         - clash-lib ==1.4.2

     

       400
       400
       -
         - clash-prelude ==1.4.2

     

       400
       400
       +
         - clash-ghc ==1.4.3

     

       401
       401
       +
         - clash-lib ==1.4.3

     

       402
       402
       +
         - clash-prelude ==1.4.3

     

       401
       403
        
         - classy-prelude ==1.5.0

     

       402
       404
        
         - classy-prelude-conduit ==1.5.0

     

       403
       405
        
         - clay ==0.13.3

     
···

       415
       417
        
         - codec-beam ==0.2.0

     

       416
       418
        
         - code-page ==0.2.1

     

       417
       419
        
         - collect-errors ==0.1.5.0

     

       418
       418
       -
         - co-log-concurrent ==0.5.0.0

     

       420
       420
       +
         - co-log-concurrent ==0.5.1.0

     

       419
       421
        
         - co-log-core ==0.2.1.1

     

       420
       422
        
         - Color ==0.3.2

     

       421
       423
        
         - colorful-monoids ==0.2.1.3

     
···

       439
       441
        
         - composition ==1.0.2.2

     

       440
       442
        
         - composition-extra ==2.0.0

     

       441
       443
        
         - concise ==0.1.0.1

     

       442
       442
       -
         - concurrency ==1.11.0.1

     

       444
       444
       +
         - concurrency ==1.11.0.2

     

       443
       445
        
         - concurrent-extra ==0.7.0.12

     

       444
       446
        
         - concurrent-output ==1.10.12

     

       445
       447
        
         - concurrent-split ==0.0.1.1

     
···

       579
       581
        
         - deepseq-generics ==0.2.0.0

     

       580
       582
        
         - deepseq-instances ==0.1.0.1

     

       581
       583
        
         - deferred-folds ==0.9.17

     

       582
       582
       -
         - dejafu ==2.4.0.2

     

       584
       584
       +
         - dejafu ==2.4.0.3

     

       583
       585
        
         - dense-linear-algebra ==0.1.0.0

     

       584
       586
        
         - dependent-map ==0.4.0.0

     

       585
       587
        
         - dependent-sum ==0.7.1.0

     
···

       743
       745
        
         - fakefs ==0.3.0.2

     

       744
       746
        
         - fakepull ==0.3.0.2

     

       745
       747
        
         - faktory ==1.0.3.1

     

       746
       746
       -
         - fast-digits ==0.3.0.0

     

       748
       748
       +
         - fast-digits ==0.3.1.0

     

       747
       749
        
         - fast-logger ==3.0.5

     

       748
       750
        
         - fast-math ==1.0.2

     

       749
       751
        
         - fb ==2.1.1

     
···

       759
       761
        
         - file-embed-lzma ==0

     

       760
       762
        
         - filelock ==0.1.1.5

     

       761
       763
        
         - filemanip ==0.3.6.3

     

       762
       762
       -
         - filepath-bytestring ==1.4.2.1.7

     

       764
       764
       +
         - filepath-bytestring ==1.4.2.1.8

     

       763
       765
        
         - file-path-th ==0.1.0.0

     

       764
       766
        
         - filepattern ==0.1.2

     

       765
       767
        
         - fileplow ==0.1.0.0

     
···

       890
       892
        
         - ghcid ==0.8.7

     

       891
       893
        
         - ghci-hexcalc ==0.1.1.0

     

       892
       894
        
         - ghcjs-codemirror ==0.0.0.2

     

       893
       893
       -
         - ghc-lib ==8.10.5.20210606

     

       894
       894
       -
         - ghc-lib-parser ==8.10.5.20210606

     

       895
       895
       -
         - ghc-lib-parser-ex ==8.10.0.21

     

       895
       895
       +
         - ghc-lib ==8.10.6.20210814

     

       896
       896
       +
         - ghc-lib-parser ==8.10.6.20210814

     

       897
       897
       +
         - ghc-lib-parser-ex ==8.10.0.22

     

       896
       898
        
         - ghc-parser ==0.2.3.0

     

       897
       899
        
         - ghc-paths ==0.1.0.12

     

       898
       900
        
         - ghc-prof ==1.4.1.9

     
···

       985
       987
        
         - hashing ==0.1.0.1

     

       986
       988
        
         - hashmap ==1.3.3

     

       987
       989
        
         - hashtables ==1.2.4.1

     

       988
       988
       -
         - haskeline ==0.8.1.2

     

       990
       990
       +
         - haskeline ==0.8.2

     

       989
       991
        
         - haskell-awk ==1.2.0.1

     

       990
       992
        
         - haskell-gi ==0.25.0

     

       991
       993
        
         - haskell-gi-base ==0.25.0

     
···

       1081
       1083
        
         - hourglass-orphans ==0.1.0.0

     

       1082
       1084
        
         - hp2pretty ==0.10

     

       1083
       1085
        
         - hpack ==0.34.4

     

       1084
       1084
       -
         - hpack-dhall ==0.5.2

     

       1086
       1086
       +
         - hpack-dhall ==0.5.3

     

       1085
       1087
        
         - hpc-codecov ==0.3.0.0

     

       1086
       1088
        
         - hpc-lcov ==1.0.1

     

       1087
       1089
        
         - hprotoc ==2.4.17

     
···

       1134
       1136
        
         - hs-php-session ==0.0.9.3

     

       1135
       1137
        
         - hsshellscript ==3.5.0

     

       1136
       1138
        
         - hs-tags ==0.1.5

     

       1137
       1137
       -
         - HStringTemplate ==0.8.7

     

       1139
       1139
       +
         - HStringTemplate ==0.8.8

     

       1138
       1140
        
         - HSvm ==0.1.1.3.22

     

       1139
       1141
        
         - HsYAML ==0.2.1.0

     

       1140
       1142
        
         - HsYAML-aeson ==0.2.0.0

     
···

       1142
       1144
        
         - htaglib ==1.2.0

     

       1143
       1145
        
         - HTF ==0.14.0.6

     

       1144
       1146
        
         - html ==1.0.1.2

     

       1145
       1145
       -
         - html-conduit ==1.3.2.1

     

       1147
       1147
       +
         - html-conduit ==1.3.2.2

     

       1146
       1148
        
         - html-entities ==1.1.4.5

     

       1147
       1149
        
         - html-entity-map ==0.1.0.0

     

       1148
       1150
        
         - htoml ==1.0.0.3

     
···

       1168
       1170
        
         - human-readable-duration ==0.2.1.4

     

       1169
       1171
        
         - HUnit ==1.6.2.0

     

       1170
       1172
        
         - HUnit-approx ==1.1.1.1

     

       1171
       1171
       -
         - hunit-dejafu ==2.0.0.4

     

       1173
       1173
       +
         - hunit-dejafu ==2.0.0.5

     

       1172
       1174
        
         - hvect ==0.4.0.0

     

       1173
       1175
        
         - hvega ==0.11.0.1

     

       1174
       1176
        
         - hw-balancedparens ==0.4.1.1

     
···

       1255
       1257
        
         - intern ==0.9.4

     

       1256
       1258
        
         - interpolate ==0.2.1

     

       1257
       1259
        
         - interpolatedstring-perl6 ==1.0.2

     

       1258
       1258
       -
         - interpolation ==0.1.1.1

     

       1260
       1260
       +
         - interpolation ==0.1.1.2

     

       1259
       1261
        
         - interpolator ==1.1.0.2

     

       1260
       1262
        
         - IntervalMap ==0.6.1.2

     

       1261
       1263
        
         - intervals ==0.9.2

     
···

       1278
       1280
        
         - ipynb ==0.1.0.1

     

       1279
       1281
        
         - ipython-kernel ==0.10.2.1

     

       1280
       1282
        
         - irc ==0.6.1.0

     

       1281
       1281
       -
         - irc-client ==1.1.2.1

     

       1282
       1282
       -
         - irc-conduit ==0.3.0.4

     

       1283
       1283
       -
         - irc-ctcp ==0.1.3.0

     

       1283
       1283
       +
         - irc-client ==1.1.2.2

     

       1284
       1284
       +
         - irc-conduit ==0.3.0.5

     

       1285
       1285
       +
         - irc-ctcp ==0.1.3.1

     

       1284
       1286
        
         - isbn ==1.1.0.2

     

       1285
       1287
        
         - islink ==0.1.0.0

     

       1286
       1288
        
         - iso3166-country-codes ==0.20140203.8

     
···

       1294
       1296
        
         - ix-shapable ==0.1.0

     

       1295
       1297
        
         - jack ==0.7.2

     

       1296
       1298
        
         - jalaali ==1.0.0.0

     

       1299
       1299
       +
         - java-adt ==0.2018.11.4

     

       1297
       1300
        
         - jira-wiki-markup ==1.4.0

     

       1298
       1301
        
         - jose ==0.8.4

     

       1299
       1302
        
         - jose-jwt ==0.9.2

     
···

       1335
       1338
        
         - l10n ==0.1.0.1

     

       1336
       1339
        
         - labels ==0.3.3

     

       1337
       1340
        
         - lackey ==1.0.15

     

       1338
       1338
       -
         - lambdabot-core ==5.3.0.1

     

       1341
       1341
       +
         - lambdabot-core ==5.3.0.2

     

       1339
       1342
        
         - LambdaHack ==0.10.2.0

     

       1340
       1343
        
         - lame ==0.2.0

     

       1341
       1344
        
         - language-avro ==0.1.3.1

     

       1342
       1345
        
         - language-bash ==0.9.2

     

       1343
       1346
        
         - language-c ==0.9.0.1

     

       1344
       1347
        
         - language-c-quote ==0.13

     

       1345
       1345
       -
         - language-docker ==10.0.1

     

       1348
       1348
       +
         - language-docker ==10.0.2

     

       1346
       1349
        
         - language-java ==0.2.9

     

       1347
       1350
        
         - language-javascript ==0.7.1.0

     

       1348
       1351
        
         - language-protobuf ==1.0.1

     
···

       1350
       1353
        
         - language-thrift ==0.12.0.0

     

       1351
       1354
        
         - lapack ==0.3.2

     

       1352
       1355
        
         - lapack-carray ==0.0.3

     

       1353
       1353
       -
         - lapack-comfort-array ==0.0.0.1

     

       1356
       1356
       +
         - lapack-comfort-array ==0.0.1

     

       1354
       1357
        
         - lapack-ffi ==0.0.3

     

       1355
       1358
        
         - lapack-ffi-tools ==0.1.2.1

     

       1356
       1359
        
         - largeword ==1.2.5

     
···

       1510
       1513
        
         - min-max-pqueue ==0.1.0.2

     

       1511
       1514
        
         - mintty ==0.1.2

     

       1512
       1515
        
         - missing-foreign ==0.1.1

     

       1513
       1513
       -
         - mixed-types-num ==0.5.8.0

     

       1516
       1516
       +
         - mixed-types-num ==0.5.9.1

     

       1514
       1517
        
         - mltool ==0.2.0.1

     

       1515
       1518
        
         - mmap ==0.5.9

     

       1516
       1519
        
         - mmark ==0.0.7.2

     
···

       1526
       1529
        
         - modern-uri ==0.3.4.1

     

       1527
       1530
        
         - modular ==0.1.0.8

     

       1528
       1531
        
         - monad-chronicle ==1.0.0.1

     

       1529
       1529
       -
         - monad-control ==1.0.3

     

       1532
       1532
       +
         - monad-control ==1.0.3.1

     

       1530
       1533
        
         - monad-control-aligned ==0.0.1.1

     

       1531
       1531
       -
         - monad-coroutine ==0.9.1.2

     

       1534
       1534
       +
         - monad-coroutine ==0.9.1.3

     

       1532
       1535
        
         - monad-extras ==0.6.0

     

       1533
       1536
        
         - monadic-arrays ==0.2.2

     

       1534
       1537
        
         - monad-journal ==0.8.1

     
···

       1541
       1544
        
         - monad-memo ==0.5.3

     

       1542
       1545
        
         - monad-metrics ==0.2.2.0

     

       1543
       1546
        
         - monad-par ==0.3.5

     

       1544
       1544
       -
         - monad-parallel ==0.7.2.4

     

       1547
       1547
       +
         - monad-parallel ==0.7.2.5

     

       1545
       1548
        
         - monad-par-extras ==0.3.3

     

       1546
       1549
        
         - monad-peel ==0.2.1.2

     

       1547
       1550
        
         - monad-primitive ==0.1

     
···

       1586
       1589
        
         - mustache ==2.3.1

     

       1587
       1590
        
         - mutable-containers ==0.3.4

     

       1588
       1591
        
         - mwc-probability ==2.3.1

     

       1589
       1589
       -
         - mwc-random ==0.15.0.1

     

       1592
       1592
       +
         - mwc-random ==0.15.0.2

     

       1590
       1593
        
         - mwc-random-monad ==0.7.3.1

     

       1591
       1594
        
         - mx-state-codes ==1.0.0.0

     

       1592
       1595
        
         - mysql ==0.2.0.1

     
···

       1604
       1607
        
         - neat-interpolation ==0.5.1.2

     

       1605
       1608
        
         - netcode-io ==0.0.2

     

       1606
       1609
        
         - netlib-carray ==0.1

     

       1607
       1607
       -
         - netlib-comfort-array ==0.0.0.1

     

       1610
       1610
       +
         - netlib-comfort-array ==0.0.0.2

     

       1608
       1611
        
         - netlib-ffi ==0.1.1

     

       1609
       1612
        
         - net-mqtt ==0.7.1.1

     

       1610
       1613
        
         - net-mqtt-lens ==0.1.1.0

     
···

       1674
       1677
        
         - OneTuple ==0.2.2.1

     

       1675
       1678
        
         - Only ==0.1

     

       1676
       1679
        
         - oo-prototypes ==0.1.0.0

     

       1677
       1677
       -
         - opaleye ==0.7.3.0

     

       1680
       1680
       +
         - opaleye ==0.7.4.0

     

       1678
       1681
        
         - OpenAL ==1.7.0.5

     

       1679
       1682
        
         - openapi3 ==3.1.0

     

       1680
       1683
        
         - open-browser ==0.2.1.0

     
···

       1803
       1806
        
         - pointedlist ==0.6.1

     

       1804
       1807
        
         - pointless-fun ==1.1.0.6

     

       1805
       1808
        
         - poll ==0.0.0.2

     

       1809
       1809
       +
         - polling-cache ==0.1.1.0

     

       1806
       1810
        
         - poly ==0.5.0.0

     

       1807
       1811
        
         - poly-arity ==0.1.0

     

       1808
       1812
        
         - polynomials-bernstein ==1.1.2

     
···

       1844
       1848
        
         - pretty-sop ==0.2.0.3

     

       1845
       1849
        
         - pretty-terminal ==0.1.0.0

     

       1846
       1850
        
         - primes ==0.2.1.0

     

       1847
       1847
       -
         - primitive ==0.7.1.0

     

       1851
       1851
       +
         - primitive ==0.7.2.0

     

       1848
       1852
        
         - primitive-addr ==0.1.0.2

     

       1849
       1853
        
         - primitive-extras ==0.10.1

     

       1850
       1854
        
         - primitive-unaligned ==0.1.1.1

     
···

       1971
       1975
        
         - regex-pcre ==0.95.0.0

     

       1972
       1976
        
         - regex-pcre-builtin ==0.95.2.3.8.43

     

       1973
       1977
        
         - regex-posix ==0.96.0.1

     

       1978
       1978
       +
         - regex-posix-clib ==2.7

     

       1974
       1979
        
         - regex-tdfa ==1.3.1.1

     

       1975
       1980
        
         - regex-with-pcre ==1.1.0.0

     

       1976
       1981
        
         - registry ==0.2.0.3

     
···

       1983
       1988
        
         - reliable-io ==0.0.1

     

       1984
       1989
        
         - relude ==0.7.0.0

     

       1985
       1990
        
         - renderable ==0.2.0.1

     

       1986
       1986
       -
         - replace-attoparsec ==1.4.4.0

     

       1991
       1991
       +
         - replace-attoparsec ==1.4.5.0

     

       1987
       1992
        
         - replace-megaparsec ==1.4.4.0

     

       1988
       1993
        
         - repline ==0.4.0.0

     

       1989
       1994
        
         - req ==3.9.0

     

       1990
       1990
       -
         - req-conduit ==1.0.0

     

       1995
       1995
       +
         - req-conduit ==1.0.1

     

       1991
       1996
        
         - rerebase ==1.13.0.1

     

       1992
       1997
        
         - rescue ==0.4.2.1

     

       1993
       1998
        
         - resistor-cube ==0.0.1.2

     

       1994
       1999
        
         - resolv ==0.1.2.0

     

       1995
       2000
        
         - resource-pool ==0.2.3.2

     

       1996
       1996
       -
         - resourcet ==1.2.4.2

     

       2001
       2001
       +
         - resourcet ==1.2.4.3

     

       1997
       2002
        
         - result ==0.2.6.0

     

       1998
       2003
        
         - rethinkdb-client-driver ==0.0.25

     

       1999
       2004
        
         - retry ==0.8.1.2

     
···

       2004
       2009
        
         - rhine ==0.7.0

     

       2005
       2010
        
         - rhine-gloss ==0.7.0

     

       2006
       2011
        
         - rigel-viz ==0.2.0.0

     

       2007
       2007
       -
         - rio ==0.1.20.0

     

       2012
       2012
       +
         - rio ==0.1.21.0

     

       2008
       2013
        
         - rio-orphans ==0.1.2.0

     

       2009
       2014
        
         - rio-prettyprint ==0.1.1.0

     

       2010
       2015
        
         - roc-id ==0.1.0.0

     
···

       2158
       2163
        
         - singletons ==2.7

     

       2159
       2164
        
         - singletons-presburger ==0.6.0.0

     

       2160
       2165
        
         - siphash ==1.0.3

     

       2166
       2166
       +
         - Sit ==0.2021.1.18

     

       2161
       2167
        
         - sitemap-gen ==0.1.0.0

     

       2162
       2168
        
         - sized ==1.0.0.0

     

       2163
       2169
        
         - skein ==1.0.9.4

     
···

       2239
       2245
        
         - storable-record ==0.0.5

     

       2240
       2246
        
         - storable-tuple ==0.0.3.3

     

       2241
       2247
        
         - storablevector ==0.2.13.1

     

       2242
       2242
       -
         - store ==0.7.11

     

       2248
       2248
       +
         - store ==0.7.12

     

       2243
       2249
        
         - store-core ==0.4.4.4

     

       2244
       2250
        
         - store-streaming ==0.2.0.3

     

       2245
       2251
        
         - stratosphere ==0.59.1

     
···

       2315
       2321
        
         - tasty ==1.4.1

     

       2316
       2322
        
         - tasty-ant-xml ==1.1.8

     

       2317
       2323
        
         - tasty-bench ==0.2.5

     

       2318
       2318
       -
         - tasty-dejafu ==2.0.0.7

     

       2324
       2324
       +
         - tasty-dejafu ==2.0.0.8

     

       2319
       2325
        
         - tasty-discover ==4.2.2

     

       2320
       2326
        
         - tasty-expected-failure ==0.12.3

     

       2321
       2327
        
         - tasty-focus ==1.0.1

     
···

       2356
       2362
        
         - test-framework-smallcheck ==0.2

     

       2357
       2363
        
         - test-fun ==0.1.0.0

     

       2358
       2364
        
         - testing-type-modifiers ==0.1.0.1

     

       2359
       2359
       -
         - texmath ==0.12.3

     

       2365
       2365
       +
         - texmath ==0.12.3.1

     

       2360
       2366
        
         - text-ansi ==0.1.1

     

       2361
       2367
        
         - text-binary ==0.2.1.1

     

       2362
       2368
        
         - text-builder ==0.6.6.2

     
···

       2427
       2433
        
         - timezone-series ==0.1.9

     

       2428
       2434
        
         - tinylog ==0.15.0

     

       2429
       2435
        
         - titlecase ==1.0.1

     

       2430
       2430
       -
         - tldr ==0.9.0

     

       2436
       2436
       +
         - tldr ==0.9.1

     

       2431
       2437
        
         - tls ==1.5.5

     

       2432
       2438
        
         - tls-debug ==0.4.8

     

       2433
       2439
        
         - tls-session-manager ==0.0.4

     
···

       2441
       2447
        
         - torsor ==0.1

     

       2442
       2448
        
         - tostring ==0.2.1.1

     

       2443
       2449
        
         - transaction ==0.1.1.3

     

       2444
       2444
       -
         - transformers-base ==0.4.5.2

     

       2450
       2450
       +
         - transformers-base ==0.4.6

     

       2445
       2451
        
         - transformers-bifunctors ==0.1

     

       2446
       2452
        
         - transformers-compat ==0.6.6

     

       2447
       2453
        
         - transformers-fix ==1.0

     
···

       2463
       2469
        
         - turtle ==1.5.22

     

       2464
       2470
        
         - typecheck-plugin-nat-simple ==0.1.0.2

     

       2465
       2471
        
         - TypeCompose ==0.9.14

     

       2466
       2466
       -
         - typed-process ==0.2.6.0

     

       2472
       2472
       +
         - typed-process ==0.2.6.1

     

       2467
       2473
        
         - typed-uuid ==0.1.0.0

     

       2468
       2474
        
         - type-equality ==1

     

       2469
       2475
        
         - type-errors ==0.2.0.0

     

       2470
       2470
       -
         - type-errors-pretty ==0.0.1.1

     

       2476
       2476
       +
         - type-errors-pretty ==0.0.1.2

     

       2471
       2477
        
         - type-hint ==0.1

     

       2472
       2478
        
         - type-level-integers ==0.0.1

     

       2473
       2479
        
         - type-level-kv-list ==1.1.0

     
···

       2593
       2599
        
         - wai-feature-flags ==0.1.0.1

     

       2594
       2600
        
         - wai-handler-launch ==3.0.3.1

     

       2595
       2601
        
         - wai-logger ==2.3.6

     

       2596
       2596
       -
         - wai-middleware-auth ==0.2.5.0

     

       2602
       2602
       +
         - wai-middleware-auth ==0.2.5.1

     

       2597
       2603
        
         - wai-middleware-caching ==0.1.0.2

     

       2598
       2604
        
         - wai-middleware-clacks ==0.1.0.1

     

       2599
       2605
        
         - wai-middleware-prometheus ==1.0.0

     
···

       2649
       2655
        
         - writer-cps-transformers ==0.5.6.1

     

       2650
       2656
        
         - wss-client ==0.3.0.0

     

       2651
       2657
        
         - wuss ==1.1.18

     

       2652
       2652
       -
         - X11 ==1.10

     

       2658
       2658
       +
         - X11 ==1.10.1

     

       2653
       2659
        
         - X11-xft ==0.3.1

     

       2654
       2660
        
         - x11-xim ==0.0.9.0

     

       2655
       2661
        
         - x509 ==1.7.5

+5 -11

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

···

       391
       391
        
        - adict

     

       392
       392
        
        - adp-multi-monadiccp

     

       393
       393
        
        - aern2-real

     

       394
       394
       -
        - aern2-real_0_2_8_0

     

       395
       394
        
        - aeson-native

     

       396
       395
        
        - afv

     

       397
       396
        
        - agda-server

     
···

       712
       711
        
        - claferwiki

     

       713
       712
        
        - clash

     

       714
       713
        
        - clash-ghc

     

       715
       715
       -
        - clash-ghc_1_4_3

     

       716
       714
        
        - clash-lib

     

       717
       717
       -
        - clash-lib_1_4_3

     

       718
       715
        
        - clash-multisignal

     

       719
       716
        
        - clash-prelude-quickcheck

     

       717
       717
       +
        - clash-shake

     

       720
       718
        
        - clash-systemverilog

     

       721
       719
        
        - clash-verilog

     

       722
       720
        
        - clash-vhdl

     

       721
       721
       +
        - clashilator

     

       723
       722
        
        - classify-frog

     

       724
       723
        
        - classy-miso

     

       725
       724
        
        - clckwrks

     
···

       1063
       1062
        
        - falling-turnip

     

       1064
       1063
        
        - fallingblocks

     

       1065
       1064
        
        - family-tree

     

       1066
       1066
       -
        - fast-digits

     

       1067
       1065
        
        - fastirc

     

       1068
       1066
        
        - fault-tree

     

       1069
       1067
        
        - fbrnch

     
···

       1131
       1129
        
        - fplll

     

       1132
       1130
        
        - fpnla-examples

     

       1133
       1131
        
        - frame-markdown

     

       1132
       1132
       +
        - freckle-app

     

       1134
       1133
        
        - free-theorems-counterexamples

     

       1135
       1134
        
        - free-theorems-seq

     

       1136
       1135
        
        - free-theorems-seq-webui

     
···

       1855
       1854
        
        - knots

     

       1856
       1855
        
        - korfu

     

       1857
       1856
        
        - ks-test

     

       1858
       1858
       -
        - kubernetes-client

     

       1859
       1857
        
        - kurita

     

       1860
       1858
        
        - laborantin-hs

     

       1861
       1859
        
        - labsat

     
···

       1895
       1893
        
        - lapack

     

       1896
       1894
        
        - lapack-carray

     

       1897
       1895
        
        - lapack-comfort-array

     

       1898
       1898
       -
        - lapack-comfort-array_0_0_1

     

       1899
       1896
        
        - lapack-hmatrix

     

       1900
       1897
        
        - lapack_0_4

     

       1901
       1898
        
        - lat

     
···

       2006
       2003
        
        - loup

     

       2007
       2004
        
        - ls-usb

     

       2008
       2005
        
        - lsystem

     

       2009
       2009
       -
        - lti13

     

       2010
       2006
        
        - luachunk

     

       2011
       2007
        
        - lucid-colonnade

     

       2012
       2008
        
        - lucienne

     
···

       2064
       2060
        
        - maxent

     

       2065
       2061
        
        - maxent-learner-hw-gui

     

       2066
       2062
        
        - maxsharing

     

       2067
       2067
       -
        - mcmc

     

       2068
       2063
        
        - mcmc-samplers

     

       2069
       2064
        
        - mealy

     

       2070
       2065
        
        - mediabus-fdk-aac

     
···

       2114
       2109
        
        - monetdb-mapi

     

       2115
       2110
        
        - mongrel2-handler

     

       2116
       2111
        
        - monky

     

       2117
       2117
       -
        - monomer

     

       2118
       2112
        
        - monte-carlo

     

       2119
       2113
        
        - moo

     

       2120
       2114
        
        - moo-nad

     
···

       2172
       2166
        
        - mywatch

     

       2173
       2167
        
        - n2o-web

     

       2174
       2168
        
        - nakadi-client

     

       2175
       2175
       -
        - nanovg-simple

     

       2176
       2169
        
        - nats-queue

     

       2177
       2170
        
        - natural-number

     

       2178
       2171
        
        - nemesis-titan

     
···

       2591
       2584
        
        - restful-snap

     

       2592
       2585
        
        - restricted-workers

     

       2593
       2586
        
        - rethinkdb-model

     

       2587
       2587
       +
        - retroclash-lib

     

       2588
       2588
       +
        - retroclash-sim

     

       2594
       2589
        
        - rewrite

     

       2595
       2590
        
        - rewriting

     

       2596
       2591
        
        - rezoom

     
···

       3270
       3265
        
        - yeshql

     

       3271
       3266
        
        - yesod-articles

     

       3272
       3267
        
        - yesod-auth-ldap

     

       3273
       3273
       -
        - yesod-auth-lti13

     

       3274
       3268
        
        - yesod-colonnade

     

       3275
       3269
        
        - yesod-continuations

     

       3276
       3270
        
        - yesod-examples

+4 -7

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

···

       223
       223
        
         wxcore = super.wxcore.override { wxGTK = pkgs.wxGTK30; };

     

       224
       224
        
       

     

       225
       225
        
         # Test suite wants to connect to $DISPLAY.

     

       226
       226
       +
         bindings-GLFW = dontCheck super.bindings-GLFW;

     

       227
       227
       +
         gi-gtk-declarative = dontCheck super.gi-gtk-declarative;

     

       228
       228
       +
         gi-gtk-declarative-app-simple = dontCheck super.gi-gtk-declarative-app-simple;

     

       226
       229
        
         hsqml = dontCheck (addExtraLibraries (super.hsqml.override { qt5 = pkgs.qt5Full; }) [pkgs.libGLU pkgs.libGL]);

     

       230
       230
       +
         monomer = dontCheck super.monomer;

     

       227
       231
        
       

     

       228
       232
        
         # Wants to check against a real DB, Needs freetds

     

       229
       233
        
         odbc = dontCheck (addExtraLibraries super.odbc [ pkgs.freetds ]);

     
···

       351
       355
        
       

     

       352
       356
        
         # Looks like Avahi provides the missing library

     

       353
       357
        
         dnssd = super.dnssd.override { dns_sd = pkgs.avahi.override { withLibdnssdCompat = true; }; };

     

       354
       354
       -
       

     

       355
       355
       -
         # requires an X11 display

     

       356
       356
       -
         bindings-GLFW = dontCheck super.bindings-GLFW;

     

       357
       357
       -
       

     

       358
       358
       -
         # requires an X11 display in test suite

     

       359
       359
       -
         gi-gtk-declarative = dontCheck super.gi-gtk-declarative;

     

       360
       360
       -
         gi-gtk-declarative-app-simple = dontCheck super.gi-gtk-declarative-app-simple;

     

       361
       358
        
       

     

       362
       359
        
         # tests depend on executable

     

       363
       360
        
         ghcide = overrideCabal super.ghcide (drv: {

+1001 -1173

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

···

       8804
       8804
        
            }) {};

     

       8805
       8805
        
       

     

       8806
       8806
        
         "HMock" = callPackage

     

       8807
       8807
       -
           ({ mkDerivation, base, constraints, containers, data-default

     

       8807
       8807
       +
           ({ mkDerivation, array, base, constraints, containers, data-default

     

       8808
       8808
        
            , deepseq, directory, doctest-exitcode-stdio, doctest-lib

     

       8809
       8809
        
            , exceptions, extra, hspec, monad-control, mono-traversable, mtl

     

       8810
       8810
        
            , QuickCheck, regex-tdfa, stm, syb, template-haskell

     
···

       8812
       8812
        
            }:

     

       8813
       8813
        
            mkDerivation {

     

       8814
       8814
        
              pname = "HMock";

     

       8815
       8815
       -
              version = "0.3.0.0";

     

       8816
       8816
       -
              sha256 = "0rvb3a0nbf8i0qfg7na5rvd966amids07l8w8ka6b7hdw46lkczn";

     

       8815
       8815
       +
              version = "0.4.0.0";

     

       8816
       8816
       +
              sha256 = "1xkb4qyccpp5iws0jysgmcypbcab8yig6hnc756890z1dz5d1vy5";

     

       8817
       8817
        
              libraryHaskellDepends = [

     

       8818
       8818
       -
                base constraints containers data-default exceptions extra

     

       8818
       8818
       +
                array base constraints containers data-default exceptions extra

     

       8819
       8819
        
                monad-control mono-traversable mtl regex-tdfa stm syb

     

       8820
       8820
        
                template-haskell transformers-base unliftio

     

       8821
       8821
        
              ];

     
···

       9041
       9041
        
              benchmarkHaskellDepends = [ base gauge ];

     

       9042
       9042
        
              description = "quantitative finance library";

     

       9043
       9043
        
              license = lib.licenses.mit;

     

       9044
       9044
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       9044
       9044
       +
              platforms = [

     

       9045
       9045
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       9046
       9046
       +
              ];

     

       9045
       9047
        
            }) {inherit (pkgs) gsl;};

     

       9046
       9048
        
       

     

       9047
       9049
        
         "HROOT" = callPackage

     
···

       9329
       9331
        
       

     

       9330
       9332
        
         "HStringTemplate" = callPackage

     

       9331
       9333
        
           ({ mkDerivation, array, base, blaze-builder, bytestring, containers

     

       9332
       9332
       -
            , deepseq, directory, filepath, mtl, old-locale, parsec, pretty

     

       9333
       9333
       -
            , semigroups, syb, template-haskell, text, time, void

     

       9334
       9334
       -
            }:

     

       9335
       9335
       -
            mkDerivation {

     

       9336
       9336
       -
              pname = "HStringTemplate";

     

       9337
       9337
       -
              version = "0.8.7";

     

       9338
       9338
       -
              sha256 = "03kbmyh0713j3qhhrl7jqbmsvyq1q82h2yxq45cc9rs55sma8kjg";

     

       9339
       9339
       -
              revision = "2";

     

       9340
       9340
       -
              editedCabalFile = "082d1lm6q1jb7rrl20jz0y4ca1qf87ihbq3v6mji9ibacl6adjaq";

     

       9341
       9341
       -
              libraryHaskellDepends = [

     

       9342
       9342
       -
                array base blaze-builder bytestring containers deepseq directory

     

       9343
       9343
       -
                filepath mtl old-locale parsec pretty semigroups syb

     

       9344
       9344
       -
                template-haskell text time void

     

       9345
       9345
       -
              ];

     

       9346
       9346
       -
              description = "StringTemplate implementation in Haskell";

     

       9347
       9347
       -
              license = lib.licenses.bsd3;

     

       9348
       9348
       -
            }) {};

     

       9349
       9349
       -
       

     

       9350
       9350
       -
         "HStringTemplate_0_8_8" = callPackage

     

       9351
       9351
       -
           ({ mkDerivation, array, base, blaze-builder, bytestring, containers

     

       9352
       9334
        
            , deepseq, directory, filepath, HUnit, mtl, old-locale, parsec

     

       9353
       9335
        
            , pretty, QuickCheck, random, semigroups, syb, template-haskell

     

       9354
       9336
        
            , text, time, void

     
···

       9365
       9347
        
              testHaskellDepends = [ base containers HUnit QuickCheck random ];

     

       9366
       9348
        
              description = "StringTemplate implementation in Haskell";

     

       9367
       9349
        
              license = lib.licenses.bsd3;

     

       9368
       9368
       -
              hydraPlatforms = lib.platforms.none;

     

       9369
       9350
        
            }) {};

     

       9370
       9351
        
       

     

       9371
       9352
        
         "HStringTemplateHelpers" = callPackage

     
···

       17794
       17775
        
              license = lib.licenses.bsd3;

     

       17795
       17776
        
            }) {};

     

       17796
       17777
        
       

     

       17778
       17778
       +
         "STMonadTrans_0_4_6" = callPackage

     

       17779
       17779
       +
           ({ mkDerivation, array, base, mtl, tasty, tasty-hunit

     

       17780
       17780
       +
            , tasty-quickcheck, transformers

     

       17781
       17781
       +
            }:

     

       17782
       17782
       +
            mkDerivation {

     

       17783
       17783
       +
              pname = "STMonadTrans";

     

       17784
       17784
       +
              version = "0.4.6";

     

       17785
       17785
       +
              sha256 = "0rvhh0hhwz601ibpzisry7xf3j61r5sxfgp47imaa37i5bvrlynb";

     

       17786
       17786
       +
              libraryHaskellDepends = [ array base mtl ];

     

       17787
       17787
       +
              testHaskellDepends = [

     

       17788
       17788
       +
                array base tasty tasty-hunit tasty-quickcheck transformers

     

       17789
       17789
       +
              ];

     

       17790
       17790
       +
              description = "A monad transformer version of the ST monad";

     

       17791
       17791
       +
              license = lib.licenses.bsd3;

     

       17792
       17792
       +
              hydraPlatforms = lib.platforms.none;

     

       17793
       17793
       +
            }) {};

     

       17794
       17794
       +
       

     

       17797
       17795
        
         "SVD2HS" = callPackage

     

       17798
       17796
        
           ({ mkDerivation, base, containers, pretty, text, xml-conduit

     

       17799
       17797
        
            , xml-lens

     
···

       17839
       17837
        
              pname = "SVGFonts";

     

       17840
       17838
        
              version = "1.7.0.1";

     

       17841
       17839
        
              sha256 = "06vnpkkr19s9b1wjp7l2w29vr7fsghcrffd2knlxvdhjacrfpc9h";

     

       17840
       17840
       +
              revision = "1";

     

       17841
       17841
       +
              editedCabalFile = "110zlafis1rivba3za7in92fq6a7738hh57w5gkivi50d7pfbw24";

     

       17842
       17842
        
              enableSeparateDataOutput = true;

     

       17843
       17843
        
              libraryHaskellDepends = [

     

       17844
       17844
        
                attoparsec base blaze-markup blaze-svg bytestring cereal

     
···

       21502
       21502
        
            }:

     

       21503
       21503
        
            mkDerivation {

     

       21504
       21504
        
              pname = "X11";

     

       21505
       21505
       -
              version = "1.10";

     

       21506
       21506
       -
              sha256 = "1zrdqryx99izjvsrsalb65ihpmikm9r6cjlci7cfp6wlwa3i585n";

     

       21507
       21507
       -
              libraryHaskellDepends = [ base data-default-class ];

     

       21508
       21508
       -
              librarySystemDepends = [

     

       21509
       21509
       -
                libX11 libXext libXinerama libXrandr libXrender libXScrnSaver

     

       21510
       21510
       -
              ];

     

       21511
       21511
       -
              description = "A binding to the X11 graphics library";

     

       21512
       21512
       -
              license = lib.licenses.bsd3;

     

       21513
       21513
       -
            }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXScrnSaver; 

     

       21514
       21514
       -
                inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXinerama; 

     

       21515
       21515
       -
                inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXrender;};

     

       21516
       21516
       -
       

     

       21517
       21517
       -
         "X11_1_10_1" = callPackage

     

       21518
       21518
       -
           ({ mkDerivation, base, data-default-class, libX11, libXext

     

       21519
       21519
       -
            , libXinerama, libXrandr, libXrender, libXScrnSaver

     

       21520
       21520
       -
            }:

     

       21521
       21521
       -
            mkDerivation {

     

       21522
       21522
       -
              pname = "X11";

     

       21523
       21505
        
              version = "1.10.1";

     

       21524
       21506
        
              sha256 = "13a0qf8rwn1s43wcl39f1pcq3h1kw1ddfq205j1ry0j3yafnazxg";

     

       21525
       21507
        
              libraryHaskellDepends = [ base data-default-class ];

     
···

       21528
       21510
        
              ];

     

       21529
       21511
        
              description = "A binding to the X11 graphics library";

     

       21530
       21512
        
              license = lib.licenses.bsd3;

     

       21531
       21531
       -
              hydraPlatforms = lib.platforms.none;

     

       21532
       21513
        
            }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXScrnSaver; 

     

       21533
       21514
        
                inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXinerama; 

     

       21534
       21515
        
                inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXrender;};

     
···

       24376
       24357
        
            }:

     

       24377
       24358
        
            mkDerivation {

     

       24378
       24359
        
              pname = "aern2-mp";

     

       24379
       24379
       -
              version = "0.2.7.0";

     

       24380
       24380
       -
              sha256 = "1gsqaggg6mpcpl9s3z566gmbynj4l6n1fhni5b0p8pf5hj8n93gg";

     

       24381
       24381
       -
              libraryHaskellDepends = [

     

       24382
       24382
       -
                base cdar-mBound collect-errors deepseq hspec integer-logarithms

     

       24383
       24383
       -
                mixed-types-num QuickCheck reflection regex-tdfa template-haskell

     

       24384
       24384
       -
              ];

     

       24385
       24385
       -
              testHaskellDepends = [

     

       24386
       24386
       -
                base cdar-mBound collect-errors deepseq hspec integer-logarithms

     

       24387
       24387
       -
                mixed-types-num QuickCheck reflection regex-tdfa template-haskell

     

       24388
       24388
       -
              ];

     

       24389
       24389
       -
              description = "Multi-precision ball (interval) arithmetic";

     

       24390
       24390
       -
              license = lib.licenses.bsd3;

     

       24391
       24391
       -
              hydraPlatforms = lib.platforms.none;

     

       24392
       24392
       -
              broken = true;

     

       24393
       24393
       -
            }) {};

     

       24394
       24394
       -
       

     

       24395
       24395
       -
         "aern2-mp_0_2_8_0" = callPackage

     

       24396
       24396
       -
           ({ mkDerivation, base, cdar-mBound, collect-errors, deepseq, hspec

     

       24397
       24397
       -
            , integer-logarithms, mixed-types-num, QuickCheck, reflection

     

       24398
       24398
       -
            , regex-tdfa, template-haskell

     

       24399
       24399
       -
            }:

     

       24400
       24400
       -
            mkDerivation {

     

       24401
       24401
       -
              pname = "aern2-mp";

     

       24402
       24360
        
              version = "0.2.8.0";

     

       24403
       24361
        
              sha256 = "0nfd2r05jm93idsgijccxzqkkpjkpkn8jz3kqwanlma0x3wj02cj";

     

       24404
       24362
        
              libraryHaskellDepends = [

     
···

       24421
       24379
        
            }:

     

       24422
       24380
        
            mkDerivation {

     

       24423
       24381
        
              pname = "aern2-real";

     

       24424
       24424
       -
              version = "0.2.7.0";

     

       24425
       24425
       -
              sha256 = "0dsph1775rifr9vvx4w7v55bryqmh04fhk6nyk7d91yhn1sf6wc9";

     

       24426
       24426
       -
              libraryHaskellDepends = [

     

       24427
       24427
       -
                aern2-mp base collect-errors hspec integer-logarithms

     

       24428
       24428
       -
                mixed-types-num QuickCheck

     

       24429
       24429
       -
              ];

     

       24430
       24430
       -
              testHaskellDepends = [

     

       24431
       24431
       -
                aern2-mp base collect-errors hspec integer-logarithms

     

       24432
       24432
       -
                mixed-types-num QuickCheck

     

       24433
       24433
       -
              ];

     

       24434
       24434
       -
              description = "Real numbers as sequences of MPBalls";

     

       24435
       24435
       -
              license = lib.licenses.bsd3;

     

       24436
       24436
       -
              hydraPlatforms = lib.platforms.none;

     

       24437
       24437
       -
            }) {};

     

       24438
       24438
       -
       

     

       24439
       24439
       -
         "aern2-real_0_2_8_0" = callPackage

     

       24440
       24440
       -
           ({ mkDerivation, aern2-mp, base, collect-errors, hspec

     

       24441
       24441
       -
            , integer-logarithms, mixed-types-num, QuickCheck

     

       24442
       24442
       -
            }:

     

       24443
       24443
       -
            mkDerivation {

     

       24444
       24444
       -
              pname = "aern2-real";

     

       24445
       24382
        
              version = "0.2.8.0";

     

       24446
       24383
        
              sha256 = "13nk4s5r7h7wg4q0x01f8aiy432zngynd5qbqsqi9fz149k7mik1";

     

       24447
       24384
        
              libraryHaskellDepends = [

     
···

       31165
       31102
        
            }:

     

       31166
       31103
        
            mkDerivation {

     

       31167
       31104
        
              pname = "apecs";

     

       31168
       31168
       -
              version = "0.9.2";

     

       31169
       31169
       -
              sha256 = "1ca9wpp60jslj63q77v55qql46f20jknfqsz7cjmqns41ml5g3q8";

     

       31170
       31170
       -
              libraryHaskellDepends = [

     

       31171
       31171
       -
                array base containers exceptions mtl template-haskell vector

     

       31172
       31172
       -
              ];

     

       31173
       31173
       -
              testHaskellDepends = [ base containers linear QuickCheck vector ];

     

       31174
       31174
       -
              benchmarkHaskellDepends = [ base criterion linear ];

     

       31175
       31175
       -
              description = "Fast Entity-Component-System library for game programming";

     

       31176
       31176
       -
              license = lib.licenses.bsd3;

     

       31177
       31177
       -
            }) {};

     

       31178
       31178
       -
       

     

       31179
       31179
       -
         "apecs_0_9_3" = callPackage

     

       31180
       31180
       -
           ({ mkDerivation, array, base, containers, criterion, exceptions

     

       31181
       31181
       -
            , linear, mtl, QuickCheck, template-haskell, vector

     

       31182
       31182
       -
            }:

     

       31183
       31183
       -
            mkDerivation {

     

       31184
       31184
       -
              pname = "apecs";

     

       31185
       31105
        
              version = "0.9.3";

     

       31186
       31106
        
              sha256 = "02qi63bj0prvmxi6ksw2cq0b7fvhcdv8fgbsjbv7vf51p4c6rbh7";

     

       31187
       31107
        
              libraryHaskellDepends = [

     
···

       31191
       31111
        
              benchmarkHaskellDepends = [ base criterion linear ];

     

       31192
       31112
        
              description = "Fast Entity-Component-System library for game programming";

     

       31193
       31113
        
              license = lib.licenses.bsd3;

     

       31194
       31194
       -
              hydraPlatforms = lib.platforms.none;

     

       31195
       31114
        
            }) {};

     

       31196
       31115
        
       

     

       31197
       31116
        
         "apecs-gloss" = callPackage

     
···

       38156
       38075
        
              ];

     

       38157
       38076
        
              description = "Create status bar menus for macOS from executables";

     

       38158
       38077
        
              license = lib.licenses.bsd3;

     

       38159
       38159
       -
              platforms = [ "x86_64-darwin" ];

     

       38078
       38078
       +
              platforms = [ "aarch64-darwin" "x86_64-darwin" ];

     

       38160
       38079
        
            }) {};

     

       38161
       38080
        
       

     

       38162
       38081
        
         "barchart" = callPackage

     
···

       43844
       43763
        
            }:

     

       43845
       43764
        
            mkDerivation {

     

       43846
       43765
        
              pname = "blas-comfort-array";

     

       43847
       43847
       -
              version = "0.0.0.2";

     

       43848
       43848
       -
              sha256 = "1n9w905ppb08w0d8xbxvgipr9fv1iapwq3ybvk0dbj009w341kd1";

     

       43849
       43849
       -
              libraryHaskellDepends = [

     

       43850
       43850
       -
                base blas-ffi comfort-array netlib-comfort-array netlib-ffi

     

       43851
       43851
       -
                storable-complex transformers

     

       43852
       43852
       -
              ];

     

       43853
       43853
       -
              description = "Auto-generated interface to Fortran BLAS via comfort-array";

     

       43854
       43854
       -
              license = lib.licenses.bsd3;

     

       43855
       43855
       -
            }) {};

     

       43856
       43856
       -
       

     

       43857
       43857
       -
         "blas-comfort-array_0_0_0_3" = callPackage

     

       43858
       43858
       -
           ({ mkDerivation, base, blas-ffi, comfort-array

     

       43859
       43859
       -
            , netlib-comfort-array, netlib-ffi, storable-complex, transformers

     

       43860
       43860
       -
            }:

     

       43861
       43861
       -
            mkDerivation {

     

       43862
       43862
       -
              pname = "blas-comfort-array";

     

       43863
       43766
        
              version = "0.0.0.3";

     

       43864
       43767
        
              sha256 = "1g0bvag205ag520vlxv24cv63idjg6j8nwnadq9gbcibn4gvsisz";

     

       43865
       43768
        
              libraryHaskellDepends = [

     
···

       43868
       43771
        
              ];

     

       43869
       43772
        
              description = "Auto-generated interface to Fortran BLAS via comfort-array";

     

       43870
       43773
        
              license = lib.licenses.bsd3;

     

       43871
       43871
       -
              hydraPlatforms = lib.platforms.none;

     

       43872
       43774
        
            }) {};

     

       43873
       43775
        
       

     

       43874
       43776
        
         "blas-ffi" = callPackage

     
···

       45552
       45454
        
           ({ mkDerivation, base, semigroups, zero }:

     

       45553
       45455
        
            mkDerivation {

     

       45554
       45456
        
              pname = "both";

     

       45555
       45555
       -
              version = "0.1.1.1";

     

       45556
       45556
       -
              sha256 = "0kdqz901fpdgggmkm9rpnpv7gma9c8d887bszhnz6xd3v96gg7xn";

     

       45557
       45557
       -
              libraryHaskellDepends = [ base semigroups zero ];

     

       45558
       45558
       -
              description = "Like Maybe, but with a different Monoid instance";

     

       45559
       45559
       -
              license = lib.licenses.mit;

     

       45560
       45560
       -
            }) {};

     

       45561
       45561
       -
       

     

       45562
       45562
       -
         "both_0_1_1_2" = callPackage

     

       45563
       45563
       -
           ({ mkDerivation, base, semigroups, zero }:

     

       45564
       45564
       -
            mkDerivation {

     

       45565
       45565
       -
              pname = "both";

     

       45566
       45457
        
              version = "0.1.1.2";

     

       45567
       45458
        
              sha256 = "1bf9fvc2ajbwwx31lmmyc1rzp3xzypwb3yjcmbhn6si5xnlbvqhl";

     

       45568
       45459
        
              libraryHaskellDepends = [ base semigroups zero ];

     

       45569
       45460
        
              description = "Like Maybe, but with a different Monoid instance";

     

       45570
       45461
        
              license = lib.licenses.mit;

     

       45571
       45571
       -
              hydraPlatforms = lib.platforms.none;

     

       45572
       45462
        
            }) {};

     

       45573
       45463
        
       

     

       45574
       45464
        
         "botpp" = callPackage

     
···

       47662
       47552
        
            }:

     

       47663
       47553
        
            mkDerivation {

     

       47664
       47554
        
              pname = "byte-count-reader";

     

       47665
       47665
       -
              version = "0.10.1.3";

     

       47666
       47666
       -
              sha256 = "1z02g8mkjwxdrbyxncbvrwg18knyiqa3w9n0x01y2xmbr279rsh0";

     

       47667
       47667
       -
              libraryHaskellDepends = [ base extra parsec parsec-numbers text ];

     

       47668
       47668
       -
              testHaskellDepends = [

     

       47669
       47669
       -
                base extra hspec parsec parsec-numbers text

     

       47670
       47670
       -
              ];

     

       47671
       47671
       -
              description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB";

     

       47672
       47672
       -
              license = lib.licenses.gpl3Only;

     

       47673
       47673
       -
            }) {};

     

       47674
       47674
       -
       

     

       47675
       47675
       -
         "byte-count-reader_0_10_1_5" = callPackage

     

       47676
       47676
       -
           ({ mkDerivation, base, extra, hspec, parsec, parsec-numbers, text

     

       47677
       47677
       -
            }:

     

       47678
       47678
       -
            mkDerivation {

     

       47679
       47679
       -
              pname = "byte-count-reader";

     

       47680
       47555
        
              version = "0.10.1.5";

     

       47681
       47556
        
              sha256 = "0iq40gnfw8z1rkri1rpaqx5av1ay45h6518cg0a0m4ypdzf03r0s";

     

       47682
       47557
        
              libraryHaskellDepends = [ base extra parsec parsec-numbers text ];

     
···

       47685
       47560
        
              ];

     

       47686
       47561
        
              description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB";

     

       47687
       47562
        
              license = lib.licenses.gpl3Only;

     

       47688
       47688
       -
              hydraPlatforms = lib.platforms.none;

     

       47689
       47563
        
            }) {};

     

       47690
       47564
        
       

     

       47691
       47565
        
         "byte-order" = callPackage

     
···

       49601
       49475
        
            }:

     

       49602
       49476
        
            mkDerivation {

     

       49603
       49477
        
              pname = "cabal-rpm";

     

       49604
       49604
       -
              version = "2.0.9";

     

       49605
       49605
       -
              sha256 = "1r6a0dki4wsrmq5xfjb9bkj0dl7cnhwdf46427k71ay90hmc6ncq";

     

       49606
       49606
       -
              isLibrary = false;

     

       49607
       49607
       -
              isExecutable = true;

     

       49608
       49608
       -
              executableHaskellDepends = [

     

       49609
       49609
       -
                base bytestring Cabal directory extra filepath http-client

     

       49610
       49610
       -
                http-client-tls http-conduit optparse-applicative process

     

       49611
       49611
       -
                simple-cabal simple-cmd simple-cmd-args time unix

     

       49612
       49612
       -
              ];

     

       49613
       49613
       -
              description = "RPM packaging tool for Haskell Cabal-based packages";

     

       49614
       49614
       -
              license = lib.licenses.gpl3Only;

     

       49615
       49615
       -
            }) {};

     

       49616
       49616
       -
       

     

       49617
       49617
       -
         "cabal-rpm_2_0_10" = callPackage

     

       49618
       49618
       -
           ({ mkDerivation, base, bytestring, Cabal, directory, extra

     

       49619
       49619
       -
            , filepath, http-client, http-client-tls, http-conduit

     

       49620
       49620
       -
            , optparse-applicative, process, simple-cabal, simple-cmd

     

       49621
       49621
       -
            , simple-cmd-args, time, unix

     

       49622
       49622
       -
            }:

     

       49623
       49623
       -
            mkDerivation {

     

       49624
       49624
       -
              pname = "cabal-rpm";

     

       49625
       49478
        
              version = "2.0.10";

     

       49626
       49479
        
              sha256 = "028kvvdm8dqjmk16ag8p1mb4d3nfyz1i6x8ijfcr45hrb93hdd77";

     

       49627
       49480
        
              isLibrary = false;

     
···

       49633
       49486
        
              ];

     

       49634
       49487
        
              description = "RPM packaging tool for Haskell Cabal-based packages";

     

       49635
       49488
        
              license = lib.licenses.gpl3Only;

     

       49636
       49636
       -
              hydraPlatforms = lib.platforms.none;

     

       49637
       49489
        
            }) {};

     

       49638
       49490
        
       

     

       49639
       49491
        
         "cabal-scripts" = callPackage

     
···

       53814
       53666
        
              description = "Character set detection using Mozilla's Universal Character Set Detector";

     

       53815
       53667
        
              license = "LGPL";

     

       53816
       53668
        
              platforms = [

     

       53817
       53817
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       53669
       53669
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       53670
       53670
       +
                "x86_64-linux"

     

       53818
       53671
        
              ];

     

       53819
       53672
        
            }) {};

     

       53820
       53673
        
       

     
···

       54391
       54244
        
            }:

     

       54392
       54245
        
            mkDerivation {

     

       54393
       54246
        
              pname = "chessIO";

     

       54394
       54394
       -
              version = "0.9.0.0";

     

       54395
       54395
       -
              sha256 = "0f8dd3w8az8fzidwiv2h6m52fppfp5b9zd0c1s4c815z3a3rxr4v";

     

       54247
       54247
       +
              version = "0.9.1.0";

     

       54248
       54248
       +
              sha256 = "19lkjrqji01kmfjm065xmlxsrwwr0z2vz2cz19wr0bx6sz4hw3zr";

     

       54396
       54249
        
              isLibrary = true;

     

       54397
       54250
        
              isExecutable = true;

     

       54398
       54251
        
              libraryHaskellDepends = [

     
···

       54491
       54344
        
            }) {};

     

       54492
       54345
        
       

     

       54493
       54346
        
         "chimera" = callPackage

     

       54494
       54494
       -
           ({ mkDerivation, adjunctions, base, distributive, gauge, mtl

     

       54495
       54495
       -
            , QuickCheck, random, tasty, tasty-hunit, tasty-quickcheck

     

       54496
       54496
       -
            , tasty-smallcheck, vector

     

       54497
       54497
       -
            }:

     

       54498
       54498
       -
            mkDerivation {

     

       54499
       54499
       -
              pname = "chimera";

     

       54500
       54500
       -
              version = "0.3.1.0";

     

       54501
       54501
       -
              sha256 = "09dk9x2har2k6apm1wlm2k5k97jf3qxy4rzx94rbfmhs5fhz0i99";

     

       54502
       54502
       -
              libraryHaskellDepends = [

     

       54503
       54503
       -
                adjunctions base distributive mtl vector

     

       54504
       54504
       -
              ];

     

       54505
       54505
       -
              testHaskellDepends = [

     

       54506
       54506
       -
                base QuickCheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck

     

       54507
       54507
       -
                vector

     

       54508
       54508
       -
              ];

     

       54509
       54509
       -
              benchmarkHaskellDepends = [ base gauge mtl random ];

     

       54510
       54510
       -
              description = "Lazy infinite streams with O(1) indexing";

     

       54511
       54511
       -
              license = lib.licenses.bsd3;

     

       54512
       54512
       -
            }) {};

     

       54513
       54513
       -
       

     

       54514
       54514
       -
         "chimera_0_3_2_0" = callPackage

     

       54515
       54347
        
           ({ mkDerivation, adjunctions, base, distributive, mtl, QuickCheck

     

       54516
       54348
        
            , random, tasty, tasty-bench, tasty-hunit, tasty-quickcheck

     

       54517
       54349
        
            , tasty-smallcheck, vector

     
···

       54530
       54362
        
              benchmarkHaskellDepends = [ base mtl random tasty-bench ];

     

       54531
       54363
        
              description = "Lazy infinite streams with O(1) indexing and applications for memoization";

     

       54532
       54364
        
              license = lib.licenses.bsd3;

     

       54533
       54533
       -
              hydraPlatforms = lib.platforms.none;

     

       54534
       54365
        
            }) {};

     

       54535
       54366
        
       

     

       54536
       54367
        
         "chiphunk" = callPackage

     
···

       55475
       55306
        
              benchmarkHaskellDepends = [ base criterion vector ];

     

       55476
       55307
        
              description = "Circular fixed-sized mutable vectors";

     

       55477
       55308
        
              license = lib.licenses.bsd3;

     

       55478
       55478
       -
              hydraPlatforms = lib.platforms.none;

     

       55479
       55479
       -
              broken = true;

     

       55480
       55309
        
            }) {};

     

       55481
       55310
        
       

     

       55482
       55311
        
         "circus" = callPackage

     
···

       55959
       55788
        
            }:

     

       55960
       55789
        
            mkDerivation {

     

       55961
       55790
        
              pname = "clash-ghc";

     

       55962
       55962
       -
              version = "1.4.2";

     

       55963
       55963
       -
              sha256 = "04sj88mcxszgbr8rxnrwa48r2pkf7h612507gcyk131f5kf6mkss";

     

       55964
       55964
       -
              isLibrary = true;

     

       55965
       55965
       -
              isExecutable = true;

     

       55966
       55966
       -
              libraryHaskellDepends = [

     

       55967
       55967
       -
                array base bifunctors bytestring Cabal clash-lib clash-prelude

     

       55968
       55968
       -
                concurrent-supply containers deepseq directory exceptions extra

     

       55969
       55969
       -
                filepath ghc ghc-boot ghc-prim ghc-typelits-extra

     

       55970
       55970
       -
                ghc-typelits-knownnat ghc-typelits-natnormalise ghci hashable

     

       55971
       55971
       -
                haskeline integer-gmp lens mtl primitive process reflection split

     

       55972
       55972
       -
                template-haskell text time transformers uniplate unix

     

       55973
       55973
       -
                unordered-containers utf8-string vector

     

       55974
       55974
       -
              ];

     

       55975
       55975
       -
              executableHaskellDepends = [ base ];

     

       55976
       55976
       -
              description = "Clash: a functional hardware description language - GHC frontend";

     

       55977
       55977
       -
              license = lib.licenses.bsd2;

     

       55978
       55978
       -
              hydraPlatforms = lib.platforms.none;

     

       55979
       55979
       -
            }) {};

     

       55980
       55980
       -
       

     

       55981
       55981
       -
         "clash-ghc_1_4_3" = callPackage

     

       55982
       55982
       -
           ({ mkDerivation, array, base, bifunctors, bytestring, Cabal

     

       55983
       55983
       -
            , clash-lib, clash-prelude, concurrent-supply, containers, deepseq

     

       55984
       55984
       -
            , directory, exceptions, extra, filepath, ghc, ghc-boot, ghc-prim

     

       55985
       55985
       -
            , ghc-typelits-extra, ghc-typelits-knownnat

     

       55986
       55986
       -
            , ghc-typelits-natnormalise, ghci, hashable, haskeline, integer-gmp

     

       55987
       55987
       -
            , lens, mtl, primitive, process, reflection, split

     

       55988
       55988
       -
            , template-haskell, text, time, transformers, uniplate, unix

     

       55989
       55989
       -
            , unordered-containers, utf8-string, vector

     

       55990
       55990
       -
            }:

     

       55991
       55991
       -
            mkDerivation {

     

       55992
       55992
       -
              pname = "clash-ghc";

     

       55993
       55791
        
              version = "1.4.3";

     

       55994
       55792
        
              sha256 = "00ipx45s2qdjv5cj6v3cg7dgwsw3sd8ai3cr1q9n1k6g26dzc3pw";

     

       55995
       55793
        
              isLibrary = true;

     
···

       56026
       55824
        
            }:

     

       56027
       55825
        
            mkDerivation {

     

       56028
       55826
        
              pname = "clash-lib";

     

       56029
       56029
       -
              version = "1.4.2";

     

       56030
       56030
       -
              sha256 = "1gismfz0pahhgfgra8kn34i3g82ip5nfy9aj38ym3rcnpg4aw10m";

     

       56031
       56031
       -
              enableSeparateDataOutput = true;

     

       56032
       56032
       -
              libraryHaskellDepends = [

     

       56033
       56033
       -
                aeson aeson-pretty ansi-terminal array attoparsec base

     

       56034
       56034
       -
                base16-bytestring binary bytestring clash-prelude concurrent-supply

     

       56035
       56035
       -
                containers cryptohash-sha256 data-binary-ieee754 data-default

     

       56036
       56036
       -
                deepseq directory dlist errors exceptions extra filepath ghc

     

       56037
       56037
       -
                ghc-boot-th hashable haskell-src-meta hint integer-gmp interpolate

     

       56038
       56038
       -
                lens mtl ordered-containers parsers pretty-show prettyprinter

     

       56039
       56039
       -
                primitive process reducers template-haskell temporary terminal-size

     

       56040
       56040
       -
                text text-show time transformers trifecta unordered-containers

     

       56041
       56041
       -
                utf8-string vector vector-binary-instances

     

       56042
       56042
       -
              ];

     

       56043
       56043
       -
              testHaskellDepends = [

     

       56044
       56044
       -
                aeson aeson-pretty base base16-bytestring bytestring clash-prelude

     

       56045
       56045
       -
                concurrent-supply containers data-default deepseq ghc

     

       56046
       56046
       -
                ghc-typelits-knownnat haskell-src-exts lens pretty-show

     

       56047
       56047
       -
                quickcheck-text tasty tasty-hunit tasty-quickcheck template-haskell

     

       56048
       56048
       -
                text transformers unordered-containers

     

       56049
       56049
       -
              ];

     

       56050
       56050
       -
              description = "Clash: a functional hardware description language - As a library";

     

       56051
       56051
       -
              license = lib.licenses.bsd2;

     

       56052
       56052
       -
              hydraPlatforms = lib.platforms.none;

     

       56053
       56053
       -
            }) {};

     

       56054
       56054
       -
       

     

       56055
       56055
       -
         "clash-lib_1_4_3" = callPackage

     

       56056
       56056
       -
           ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array

     

       56057
       56057
       -
            , attoparsec, base, base16-bytestring, binary, bytestring

     

       56058
       56058
       -
            , clash-prelude, concurrent-supply, containers, cryptohash-sha256

     

       56059
       56059
       -
            , data-binary-ieee754, data-default, deepseq, directory, dlist

     

       56060
       56060
       -
            , errors, exceptions, extra, filepath, ghc, ghc-boot-th

     

       56061
       56061
       -
            , ghc-typelits-knownnat, hashable, haskell-src-exts

     

       56062
       56062
       -
            , haskell-src-meta, hint, integer-gmp, interpolate, lens, mtl

     

       56063
       56063
       -
            , ordered-containers, parsers, pretty-show, prettyprinter

     

       56064
       56064
       -
            , primitive, process, quickcheck-text, reducers, tasty, tasty-hunit

     

       56065
       56065
       -
            , tasty-quickcheck, template-haskell, temporary, terminal-size

     

       56066
       56066
       -
            , text, text-show, time, transformers, trifecta

     

       56067
       56067
       -
            , unordered-containers, utf8-string, vector

     

       56068
       56068
       -
            , vector-binary-instances

     

       56069
       56069
       -
            }:

     

       56070
       56070
       -
            mkDerivation {

     

       56071
       56071
       -
              pname = "clash-lib";

     

       56072
       55827
        
              version = "1.4.3";

     

       56073
       55828
        
              sha256 = "0p6sf9wn25i1f0isqskpy35x6qm2ym63x9fpb54kbd1pp9xqgysl";

     

       56074
       55829
        
              enableSeparateDataOutput = true;

     
···

       56125
       55880
        
            }:

     

       56126
       55881
        
            mkDerivation {

     

       56127
       55882
        
              pname = "clash-prelude";

     

       56128
       56128
       -
              version = "1.4.2";

     

       56129
       56129
       -
              sha256 = "04hshjdddd9sk697zvbwlq6cdvyvdfrw670ksfdxxgssyrcsid95";

     

       56130
       56130
       -
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       56131
       56131
       -
              libraryHaskellDepends = [

     

       56132
       56132
       -
                array arrows base bifunctors binary bytestring constraints

     

       56133
       56133
       -
                containers data-binary-ieee754 data-default-class deepseq ghc-prim

     

       56134
       56134
       -
                ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise

     

       56135
       56135
       -
                half hashable integer-gmp interpolate lens QuickCheck

     

       56136
       56136
       -
                recursion-schemes reflection singletons template-haskell text

     

       56137
       56137
       -
                text-show th-abstraction th-lift th-orphans time transformers

     

       56138
       56138
       -
                type-errors uniplate vector

     

       56139
       56139
       -
              ];

     

       56140
       56140
       -
              testHaskellDepends = [

     

       56141
       56141
       -
                base deepseq doctest ghc-typelits-extra ghc-typelits-knownnat

     

       56142
       56142
       -
                ghc-typelits-natnormalise hedgehog hint quickcheck-classes-base

     

       56143
       56143
       -
                tasty tasty-hedgehog tasty-hunit tasty-quickcheck tasty-th

     

       56144
       56144
       -
                template-haskell

     

       56145
       56145
       -
              ];

     

       56146
       56146
       -
              benchmarkHaskellDepends = [

     

       56147
       56147
       -
                base criterion deepseq template-haskell

     

       56148
       56148
       -
              ];

     

       56149
       56149
       -
              description = "Clash: a functional hardware description language - Prelude library";

     

       56150
       56150
       -
              license = lib.licenses.bsd2;

     

       56151
       56151
       -
              hydraPlatforms = lib.platforms.none;

     

       56152
       56152
       -
              broken = true;

     

       56153
       56153
       -
            }) {};

     

       56154
       56154
       -
       

     

       56155
       56155
       -
         "clash-prelude_1_4_3" = callPackage

     

       56156
       56156
       -
           ({ mkDerivation, array, arrows, base, bifunctors, binary

     

       56157
       56157
       -
            , bytestring, Cabal, cabal-doctest, constraints, containers

     

       56158
       56158
       -
            , criterion, data-binary-ieee754, data-default-class, deepseq

     

       56159
       56159
       -
            , doctest, ghc-prim, ghc-typelits-extra, ghc-typelits-knownnat

     

       56160
       56160
       -
            , ghc-typelits-natnormalise, half, hashable, hedgehog, hint

     

       56161
       56161
       -
            , integer-gmp, interpolate, lens, QuickCheck

     

       56162
       56162
       -
            , quickcheck-classes-base, recursion-schemes, reflection

     

       56163
       56163
       -
            , singletons, tasty, tasty-hedgehog, tasty-hunit, tasty-quickcheck

     

       56164
       56164
       -
            , tasty-th, template-haskell, text, text-show, th-abstraction

     

       56165
       56165
       -
            , th-lift, th-orphans, time, transformers, type-errors, uniplate

     

       56166
       56166
       -
            , vector

     

       56167
       56167
       -
            }:

     

       56168
       56168
       -
            mkDerivation {

     

       56169
       56169
       -
              pname = "clash-prelude";

     

       56170
       55883
        
              version = "1.4.3";

     

       56171
       55884
        
              sha256 = "07mdl3196yb971hpcbysyaj6vciyrm1p5m9prcymkhkqh7vw9igy";

     

       56172
       55885
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       56207
       55920
        
              hydraPlatforms = lib.platforms.none;

     

       56208
       55921
        
            }) {};

     

       56209
       55922
        
       

     

       55923
       55923
       +
         "clash-shake" = callPackage

     

       55924
       55924
       +
           ({ mkDerivation, aeson, base, bytestring, clash-ghc, clash-lib

     

       55925
       55925
       +
            , clash-prelude, directory, ghc-typelits-extra

     

       55926
       55926
       +
            , ghc-typelits-knownnat, ghc-typelits-natnormalise, shake, split

     

       55927
       55927
       +
            , stache, text, unordered-containers

     

       55928
       55928
       +
            }:

     

       55929
       55929
       +
            mkDerivation {

     

       55930
       55930
       +
              pname = "clash-shake";

     

       55931
       55931
       +
              version = "0.1.0";

     

       55932
       55932
       +
              sha256 = "0zjlbi8p0wxaxgfxhljbp9vzhki3ll8g1qqv3gghqkh7cym73kgq";

     

       55933
       55933
       +
              libraryHaskellDepends = [

     

       55934
       55934
       +
                aeson base bytestring clash-ghc clash-lib clash-prelude directory

     

       55935
       55935
       +
                ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise

     

       55936
       55936
       +
                shake split stache text unordered-containers

     

       55937
       55937
       +
              ];

     

       55938
       55938
       +
              description = "Shake rules for building Clash programs";

     

       55939
       55939
       +
              license = lib.licenses.mit;

     

       55940
       55940
       +
              hydraPlatforms = lib.platforms.none;

     

       55941
       55941
       +
            }) {};

     

       55942
       55942
       +
       

     

       56210
       55943
        
         "clash-systemverilog" = callPackage

     

       56211
       55944
        
           ({ mkDerivation, base, clash-lib, clash-prelude, fgl, hashable

     

       56212
       55945
        
            , lens, mtl, text, unordered-containers, wl-pprint-text

     
···

       56258
       55991
        
              ];

     

       56259
       55992
        
              description = "CAES Language for Synchronous Hardware - VHDL backend";

     

       56260
       55993
        
              license = lib.licenses.bsd2;

     

       55994
       55994
       +
              hydraPlatforms = lib.platforms.none;

     

       55995
       55995
       +
            }) {};

     

       55996
       55996
       +
       

     

       55997
       55997
       +
         "clashilator" = callPackage

     

       55998
       55998
       +
           ({ mkDerivation, aeson, base, Cabal, clash-ghc, clash-lib

     

       55999
       55999
       +
            , containers, filepath, ghc, lens, optparse-applicative, shake

     

       56000
       56000
       +
            , stache, text, unordered-containers

     

       56001
       56001
       +
            }:

     

       56002
       56002
       +
            mkDerivation {

     

       56003
       56003
       +
              pname = "clashilator";

     

       56004
       56004
       +
              version = "0.1.0";

     

       56005
       56005
       +
              sha256 = "0nlyjhf4vy5ypimdv3ac9qw9aljm2k99y42b2pkhhw84iblv4qgy";

     

       56006
       56006
       +
              isLibrary = true;

     

       56007
       56007
       +
              isExecutable = true;

     

       56008
       56008
       +
              libraryHaskellDepends = [

     

       56009
       56009
       +
                aeson base Cabal clash-ghc clash-lib containers filepath ghc lens

     

       56010
       56010
       +
                optparse-applicative shake stache text unordered-containers

     

       56011
       56011
       +
              ];

     

       56012
       56012
       +
              executableHaskellDepends = [

     

       56013
       56013
       +
                aeson base Cabal clash-ghc clash-lib containers filepath ghc lens

     

       56014
       56014
       +
                optparse-applicative shake stache text unordered-containers

     

       56015
       56015
       +
              ];

     

       56016
       56016
       +
              description = "Automated Clash to Verilator bridge";

     

       56017
       56017
       +
              license = lib.licenses.mit;

     

       56261
       56018
        
              hydraPlatforms = lib.platforms.none;

     

       56262
       56019
        
            }) {};

     

       56263
       56020
        
       

     
···

       58186
       57943
        
           ({ mkDerivation, base, co-log-core, stm }:

     

       58187
       57944
        
            mkDerivation {

     

       58188
       57945
        
              pname = "co-log-concurrent";

     

       58189
       58189
       -
              version = "0.5.0.0";

     

       58190
       58190
       -
              sha256 = "07z4aklk7dc2fhbc30kd9hbdvq71sa4ip6r2pyifcpn3p2pr3mna";

     

       58191
       58191
       -
              libraryHaskellDepends = [ base co-log-core stm ];

     

       58192
       58192
       -
              description = "Asynchronous backend for co-log library";

     

       58193
       58193
       -
              license = lib.licenses.mpl20;

     

       58194
       58194
       -
            }) {};

     

       58195
       58195
       -
       

     

       58196
       58196
       -
         "co-log-concurrent_0_5_1_0" = callPackage

     

       58197
       58197
       -
           ({ mkDerivation, base, co-log-core, stm }:

     

       58198
       58198
       -
            mkDerivation {

     

       58199
       58199
       -
              pname = "co-log-concurrent";

     

       58200
       57946
        
              version = "0.5.1.0";

     

       58201
       57947
        
              sha256 = "07qmx9z03vmgq2cgz4352fsav7r1nx8n7svmrhg2lkdiyp0j7a59";

     

       58202
       57948
        
              libraryHaskellDepends = [ base co-log-core stm ];

     

       58203
       57949
        
              description = "Asynchronous backend for co-log library";

     

       58204
       57950
        
              license = lib.licenses.mpl20;

     

       58205
       58205
       -
              hydraPlatforms = lib.platforms.none;

     

       58206
       57951
        
            }) {};

     

       58207
       57952
        
       

     

       58208
       57953
        
         "co-log-core" = callPackage

     
···

       58722
       58467
        
           ({ mkDerivation, base, profunctors }:

     

       58723
       58468
        
            mkDerivation {

     

       58724
       58469
        
              pname = "coercible-subtypes";

     

       58725
       58725
       -
              version = "0.1.0.0";

     

       58726
       58726
       -
              sha256 = "1z5fmdgv52x410x2z4gxyac18f98226dymzdvhcvkx7mw2k9q44x";

     

       58727
       58727
       -
              revision = "1";

     

       58728
       58728
       -
              editedCabalFile = "05bd9lp5jp31ac039vq0p58kr03g5ai3cyymc4ikhbnl3x44hx4d";

     

       58470
       58470
       +
              version = "0.1.1.0";

     

       58471
       58471
       +
              sha256 = "1q6a38y49a31vl19i5c5kym36fjxspxj6vfi0b35j4gb9b7r642r";

     

       58729
       58472
        
              libraryHaskellDepends = [ base profunctors ];

     

       58730
       58473
        
              description = "Coercible but only in one direction";

     

       58731
       58474
        
              license = lib.licenses.bsd3;

     
···

       61424
       61167
        
            }:

     

       61425
       61168
        
            mkDerivation {

     

       61426
       61169
        
              pname = "concurrency";

     

       61427
       61427
       -
              version = "1.11.0.1";

     

       61428
       61428
       -
              sha256 = "0ds55wpkxlrw2x5ql34p9b05xlycnc4v7962f27a54nhrjfhb2ah";

     

       61429
       61429
       -
              libraryHaskellDepends = [

     

       61430
       61430
       -
                array atomic-primops base exceptions monad-control mtl stm

     

       61431
       61431
       -
                transformers

     

       61432
       61432
       -
              ];

     

       61433
       61433
       -
              description = "Typeclasses, functions, and data types for concurrency and STM";

     

       61434
       61434
       -
              license = lib.licenses.mit;

     

       61435
       61435
       -
            }) {};

     

       61436
       61436
       -
       

     

       61437
       61437
       -
         "concurrency_1_11_0_2" = callPackage

     

       61438
       61438
       -
           ({ mkDerivation, array, atomic-primops, base, exceptions

     

       61439
       61439
       -
            , monad-control, mtl, stm, transformers

     

       61440
       61440
       -
            }:

     

       61441
       61441
       -
            mkDerivation {

     

       61442
       61442
       -
              pname = "concurrency";

     

       61443
       61170
        
              version = "1.11.0.2";

     

       61444
       61171
        
              sha256 = "0c7nq4d29s49a3h9wzjdi3idm6r68vxn6ybphsbrk2vmwqyfq36y";

     

       61445
       61172
        
              libraryHaskellDepends = [

     
···

       61448
       61175
        
              ];

     

       61449
       61176
        
              description = "Typeclasses, functions, and data types for concurrency and STM";

     

       61450
       61177
        
              license = lib.licenses.mit;

     

       61451
       61451
       -
              hydraPlatforms = lib.platforms.none;

     

       61452
       61178
        
            }) {};

     

       61453
       61179
        
       

     

       61454
       61180
        
         "concurrency-benchmarks" = callPackage

     
···

       65811
       65537
        
              description = "Crack various integer, floating-point data formats";

     

       65812
       65538
        
              license = lib.licenses.bsd3;

     

       65813
       65539
        
              platforms = [

     

       65814
       65814
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       65540
       65540
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       65541
       65541
       +
                "x86_64-linux"

     

       65815
       65542
        
              ];

     

       65816
       65543
        
              hydraPlatforms = lib.platforms.none;

     

       65817
       65544
        
            }) {};

     
···

       65832
       65559
        
              description = "Crack various integer and floating-point data formats";

     

       65833
       65560
        
              license = lib.licenses.bsd3;

     

       65834
       65561
        
              platforms = [

     

       65835
       65835
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       65562
       65562
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       65563
       65563
       +
                "x86_64-linux"

     

       65836
       65564
        
              ];

     

       65837
       65565
        
            }) {};

     

       65838
       65566
        
       

     
···

       65852
       65580
        
              description = "Crack various integer and floating-point data formats";

     

       65853
       65581
        
              license = lib.licenses.bsd3;

     

       65854
       65582
        
              platforms = [

     

       65855
       65855
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       65583
       65583
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       65584
       65584
       +
                "x86_64-linux"

     

       65856
       65585
        
              ];

     

       65857
       65586
        
              hydraPlatforms = lib.platforms.none;

     

       65858
       65587
        
            }) {};

     
···

       66094
       65823
        
            }:

     

       66095
       65824
        
            mkDerivation {

     

       66096
       65825
        
              pname = "creatur";

     

       66097
       66097
       -
              version = "5.9.28";

     

       66098
       66098
       -
              sha256 = "11fscbkzyzajgg6m50s5x4rmxy1mxrgiqflamqxiwsyj9szw16xl";

     

       65826
       65826
       +
              version = "5.9.30";

     

       65827
       65827
       +
              sha256 = "1zxg8zkm1n78c80z6xqnnx6x8jzpfx0lfdjn26i9p3rr3wd78bf3";

     

       66099
       65828
        
              libraryHaskellDepends = [

     

       66100
       65829
        
                array base binary bytestring cereal cond directory exceptions

     

       66101
       65830
        
                filepath gray-extended hdaemonize hsyslog MonadRandom mtl random

     
···

       66323
       66052
        
              license = lib.licenses.bsd3;

     

       66324
       66053
        
            }) {};

     

       66325
       66054
        
       

     

       66055
       66055
       +
         "criterion_1_5_10_0" = callPackage

     

       66056
       66056
       +
           ({ mkDerivation, aeson, ansi-wl-pprint, base, base-compat

     

       66057
       66057
       +
            , base-compat-batteries, binary, binary-orphans, bytestring

     

       66058
       66058
       +
            , cassava, code-page, containers, criterion-measurement, deepseq

     

       66059
       66059
       +
            , directory, exceptions, filepath, Glob, HUnit, js-chart

     

       66060
       66060
       +
            , microstache, mtl, mwc-random, optparse-applicative, parsec

     

       66061
       66061
       +
            , QuickCheck, statistics, tasty, tasty-hunit, tasty-quickcheck

     

       66062
       66062
       +
            , text, time, transformers, transformers-compat, vector

     

       66063
       66063
       +
            , vector-algorithms

     

       66064
       66064
       +
            }:

     

       66065
       66065
       +
            mkDerivation {

     

       66066
       66066
       +
              pname = "criterion";

     

       66067
       66067
       +
              version = "1.5.10.0";

     

       66068
       66068
       +
              sha256 = "0akws27z3i9381xrb0p0h5qicz4w5nnxy8jq7gk68gi50gj0flxq";

     

       66069
       66069
       +
              isLibrary = true;

     

       66070
       66070
       +
              isExecutable = true;

     

       66071
       66071
       +
              enableSeparateDataOutput = true;

     

       66072
       66072
       +
              libraryHaskellDepends = [

     

       66073
       66073
       +
                aeson ansi-wl-pprint base base-compat-batteries binary

     

       66074
       66074
       +
                binary-orphans bytestring cassava code-page containers

     

       66075
       66075
       +
                criterion-measurement deepseq directory exceptions filepath Glob

     

       66076
       66076
       +
                js-chart microstache mtl mwc-random optparse-applicative parsec

     

       66077
       66077
       +
                statistics text time transformers transformers-compat vector

     

       66078
       66078
       +
                vector-algorithms

     

       66079
       66079
       +
              ];

     

       66080
       66080
       +
              executableHaskellDepends = [

     

       66081
       66081
       +
                base base-compat-batteries optparse-applicative

     

       66082
       66082
       +
              ];

     

       66083
       66083
       +
              testHaskellDepends = [

     

       66084
       66084
       +
                aeson base base-compat base-compat-batteries bytestring deepseq

     

       66085
       66085
       +
                directory HUnit QuickCheck statistics tasty tasty-hunit

     

       66086
       66086
       +
                tasty-quickcheck vector

     

       66087
       66087
       +
              ];

     

       66088
       66088
       +
              description = "Robust, reliable performance measurement and analysis";

     

       66089
       66089
       +
              license = lib.licenses.bsd3;

     

       66090
       66090
       +
              hydraPlatforms = lib.platforms.none;

     

       66091
       66091
       +
            }) {};

     

       66092
       66092
       +
       

     

       66326
       66093
        
         "criterion-cmp" = callPackage

     

       66327
       66094
        
           ({ mkDerivation, ansi-terminal, base, boxes, bytestring, cassava

     

       66328
       66095
        
            , containers, filepath, optparse-applicative, vector

     
···

       73186
       72953
        
            }:

     

       73187
       72954
        
            mkDerivation {

     

       73188
       72955
        
              pname = "dejafu";

     

       73189
       73189
       -
              version = "2.4.0.2";

     

       73190
       73190
       -
              sha256 = "1hwhyxjjwapk6jgsbs0vh033xbc9b8mr5iqd93vskvvljnb40v9h";

     

       73191
       73191
       -
              libraryHaskellDepends = [

     

       73192
       73192
       -
                base concurrency containers contravariant deepseq exceptions

     

       73193
       73193
       -
                leancheck profunctors random transformers

     

       73194
       73194
       -
              ];

     

       73195
       73195
       -
              description = "A library for unit-testing concurrent programs";

     

       73196
       73196
       -
              license = lib.licenses.mit;

     

       73197
       73197
       -
            }) {};

     

       73198
       73198
       -
       

     

       73199
       73199
       -
         "dejafu_2_4_0_3" = callPackage

     

       73200
       73200
       -
           ({ mkDerivation, base, concurrency, containers, contravariant

     

       73201
       73201
       -
            , deepseq, exceptions, leancheck, profunctors, random, transformers

     

       73202
       73202
       -
            }:

     

       73203
       73203
       -
            mkDerivation {

     

       73204
       73204
       -
              pname = "dejafu";

     

       73205
       72956
        
              version = "2.4.0.3";

     

       73206
       72957
        
              sha256 = "1qzc8jbl6zwbncfmfmcwwmmhwzgbwc7wmnxxxa3mbcjbwhyibf92";

     

       73207
       72958
        
              libraryHaskellDepends = [

     
···

       73210
       72961
        
              ];

     

       73211
       72962
        
              description = "A library for unit-testing concurrent programs";

     

       73212
       72963
        
              license = lib.licenses.mit;

     

       73213
       73213
       -
              hydraPlatforms = lib.platforms.none;

     

       73214
       72964
        
            }) {};

     

       73215
       72965
        
       

     

       73216
       72966
        
         "deka" = callPackage

     
···

       74686
       74436
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74687
       74437
        
            }) {};

     

       74688
       74438
        
       

     

       74439
       74439
       +
         "dhall_1_40_0" = callPackage

     

       74440
       74440
       +
           ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, atomic-write

     

       74441
       74441
       +
            , base, bytestring, case-insensitive, cborg, cborg-json, containers

     

       74442
       74442
       +
            , contravariant, cryptonite, data-fix, deepseq, Diff, directory

     

       74443
       74443
       +
            , doctest, dotgen, either, exceptions, filepath, foldl, gauge

     

       74444
       74444
       +
            , generic-random, half, hashable, haskeline, http-client

     

       74445
       74445
       +
            , http-client-tls, http-types, lens-family-core, megaparsec, memory

     

       74446
       74446
       +
            , mmorph, mockery, mtl, network-uri, optparse-applicative

     

       74447
       74447
       +
            , parser-combinators, parsers, pretty-simple, prettyprinter

     

       74448
       74448
       +
            , prettyprinter-ansi-terminal, profunctors, QuickCheck

     

       74449
       74449
       +
            , quickcheck-instances, repline, scientific, serialise

     

       74450
       74450
       +
            , special-values, spoon, tasty, tasty-expected-failure, tasty-hunit

     

       74451
       74451
       +
            , tasty-quickcheck, tasty-silver, template-haskell, temporary, text

     

       74452
       74452
       +
            , text-manipulate, th-lift-instances, time, transformers, turtle

     

       74453
       74453
       +
            , unordered-containers, uri-encode, vector

     

       74454
       74454
       +
            }:

     

       74455
       74455
       +
            mkDerivation {

     

       74456
       74456
       +
              pname = "dhall";

     

       74457
       74457
       +
              version = "1.40.0";

     

       74458
       74458
       +
              sha256 = "1a5hvfrygk9y9jlldyrbhfv9nzl03s6lqlmzf5dkwycwmfb7cc66";

     

       74459
       74459
       +
              isLibrary = true;

     

       74460
       74460
       +
              isExecutable = true;

     

       74461
       74461
       +
              enableSeparateDataOutput = true;

     

       74462
       74462
       +
              libraryHaskellDepends = [

     

       74463
       74463
       +
                aeson aeson-pretty ansi-terminal atomic-write base bytestring

     

       74464
       74464
       +
                case-insensitive cborg cborg-json containers contravariant

     

       74465
       74465
       +
                cryptonite data-fix deepseq Diff directory dotgen either exceptions

     

       74466
       74466
       +
                filepath half hashable haskeline http-client http-client-tls

     

       74467
       74467
       +
                http-types lens-family-core megaparsec memory mmorph mtl

     

       74468
       74468
       +
                network-uri optparse-applicative parser-combinators parsers

     

       74469
       74469
       +
                pretty-simple prettyprinter prettyprinter-ansi-terminal profunctors

     

       74470
       74470
       +
                repline scientific serialise template-haskell text text-manipulate

     

       74471
       74471
       +
                th-lift-instances time transformers unordered-containers uri-encode

     

       74472
       74472
       +
                vector

     

       74473
       74473
       +
              ];

     

       74474
       74474
       +
              executableHaskellDepends = [ base ];

     

       74475
       74475
       +
              testHaskellDepends = [

     

       74476
       74476
       +
                base bytestring cborg containers data-fix deepseq directory doctest

     

       74477
       74477
       +
                either filepath foldl generic-random http-client http-client-tls

     

       74478
       74478
       +
                lens-family-core megaparsec mockery prettyprinter QuickCheck

     

       74479
       74479
       +
                quickcheck-instances scientific serialise special-values spoon

     

       74480
       74480
       +
                tasty tasty-expected-failure tasty-hunit tasty-quickcheck

     

       74481
       74481
       +
                tasty-silver template-haskell temporary text time transformers

     

       74482
       74482
       +
                turtle unordered-containers vector

     

       74483
       74483
       +
              ];

     

       74484
       74484
       +
              benchmarkHaskellDepends = [

     

       74485
       74485
       +
                base bytestring containers directory gauge text

     

       74486
       74486
       +
              ];

     

       74487
       74487
       +
              doCheck = false;

     

       74488
       74488
       +
              description = "A configuration language guaranteed to terminate";

     

       74489
       74489
       +
              license = lib.licenses.bsd3;

     

       74490
       74490
       +
              hydraPlatforms = lib.platforms.none;

     

       74491
       74491
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74492
       74492
       +
            }) {};

     

       74493
       74493
       +
       

     

       74689
       74494
        
         "dhall-bash" = callPackage

     

       74690
       74495
        
           ({ mkDerivation, base, bytestring, containers, dhall

     

       74691
       74496
        
            , neat-interpolation, optparse-generic, shell-escape, text

     
···

       74708
       74513
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74709
       74514
        
            }) {};

     

       74710
       74515
        
       

     

       74516
       74516
       +
         "dhall-bash_1_0_38" = callPackage

     

       74517
       74517
       +
           ({ mkDerivation, base, bytestring, containers, dhall

     

       74518
       74518
       +
            , neat-interpolation, optparse-generic, shell-escape, text

     

       74519
       74519
       +
            }:

     

       74520
       74520
       +
            mkDerivation {

     

       74521
       74521
       +
              pname = "dhall-bash";

     

       74522
       74522
       +
              version = "1.0.38";

     

       74523
       74523
       +
              sha256 = "0pfwqz4l3nn4mr16pv5703j517g3nsgzpmiv18kzl4fs6141d881";

     

       74524
       74524
       +
              isLibrary = true;

     

       74525
       74525
       +
              isExecutable = true;

     

       74526
       74526
       +
              libraryHaskellDepends = [

     

       74527
       74527
       +
                base bytestring containers dhall neat-interpolation shell-escape

     

       74528
       74528
       +
                text

     

       74529
       74529
       +
              ];

     

       74530
       74530
       +
              executableHaskellDepends = [

     

       74531
       74531
       +
                base bytestring dhall optparse-generic text

     

       74532
       74532
       +
              ];

     

       74533
       74533
       +
              description = "Compile Dhall to Bash";

     

       74534
       74534
       +
              license = lib.licenses.bsd3;

     

       74535
       74535
       +
              hydraPlatforms = lib.platforms.none;

     

       74536
       74536
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74537
       74537
       +
            }) {};

     

       74538
       74538
       +
       

     

       74711
       74539
        
         "dhall-check" = callPackage

     

       74712
       74540
        
           ({ mkDerivation, base, containers, dhall, directory, filepath

     

       74713
       74541
        
            , fsnotify, text, trifecta

     
···

       74727
       74555
        
              broken = true;

     

       74728
       74556
        
            }) {};

     

       74729
       74557
        
       

     

       74558
       74558
       +
         "dhall-csv" = callPackage

     

       74559
       74559
       +
           ({ mkDerivation, ansi-terminal, base, bytestring, cassava

     

       74560
       74560
       +
            , containers, dhall, either, exceptions, filepath

     

       74561
       74561
       +
            , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal

     

       74562
       74562
       +
            , tasty, tasty-hunit, tasty-silver, text, unordered-containers

     

       74563
       74563
       +
            , vector

     

       74564
       74564
       +
            }:

     

       74565
       74565
       +
            mkDerivation {

     

       74566
       74566
       +
              pname = "dhall-csv";

     

       74567
       74567
       +
              version = "1.0.0";

     

       74568
       74568
       +
              sha256 = "1dg310mq4c00ykkm1vsvrcicls25zbx7iypcg0nqa8ggchac5jmh";

     

       74569
       74569
       +
              isLibrary = true;

     

       74570
       74570
       +
              isExecutable = true;

     

       74571
       74571
       +
              libraryHaskellDepends = [

     

       74572
       74572
       +
                base bytestring cassava containers dhall either exceptions filepath

     

       74573
       74573
       +
                optparse-applicative prettyprinter text unordered-containers vector

     

       74574
       74574
       +
              ];

     

       74575
       74575
       +
              executableHaskellDepends = [

     

       74576
       74576
       +
                ansi-terminal base bytestring cassava dhall optparse-applicative

     

       74577
       74577
       +
                prettyprinter prettyprinter-ansi-terminal text unordered-containers

     

       74578
       74578
       +
                vector

     

       74579
       74579
       +
              ];

     

       74580
       74580
       +
              testHaskellDepends = [

     

       74581
       74581
       +
                base bytestring cassava dhall filepath tasty tasty-hunit

     

       74582
       74582
       +
                tasty-silver text unordered-containers vector

     

       74583
       74583
       +
              ];

     

       74584
       74584
       +
              description = "Convert bidirectionally between Dhall and CSV files";

     

       74585
       74585
       +
              license = lib.licenses.bsd3;

     

       74586
       74586
       +
              hydraPlatforms = lib.platforms.none;

     

       74587
       74587
       +
              broken = true;

     

       74588
       74588
       +
            }) {};

     

       74589
       74589
       +
       

     

       74730
       74590
        
         "dhall-docs" = callPackage

     

       74731
       74591
        
           ({ mkDerivation, base, bytestring, containers, cryptonite, dhall

     

       74732
       74592
        
            , directory, doctest, file-embed, filepath, foldl, hashable

     
···

       74736
       74596
        
            }:

     

       74737
       74597
        
            mkDerivation {

     

       74738
       74598
        
              pname = "dhall-docs";

     

       74739
       74739
       -
              version = "1.0.6";

     

       74740
       74740
       -
              sha256 = "004n8kh8riw67aqwp6z9199jwv2c9r1dbkg92s71vd9zc04wxljv";

     

       74741
       74741
       -
              revision = "2";

     

       74742
       74742
       -
              editedCabalFile = "1z41z96qawc1i818ycp1ycdpxnysynipjjbi1pmrrgglv89hqjlq";

     

       74599
       74599
       +
              version = "1.0.7";

     

       74600
       74600
       +
              sha256 = "1h7bzpp3xa5m8zknhi24q0wh1n6w6z26ka780mdsbmchhhj59njm";

     

       74743
       74601
        
              isLibrary = true;

     

       74744
       74602
        
              isExecutable = true;

     

       74745
       74603
        
              enableSeparateDataOutput = true;

     
···

       74824
       74682
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74825
       74683
        
            }) {};

     

       74826
       74684
        
       

     

       74685
       74685
       +
         "dhall-json_1_7_8" = callPackage

     

       74686
       74686
       +
           ({ mkDerivation, aeson, aeson-pretty, aeson-yaml, ansi-terminal

     

       74687
       74687
       +
            , base, bytestring, containers, dhall, exceptions, filepath

     

       74688
       74688
       +
            , lens-family-core, optparse-applicative, prettyprinter

     

       74689
       74689
       +
            , prettyprinter-ansi-terminal, scientific, tasty, tasty-hunit

     

       74690
       74690
       +
            , tasty-silver, text, unordered-containers, vector

     

       74691
       74691
       +
            }:

     

       74692
       74692
       +
            mkDerivation {

     

       74693
       74693
       +
              pname = "dhall-json";

     

       74694
       74694
       +
              version = "1.7.8";

     

       74695
       74695
       +
              sha256 = "0g4c71di93r6vnbhajsj5k3ivhzvn0n0aicvvc2j9nbjfhvahd3h";

     

       74696
       74696
       +
              isLibrary = true;

     

       74697
       74697
       +
              isExecutable = true;

     

       74698
       74698
       +
              libraryHaskellDepends = [

     

       74699
       74699
       +
                aeson aeson-pretty aeson-yaml base bytestring containers dhall

     

       74700
       74700
       +
                exceptions filepath lens-family-core optparse-applicative

     

       74701
       74701
       +
                prettyprinter scientific text unordered-containers vector

     

       74702
       74702
       +
              ];

     

       74703
       74703
       +
              executableHaskellDepends = [

     

       74704
       74704
       +
                aeson aeson-pretty ansi-terminal base bytestring dhall exceptions

     

       74705
       74705
       +
                optparse-applicative prettyprinter prettyprinter-ansi-terminal text

     

       74706
       74706
       +
              ];

     

       74707
       74707
       +
              testHaskellDepends = [

     

       74708
       74708
       +
                aeson base bytestring dhall tasty tasty-hunit tasty-silver text

     

       74709
       74709
       +
              ];

     

       74710
       74710
       +
              description = "Convert between Dhall and JSON or YAML";

     

       74711
       74711
       +
              license = lib.licenses.bsd3;

     

       74712
       74712
       +
              hydraPlatforms = lib.platforms.none;

     

       74713
       74713
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74714
       74714
       +
            }) {};

     

       74715
       74715
       +
       

     

       74827
       74716
        
         "dhall-lex" = callPackage

     

       74828
       74717
        
           ({ mkDerivation, alex, array, base, bytestring, criterion, deepseq

     

       74829
       74718
        
            , hspec, hspec-dirstream, scientific

     
···

       74875
       74764
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74876
       74765
        
            }) {};

     

       74877
       74766
        
       

     

       74767
       74767
       +
         "dhall-lsp-server_1_0_16" = callPackage

     

       74768
       74768
       +
           ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers

     

       74769
       74769
       +
            , data-default, dhall, dhall-json, directory, doctest, filepath

     

       74770
       74770
       +
            , haskell-lsp, haskell-lsp-types, hslogger, hspec, lens, lsp-test

     

       74771
       74771
       +
            , megaparsec, mtl, network-uri, optparse-applicative, prettyprinter

     

       74772
       74772
       +
            , QuickCheck, rope-utf16-splay, tasty, tasty-hspec, text

     

       74773
       74773
       +
            , transformers, unordered-containers, uri-encode

     

       74774
       74774
       +
            }:

     

       74775
       74775
       +
            mkDerivation {

     

       74776
       74776
       +
              pname = "dhall-lsp-server";

     

       74777
       74777
       +
              version = "1.0.16";

     

       74778
       74778
       +
              sha256 = "04s4kvbjp4ai17l64syram0br3qc4fpz669ps24r8fkcbbaczckq";

     

       74779
       74779
       +
              isLibrary = true;

     

       74780
       74780
       +
              isExecutable = true;

     

       74781
       74781
       +
              libraryHaskellDepends = [

     

       74782
       74782
       +
                aeson aeson-pretty base bytestring containers data-default dhall

     

       74783
       74783
       +
                dhall-json directory filepath haskell-lsp hslogger lens megaparsec

     

       74784
       74784
       +
                mtl network-uri prettyprinter rope-utf16-splay text transformers

     

       74785
       74785
       +
                unordered-containers uri-encode

     

       74786
       74786
       +
              ];

     

       74787
       74787
       +
              executableHaskellDepends = [ base optparse-applicative ];

     

       74788
       74788
       +
              testHaskellDepends = [

     

       74789
       74789
       +
                base directory doctest filepath haskell-lsp-types hspec lsp-test

     

       74790
       74790
       +
                QuickCheck tasty tasty-hspec text

     

       74791
       74791
       +
              ];

     

       74792
       74792
       +
              description = "Language Server Protocol (LSP) server for Dhall";

     

       74793
       74793
       +
              license = lib.licenses.mit;

     

       74794
       74794
       +
              hydraPlatforms = lib.platforms.none;

     

       74795
       74795
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74796
       74796
       +
            }) {};

     

       74797
       74797
       +
       

     

       74878
       74798
        
         "dhall-nix" = callPackage

     

       74879
       74799
        
           ({ mkDerivation, base, containers, data-fix, dhall, hnix

     

       74880
       74800
        
            , lens-family-core, neat-interpolation, optparse-generic, text

     
···

       74899
       74819
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74900
       74820
        
            }) {};

     

       74901
       74821
        
       

     

       74822
       74822
       +
         "dhall-nix_1_1_22" = callPackage

     

       74823
       74823
       +
           ({ mkDerivation, base, containers, data-fix, dhall, hnix

     

       74824
       74824
       +
            , lens-family-core, neat-interpolation, optparse-generic, text

     

       74825
       74825
       +
            }:

     

       74826
       74826
       +
            mkDerivation {

     

       74827
       74827
       +
              pname = "dhall-nix";

     

       74828
       74828
       +
              version = "1.1.22";

     

       74829
       74829
       +
              sha256 = "1da64h52fz4imvk7hqblri27zg54r9rcs6hlyzkbnqg4yivpiclg";

     

       74830
       74830
       +
              isLibrary = true;

     

       74831
       74831
       +
              isExecutable = true;

     

       74832
       74832
       +
              libraryHaskellDepends = [

     

       74833
       74833
       +
                base containers data-fix dhall hnix lens-family-core

     

       74834
       74834
       +
                neat-interpolation text

     

       74835
       74835
       +
              ];

     

       74836
       74836
       +
              executableHaskellDepends = [

     

       74837
       74837
       +
                base dhall hnix optparse-generic text

     

       74838
       74838
       +
              ];

     

       74839
       74839
       +
              description = "Dhall to Nix compiler";

     

       74840
       74840
       +
              license = lib.licenses.bsd3;

     

       74841
       74841
       +
              hydraPlatforms = lib.platforms.none;

     

       74842
       74842
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74843
       74843
       +
            }) {};

     

       74844
       74844
       +
       

     

       74902
       74845
        
         "dhall-nixpkgs" = callPackage

     

       74903
       74846
        
           ({ mkDerivation, aeson, base, data-fix, dhall, foldl, hnix

     

       74904
       74847
        
            , lens-family-core, megaparsec, mmorph, neat-interpolation

     
···

       74907
       74850
        
            }:

     

       74908
       74851
        
            mkDerivation {

     

       74909
       74852
        
              pname = "dhall-nixpkgs";

     

       74910
       74910
       -
              version = "1.0.5";

     

       74911
       74911
       -
              sha256 = "10gvkw2rdmz7pgr9675xqnhkgi8pwjid77mwsriid81d703z2b6j";

     

       74912
       74912
       -
              revision = "2";

     

       74913
       74913
       -
              editedCabalFile = "1kb2bn9v6p6ma016gaq3332vpcd6rdalrmcvxzzys4vaa0l6nl68";

     

       74853
       74853
       +
              version = "1.0.6";

     

       74854
       74854
       +
              sha256 = "12sfxz7n86m69m1xbnrrr1ybggh70rfwmr4maflq522bhkc2hgvk";

     

       74914
       74855
        
              isLibrary = false;

     

       74915
       74856
        
              isExecutable = true;

     

       74916
       74857
        
              executableHaskellDepends = [

     
···

       74930
       74871
        
            }:

     

       74931
       74872
        
            mkDerivation {

     

       74932
       74873
        
              pname = "dhall-openapi";

     

       74933
       74933
       -
              version = "1.0.1";

     

       74934
       74934
       -
              sha256 = "1n34amb97dqpvz0s3mhqb46gjq1ix1gicsq700z6v6y7xssrgbz2";

     

       74935
       74935
       -
              revision = "1";

     

       74936
       74936
       -
              editedCabalFile = "03axb4pqa5p8fkdqxjz1xni8fxg66xr3pshfs2p3y13bgn0kn5z2";

     

       74874
       74874
       +
              version = "1.0.2";

     

       74875
       74875
       +
              sha256 = "1p678nn1gfj2xp0kmw8i5pzsv6s5bpnsmyng45adb9pnpiyxbcyj";

     

       74937
       74876
        
              isLibrary = true;

     

       74938
       74877
        
              isExecutable = true;

     

       74939
       74878
        
              libraryHaskellDepends = [

     
···

       74958
       74897
        
              pname = "dhall-recursive-adt";

     

       74959
       74898
        
              version = "0.1.0.1";

     

       74960
       74899
        
              sha256 = "09s3m86vflj5im2walab8d0wpvihsvxc5mzy55m10pfzr3gxsd11";

     

       74900
       74900
       +
              revision = "1";

     

       74901
       74901
       +
              editedCabalFile = "0phfa1y6fic6wyvm3bp56z4sj43wbf75rzggzgf763vivlnvc7xw";

     

       74961
       74902
        
              libraryHaskellDepends = [ base data-fix dhall recursion-schemes ];

     

       74962
       74903
        
              testHaskellDepends = [

     

       74963
       74904
        
                base dhall either hedgehog recursion-schemes tasty tasty-hedgehog

     
···

       75013
       74954
        
              ];

     

       75014
       74955
        
              description = "Compile Dhall expressions to Cabal files";

     

       75015
       74956
        
              license = lib.licenses.mit;

     

       74957
       74957
       +
              hydraPlatforms = lib.platforms.none;

     

       74958
       74958
       +
              broken = true;

     

       74959
       74959
       +
            }) {};

     

       74960
       74960
       +
       

     

       74961
       74961
       +
         "dhall-toml" = callPackage

     

       74962
       74962
       +
           ({ mkDerivation, base, containers, dhall, directory, doctest

     

       74963
       74963
       +
            , filepath, prettyprinter, tasty, tasty-hunit, text, tomland

     

       74964
       74964
       +
            , unordered-containers

     

       74965
       74965
       +
            }:

     

       74966
       74966
       +
            mkDerivation {

     

       74967
       74967
       +
              pname = "dhall-toml";

     

       74968
       74968
       +
              version = "1.0.0";

     

       74969
       74969
       +
              sha256 = "13pz6y0l70h3x62wkhay2jiws6s5m6dy9v7kpd2c5mqzaspfy0w2";

     

       74970
       74970
       +
              isLibrary = true;

     

       74971
       74971
       +
              isExecutable = true;

     

       74972
       74972
       +
              libraryHaskellDepends = [

     

       74973
       74973
       +
                base containers dhall prettyprinter text tomland

     

       74974
       74974
       +
                unordered-containers

     

       74975
       74975
       +
              ];

     

       74976
       74976
       +
              executableHaskellDepends = [ base ];

     

       74977
       74977
       +
              testHaskellDepends = [

     

       74978
       74978
       +
                base dhall directory doctest filepath tasty tasty-hunit text

     

       74979
       74979
       +
                tomland

     

       74980
       74980
       +
              ];

     

       74981
       74981
       +
              description = "Convert between Dhall and TOML";

     

       74982
       74982
       +
              license = lib.licenses.bsd3;

     

       75016
       74983
        
              hydraPlatforms = lib.platforms.none;

     

       75017
       74984
        
              broken = true;

     

       75018
       74985
        
            }) {};

     
···

       75046
       75013
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       75047
       75014
        
            }) {};

     

       75048
       75015
        
       

     

       75016
       75016
       +
         "dhall-yaml_1_2_8" = callPackage

     

       75017
       75017
       +
           ({ mkDerivation, aeson, ansi-terminal, base, bytestring, dhall

     

       75018
       75018
       +
            , dhall-json, exceptions, HsYAML, HsYAML-aeson

     

       75019
       75019
       +
            , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal

     

       75020
       75020
       +
            , tasty, tasty-expected-failure, tasty-hunit, text, vector

     

       75021
       75021
       +
            }:

     

       75022
       75022
       +
            mkDerivation {

     

       75023
       75023
       +
              pname = "dhall-yaml";

     

       75024
       75024
       +
              version = "1.2.8";

     

       75025
       75025
       +
              sha256 = "1p766ybwib3f2i5h7m1hh71vc255ahvf7237bpprdapqw3ag8nak";

     

       75026
       75026
       +
              isLibrary = true;

     

       75027
       75027
       +
              isExecutable = true;

     

       75028
       75028
       +
              libraryHaskellDepends = [

     

       75029
       75029
       +
                aeson base bytestring dhall dhall-json HsYAML HsYAML-aeson

     

       75030
       75030
       +
                optparse-applicative text vector

     

       75031
       75031
       +
              ];

     

       75032
       75032
       +
              executableHaskellDepends = [

     

       75033
       75033
       +
                aeson ansi-terminal base bytestring dhall dhall-json exceptions

     

       75034
       75034
       +
                optparse-applicative prettyprinter prettyprinter-ansi-terminal text

     

       75035
       75035
       +
              ];

     

       75036
       75036
       +
              testHaskellDepends = [

     

       75037
       75037
       +
                base bytestring dhall dhall-json tasty tasty-expected-failure

     

       75038
       75038
       +
                tasty-hunit text

     

       75039
       75039
       +
              ];

     

       75040
       75040
       +
              description = "Convert between Dhall and YAML";

     

       75041
       75041
       +
              license = lib.licenses.gpl3Only;

     

       75042
       75042
       +
              hydraPlatforms = lib.platforms.none;

     

       75043
       75043
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       75044
       75044
       +
            }) {};

     

       75045
       75045
       +
       

     

       75049
       75046
        
         "dhcp-lease-parser" = callPackage

     

       75050
       75047
        
           ({ mkDerivation, attoparsec, base, bytestring, chronos, ip, tasty

     

       75051
       75048
        
            , tasty-hunit, text

     
···

       75297
       75294
        
              pname = "diagrams-builder";

     

       75298
       75295
        
              version = "0.8.0.5";

     

       75299
       75296
        
              sha256 = "0dz617kfkvjf3f2zbphkdx1scglcjj162qsfk9xj7slbapnj918m";

     

       75300
       75300
       -
              revision = "1";

     

       75301
       75301
       -
              editedCabalFile = "0rcj755n729gs9rgmjwai1xacigwpyk4b91x0cadfsl7xrgqax0c";

     

       75297
       75297
       +
              revision = "2";

     

       75298
       75298
       +
              editedCabalFile = "1jys7j2s8shwh5yr7w597qd46ip5xqvszaqgpjvnx9fxazqp6r0v";

     

       75302
       75299
        
              configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];

     

       75303
       75300
        
              isLibrary = true;

     

       75304
       75301
        
              isExecutable = true;

     
···

       75328
       75325
        
              pname = "diagrams-cairo";

     

       75329
       75326
        
              version = "1.4.1.1";

     

       75330
       75327
        
              sha256 = "0vyd2yr55n7x71194i18lnbcshdjpnqw4qyq7vj5zx377rsz711k";

     

       75331
       75331
       -
              revision = "2";

     

       75332
       75332
       -
              editedCabalFile = "0ngbshqmb86sc9djmgkn3zc9l69bn3kdml7ld6qx36dsyq6mafq9";

     

       75328
       75328
       +
              revision = "3";

     

       75329
       75329
       +
              editedCabalFile = "16jm9g9rfc7d1dy2kwq3n9wfgcj8l6c0d54lym1r6b0arc7yjqlb";

     

       75333
       75330
        
              libraryHaskellDepends = [

     

       75334
       75331
        
                array base bytestring cairo colour containers data-default-class

     

       75335
       75332
        
                diagrams-core diagrams-lib filepath hashable JuicyPixels lens mtl

     
···

       75349
       75346
        
              pname = "diagrams-canvas";

     

       75350
       75347
        
              version = "1.4.1";

     

       75351
       75348
        
              sha256 = "1ihmv42412d8dk3s894zd70xd386wrk9ycxkid19barry1vz5plj";

     

       75352
       75352
       -
              revision = "1";

     

       75353
       75353
       -
              editedCabalFile = "12p6n6g4ab81b39d031vzwfj89qi5wm27srpyigf2v0zswppdyvn";

     

       75349
       75349
       +
              revision = "2";

     

       75350
       75350
       +
              editedCabalFile = "0x8iv0998nn42l0ph90xq50ca514m3zhac4s9zl1hc5hzivj10sl";

     

       75354
       75351
        
              libraryHaskellDepends = [

     

       75355
       75352
        
                base blank-canvas cmdargs containers data-default-class

     

       75356
       75353
        
                diagrams-core diagrams-lib lens mtl NumInstances

     
···

       75374
       75371
        
              pname = "diagrams-contrib";

     

       75375
       75372
        
              version = "1.4.4";

     

       75376
       75373
        
              sha256 = "043jpr7lqg708lzmv6cqys7312lfdwnf8ijcnpl4jkbvcwl87c1m";

     

       75377
       75377
       -
              revision = "2";

     

       75378
       75378
       -
              editedCabalFile = "1mkpq356z7b2q6ifa4f1k7whsmhgn3hww8scacca0q2wnc8p4xjg";

     

       75374
       75374
       +
              revision = "3";

     

       75375
       75375
       +
              editedCabalFile = "03drxpqhyv62kzsxiabhfjiayk79fpv8wrq4qapsjbv7ph2jhx2v";

     

       75379
       75376
        
              libraryHaskellDepends = [

     

       75380
       75377
        
                base circle-packing colour containers cubicbezier data-default

     

       75381
       75378
        
                data-default-class diagrams-core diagrams-lib diagrams-solve

     
···

       75437
       75434
        
              pname = "diagrams-graphviz";

     

       75438
       75435
        
              version = "1.4.1.1";

     

       75439
       75436
        
              sha256 = "0lscrxd682jvyrl5bj4dxp7593qwyis01sl0p4jm2jfn335wdq40";

     

       75440
       75440
       -
              revision = "1";

     

       75441
       75441
       -
              editedCabalFile = "1qx69541pxf71whfz2a913yzbhfcks2pyzfprkgrcmiiyv0a3i7b";

     

       75437
       75437
       +
              revision = "2";

     

       75438
       75438
       +
              editedCabalFile = "0cxg21lsahkrf129k5h82d4znm3861dqc597mgzwyl5f0ywhllzr";

     

       75442
       75439
        
              libraryHaskellDepends = [

     

       75443
       75440
        
                base containers diagrams-lib fgl graphviz split

     

       75444
       75441
        
              ];

     
···

       75476
       75473
        
              pname = "diagrams-haddock";

     

       75477
       75474
        
              version = "0.4.1";

     

       75478
       75475
        
              sha256 = "0p978saxsfad6d8wkjnp6i300cf58ps02yw7a1zzhjfgk5ih2qlb";

     

       75476
       75476
       +
              revision = "1";

     

       75477
       75477
       +
              editedCabalFile = "063j6drlybzbm6bf9yfix86hs3hvgb98sgh4rzgrqkq9kvarj2ij";

     

       75479
       75478
        
              isLibrary = true;

     

       75480
       75479
        
              isExecutable = true;

     

       75481
       75480
        
              libraryHaskellDepends = [

     
···

       75675
       75674
        
              pname = "diagrams-postscript";

     

       75676
       75675
        
              version = "1.5";

     

       75677
       75676
        
              sha256 = "00j58mc84srjvrf21v6zjxxlbw6b8ahhn1jmbq697w8kw3cvygpa";

     

       75678
       75678
       -
              revision = "2";

     

       75679
       75679
       -
              editedCabalFile = "0dyji1b8mcxaxwzgckkk3p3ji0prrp7rsin98f1hmyjlj3ih735b";

     

       75677
       75677
       +
              revision = "3";

     

       75678
       75678
       +
              editedCabalFile = "1aq214837jk85b2l79adm5rcrv8y929aspvix7yjq1skyrqgk7pa";

     

       75680
       75679
        
              libraryHaskellDepends = [

     

       75681
       75680
        
                base bytestring containers data-default-class diagrams-core

     

       75682
       75681
        
                diagrams-lib hashable lens monoid-extras mtl semigroups split

     
···

       75712
       75711
        
              pname = "diagrams-rasterific";

     

       75713
       75712
        
              version = "1.4.2.1";

     

       75714
       75713
        
              sha256 = "09a1jnpc4kplg1yhv5kxhi0ph22m5xyr0vmnjv2c5wlz72c72z2z";

     

       75715
       75715
       -
              revision = "1";

     

       75716
       75716
       -
              editedCabalFile = "1nc12hm4qbj2lmbpk3a77cd46n5bcf20vwd075qj2vglbca2yl9b";

     

       75714
       75714
       +
              revision = "2";

     

       75715
       75715
       +
              editedCabalFile = "1vd8njhanjaa86h0g8hb6khz11bv9zvg8l4pfx0dj4ypknz4hwak";

     

       75717
       75716
        
              libraryHaskellDepends = [

     

       75718
       75717
        
                base bytestring containers data-default-class diagrams-core

     

       75719
       75718
        
                diagrams-lib file-embed filepath FontyFruity hashable JuicyPixels

     
···

       75785
       75784
        
              pname = "diagrams-svg";

     

       75786
       75785
        
              version = "1.4.3";

     

       75787
       75786
        
              sha256 = "1ysv6cz0fngrndl4wjmw4hrdj2rik5fxa1dkxzwnlgf1xwpvxgk8";

     

       75788
       75788
       -
              revision = "3";

     

       75789
       75789
       -
              editedCabalFile = "19n3g9wvp2fj4dlz3ssyjqx1b6ihskg5s595x9z2c99bpbzyykkv";

     

       75787
       75787
       +
              revision = "4";

     

       75788
       75788
       +
              editedCabalFile = "0irjf0g1barr06fy409r0ld2hypihrhh6n80ig3487xxny6gfzs0";

     

       75790
       75789
        
              libraryHaskellDepends = [

     

       75791
       75790
        
                base base64-bytestring bytestring colour containers diagrams-core

     

       75792
       75791
        
                diagrams-lib filepath hashable JuicyPixels lens monoid-extras mtl

     
···

       89798
       89797
        
              broken = true;

     

       89799
       89798
        
            }) {};

     

       89800
       89799
        
       

     

       89801
       89801
       -
         "faktory_1_1_0_0" = callPackage

     

       89802
       89802
       -
           ({ mkDerivation, aeson, aeson-casing, async, base, bytestring

     

       89803
       89803
       -
            , connection, cryptonite, errors, hspec, markdown-unlit, megaparsec

     

       89804
       89804
       -
            , memory, mtl, network, random, safe-exceptions, scanner

     

       89805
       89805
       -
            , semigroups, text, time, unix, unordered-containers

     

       89800
       89800
       +
         "faktory_1_1_1_0" = callPackage

     

       89801
       89801
       +
           ({ mkDerivation, aeson, aeson-casing, aeson-qq, async, base

     

       89802
       89802
       +
            , bytestring, connection, cryptonite, errors, hspec, markdown-unlit

     

       89803
       89803
       +
            , megaparsec, memory, mtl, network, random, safe-exceptions

     

       89804
       89804
       +
            , scanner, semigroups, text, time, unix, unordered-containers

     

       89806
       89805
        
            }:

     

       89807
       89806
        
            mkDerivation {

     

       89808
       89807
        
              pname = "faktory";

     

       89809
       89809
       -
              version = "1.1.0.0";

     

       89810
       89810
       -
              sha256 = "0bxwrrypkwhq7whaj79dkibad022bdxd8r5vh1dnd4aka3bdk8mj";

     

       89808
       89808
       +
              version = "1.1.1.0";

     

       89809
       89809
       +
              sha256 = "1lh427lq991pclzqr112dw4jjalcxpkwl440ygg2fhl6bgn082wx";

     

       89811
       89810
        
              isLibrary = true;

     

       89812
       89811
        
              isExecutable = true;

     

       89813
       89812
        
              libraryHaskellDepends = [

     
···

       89817
       89816
        
              ];

     

       89818
       89817
        
              executableHaskellDepends = [ aeson base safe-exceptions ];

     

       89819
       89818
        
              testHaskellDepends = [

     

       89820
       89820
       -
                aeson async base hspec markdown-unlit mtl time

     

       89819
       89819
       +
                aeson aeson-qq async base hspec markdown-unlit mtl time

     

       89821
       89820
        
              ];

     

       89822
       89821
        
              testToolDepends = [ markdown-unlit ];

     

       89823
       89822
        
              description = "Faktory Worker for Haskell";

     
···

       89942
       89941
        
            }:

     

       89943
       89942
        
            mkDerivation {

     

       89944
       89943
        
              pname = "fast-builder";

     

       89945
       89945
       -
              version = "0.1.2.1";

     

       89946
       89946
       -
              sha256 = "0j11ahdmbni56car4zblwz9yz1qkrr6qbmpbah4fgpiyq6177cn9";

     

       89944
       89944
       +
              version = "0.1.3.0";

     

       89945
       89945
       +
              sha256 = "0j2dfh6y689sk5ahh232zl8glbmwp34xnqkmaq9n9jwbddw4fg5z";

     

       89947
       89946
        
              libraryHaskellDepends = [ base bytestring ghc-prim ];

     

       89948
       89947
        
              testHaskellDepends = [ base bytestring process QuickCheck stm ];

     

       89949
       89948
        
              benchmarkHaskellDepends = [

     
···

       89975
       89974
        
            }) {};

     

       89976
       89975
        
       

     

       89977
       89976
        
         "fast-digits" = callPackage

     

       89978
       89978
       -
           ({ mkDerivation, base, digits, gauge, integer-gmp, QuickCheck

     

       89979
       89979
       -
            , smallcheck, tasty, tasty-quickcheck, tasty-smallcheck

     

       89980
       89980
       -
            }:

     

       89981
       89981
       -
            mkDerivation {

     

       89982
       89982
       -
              pname = "fast-digits";

     

       89983
       89983
       -
              version = "0.3.0.0";

     

       89984
       89984
       -
              sha256 = "1vlmjlkmv1nmw1rriafm2hzkmqd5xnwgzmvrg6xxqj1ab5sdsafs";

     

       89985
       89985
       -
              libraryHaskellDepends = [ base integer-gmp ];

     

       89986
       89986
       -
              testHaskellDepends = [

     

       89987
       89987
       -
                base digits QuickCheck smallcheck tasty tasty-quickcheck

     

       89988
       89988
       -
                tasty-smallcheck

     

       89989
       89989
       -
              ];

     

       89990
       89990
       -
              benchmarkHaskellDepends = [ base digits gauge ];

     

       89991
       89991
       -
              doHaddock = false;

     

       89992
       89992
       -
              description = "Integer-to-digits conversion";

     

       89993
       89993
       -
              license = lib.licenses.gpl3Only;

     

       89994
       89994
       -
              hydraPlatforms = lib.platforms.none;

     

       89995
       89995
       -
            }) {};

     

       89996
       89996
       -
       

     

       89997
       89997
       -
         "fast-digits_0_3_1_0" = callPackage

     

       89998
       89977
        
           ({ mkDerivation, base, integer-gmp, QuickCheck, smallcheck, tasty

     

       89999
       89978
        
            , tasty-bench, tasty-quickcheck, tasty-smallcheck

     

       90000
       89979
        
            }:

     
···

       90010
       89989
        
              doHaddock = false;

     

       90011
       89990
        
              description = "Integer-to-digits conversion";

     

       90012
       89991
        
              license = lib.licenses.gpl3Only;

     

       90013
       90013
       -
              hydraPlatforms = lib.platforms.none;

     

       90014
       89992
        
            }) {};

     

       90015
       89993
        
       

     

       90016
       89994
        
         "fast-downward" = callPackage

     
···

       92104
       92082
        
            }) {};

     

       92105
       92083
        
       

     

       92106
       92084
        
         "filepath-bytestring" = callPackage

     

       92107
       92107
       -
           ({ mkDerivation, base, bytestring, filepath, QuickCheck, unix }:

     

       92108
       92108
       -
            mkDerivation {

     

       92109
       92109
       -
              pname = "filepath-bytestring";

     

       92110
       92110
       -
              version = "1.4.2.1.7";

     

       92111
       92111
       -
              sha256 = "00xayqjq2qvb4yj0ppx838cabg5cx9swh0mzfb8c6njk9y5rc41n";

     

       92112
       92112
       -
              libraryHaskellDepends = [ base bytestring unix ];

     

       92113
       92113
       -
              testHaskellDepends = [ base bytestring filepath QuickCheck ];

     

       92114
       92114
       -
              description = "Library for manipulating RawFilePaths in a cross platform way";

     

       92115
       92115
       -
              license = lib.licenses.bsd3;

     

       92116
       92116
       -
            }) {};

     

       92117
       92117
       -
       

     

       92118
       92118
       -
         "filepath-bytestring_1_4_2_1_8" = callPackage

     

       92119
       92085
        
           ({ mkDerivation, base, bytestring, criterion, filepath, QuickCheck

     

       92120
       92086
        
            , unix

     

       92121
       92087
        
            }:

     
···

       92128
       92094
        
              benchmarkHaskellDepends = [ base criterion filepath ];

     

       92129
       92095
        
              description = "Library for manipulating RawFilePaths in a cross platform way";

     

       92130
       92096
        
              license = lib.licenses.bsd3;

     

       92131
       92131
       -
              hydraPlatforms = lib.platforms.none;

     

       92132
       92097
        
            }) {};

     

       92133
       92098
        
       

     

       92134
       92099
        
         "filepath-crypto" = callPackage

     
···

       96179
       96144
        
              broken = true;

     

       96180
       96145
        
            }) {};

     

       96181
       96146
        
       

     

       96147
       96147
       +
         "freckle-app" = callPackage

     

       96148
       96148
       +
           ({ mkDerivation, aeson, ansi-terminal, base, bytestring

     

       96149
       96149
       +
            , case-insensitive, conduit, data-default, datadog, directory

     

       96150
       96150
       +
            , doctest, errors, exceptions, fast-logger, filepath, Glob, hspec

     

       96151
       96151
       +
            , hspec-core, hspec-expectations-lifted, hspec-junit-formatter

     

       96152
       96152
       +
            , http-client, http-conduit, http-link-header, http-types, immortal

     

       96153
       96153
       +
            , iproute, lens, lens-aeson, load-env, monad-control, monad-logger

     

       96154
       96154
       +
            , MonadRandom, mtl, network, network-uri, persistent

     

       96155
       96155
       +
            , persistent-postgresql, postgresql-simple, primitive, process

     

       96156
       96156
       +
            , resource-pool, retry, rio, temporary, text, time, transformers

     

       96157
       96157
       +
            , transformers-base, unliftio, unliftio-core, wai, wai-extra, yaml

     

       96158
       96158
       +
            , yesod, yesod-core

     

       96159
       96159
       +
            }:

     

       96160
       96160
       +
            mkDerivation {

     

       96161
       96161
       +
              pname = "freckle-app";

     

       96162
       96162
       +
              version = "1.0.0.2";

     

       96163
       96163
       +
              sha256 = "1mrydqmwzwa391cb6pzxmjd5yl04f5xggz0wha7rm2a0pksgxphy";

     

       96164
       96164
       +
              libraryHaskellDepends = [

     

       96165
       96165
       +
                aeson ansi-terminal base bytestring case-insensitive conduit

     

       96166
       96166
       +
                data-default datadog doctest errors exceptions fast-logger filepath

     

       96167
       96167
       +
                Glob hspec hspec-core hspec-expectations-lifted

     

       96168
       96168
       +
                hspec-junit-formatter http-client http-conduit http-link-header

     

       96169
       96169
       +
                http-types immortal iproute lens load-env monad-control

     

       96170
       96170
       +
                monad-logger MonadRandom mtl network network-uri persistent

     

       96171
       96171
       +
                persistent-postgresql postgresql-simple primitive process

     

       96172
       96172
       +
                resource-pool retry rio text time transformers transformers-base

     

       96173
       96173
       +
                unliftio unliftio-core wai wai-extra yaml yesod yesod-core

     

       96174
       96174
       +
              ];

     

       96175
       96175
       +
              testHaskellDepends = [

     

       96176
       96176
       +
                aeson base bytestring directory hspec http-types lens lens-aeson

     

       96177
       96177
       +
                process temporary text time wai wai-extra

     

       96178
       96178
       +
              ];

     

       96179
       96179
       +
              description = "Haskell application toolkit used at Freckle";

     

       96180
       96180
       +
              license = lib.licenses.mit;

     

       96181
       96181
       +
              hydraPlatforms = lib.platforms.none;

     

       96182
       96182
       +
            }) {};

     

       96183
       96183
       +
       

     

       96182
       96184
        
         "freddy" = callPackage

     

       96183
       96185
        
           ({ mkDerivation, amqp, async, base, broadcast-chan, bytestring

     

       96184
       96186
        
            , data-default, hspec, random, text, uuid

     
···

       101931
       101933
        
           ({ mkDerivation, base, ghc }:

     

       101932
       101934
        
            mkDerivation {

     

       101933
       101935
        
              pname = "ghc-api-compat";

     

       101934
       101934
       -
              version = "8.10.5";

     

       101935
       101935
       -
              sha256 = "09g04k7zvzjs312yn9hhk8bk3l6k2vbb8qrdpnlr12a6az4adq3s";

     

       101936
       101936
       +
              version = "8.10.6";

     

       101937
       101937
       +
              sha256 = "1zrwa266v776w8rvcjggdpnyhs8kk36w5wrh63l16kxh58yc2vjz";

     

       101936
       101938
        
              libraryHaskellDepends = [ base ghc ];

     

       101937
       101939
        
              doHaddock = false;

     

       101938
       101940
        
              description = "GHC-API compatibility helpers";

     
···

       102528
       102530
        
            }:

     

       102529
       102531
        
            mkDerivation {

     

       102530
       102532
        
              pname = "ghc-lib";

     

       102531
       102531
       -
              version = "8.10.5.20210606";

     

       102532
       102532
       -
              sha256 = "0bl2jp44s3pd1a1sg0kslkhi97f4z2423kdkizg65m6cvmk25ijs";

     

       102533
       102533
       +
              version = "8.10.6.20210814";

     

       102534
       102534
       +
              sha256 = "0gnjps6xf5wq0nl4rlm4c1mqp3a3rbkwskv85fm852n5cf7bicd6";

     

       102533
       102535
        
              enableSeparateDataOutput = true;

     

       102534
       102536
        
              libraryHaskellDepends = [

     

       102535
       102537
        
                array base binary bytestring containers deepseq directory filepath

     
···

       102564
       102566
        
       

     

       102565
       102567
        
         "ghc-lib-parser" = callPackage

     

       102566
       102568
        
           ({ mkDerivation, alex, array, base, binary, bytestring, containers

     

       102567
       102567
       -
            , deepseq, directory, filepath, ghc-prim, happy, hpc, pretty

     

       102568
       102568
       -
            , process, time, transformers, unix

     

       102569
       102569
       +
            , deepseq, directory, filepath, ghc-prim, happy, pretty, process

     

       102570
       102570
       +
            , time, transformers, unix

     

       102569
       102571
        
            }:

     

       102570
       102572
        
            mkDerivation {

     

       102571
       102573
        
              pname = "ghc-lib-parser";

     

       102572
       102572
       -
              version = "8.10.5.20210606";

     

       102573
       102573
       -
              sha256 = "0pqsq49kvqwgbi6jw0dycbdzyldi0sannyqkfzavhqjf4mwjzn4a";

     

       102574
       102574
       +
              version = "8.10.6.20210814";

     

       102575
       102575
       +
              sha256 = "16kmm5wv3kym3qjq43pldycnira64zyga2c4b2vccvlvbi0v40hi";

     

       102574
       102576
        
              enableSeparateDataOutput = true;

     

       102575
       102577
        
              libraryHaskellDepends = [

     

       102576
       102578
        
                array base binary bytestring containers deepseq directory filepath

     

       102577
       102577
       -
                ghc-prim hpc pretty process time transformers unix

     

       102579
       102579
       +
                ghc-prim pretty process time transformers unix

     

       102578
       102580
        
              ];

     

       102579
       102581
        
              libraryToolDepends = [ alex happy ];

     

       102580
       102582
        
              description = "The GHC API, decoupled from GHC versions";

     
···

       102609
       102611
        
            }:

     

       102610
       102612
        
            mkDerivation {

     

       102611
       102613
        
              pname = "ghc-lib-parser-ex";

     

       102612
       102612
       -
              version = "8.10.0.21";

     

       102613
       102613
       -
              sha256 = "0ynrn7qdmim35fs9qdlbajqwyz559x1l9cqmjhb54vbrs2xnk6vp";

     

       102614
       102614
       +
              version = "8.10.0.22";

     

       102615
       102615
       +
              sha256 = "1a1yhm8rflln6m8sn2bbh5x6cbn20zfq91vfk1ywmia0v5y2sx03";

     

       102614
       102616
        
              libraryHaskellDepends = [

     

       102615
       102617
        
                base bytestring containers ghc ghc-boot ghc-boot-th uniplate

     

       102616
       102618
        
              ];

     
···

       112156
       112158
        
            }:

     

       112157
       112159
        
            mkDerivation {

     

       112158
       112160
        
              pname = "gray-extended";

     

       112159
       112159
       -
              version = "1.5.8";

     

       112160
       112160
       -
              sha256 = "1vli6dc0wc1an6vfhchai6s8xrg8rfds2k07x2xszaqg7r2njc9k";

     

       112161
       112161
       +
              version = "1.5.9";

     

       112162
       112162
       +
              sha256 = "0j2qw42fv5pg6v6bq51hk6lw3gcz35xd1gfvm8i74irv6bqialgy";

     

       112161
       112163
        
              libraryHaskellDepends = [ base ];

     

       112162
       112164
        
              testHaskellDepends = [

     

       112163
       112165
        
                base QuickCheck test-framework test-framework-quickcheck2

     
···

       112396
       112398
        
            }:

     

       112397
       112399
        
            mkDerivation {

     

       112398
       112400
        
              pname = "grid";

     

       112399
       112399
       -
              version = "7.8.14";

     

       112400
       112400
       -
              sha256 = "11rnsl6bs6qpx90p8jzdigncv6m5wbn6sav8gb3mlbm40fpi3p93";

     

       112401
       112401
       +
              version = "7.8.15";

     

       112402
       112402
       +
              sha256 = "0fsgax3xpdhnwn67s4wqqpvmm98j7b1fp6lrx98m15nxmjqb7rcc";

     

       112401
       112403
        
              libraryHaskellDepends = [ base containers ];

     

       112402
       112404
        
              testHaskellDepends = [

     

       112403
       112405
        
                base QuickCheck test-framework test-framework-quickcheck2

     
···

       113330
       113332
        
              libraryPkgconfigDepends = [ gtk-mac-integration-gtk2 ];

     

       113331
       113333
        
              description = "Bindings for the Gtk/OS X integration library";

     

       113332
       113334
        
              license = lib.licenses.lgpl21Only;

     

       113333
       113333
       -
              platforms = [ "x86_64-darwin" ];

     

       113335
       113335
       +
              platforms = [ "aarch64-darwin" "x86_64-darwin" ];

     

       113334
       113336
        
              hydraPlatforms = lib.platforms.none;

     

       113335
       113337
        
              broken = true;

     

       113336
       113338
        
            }) {inherit (pkgs) gtk-mac-integration-gtk2;};

     
···

       118869
       118871
        
              pname = "hashable";

     

       118870
       118872
        
              version = "1.3.2.0";

     

       118871
       118873
        
              sha256 = "0dyn343wdwbm1facpcjiyd8w0s0hk23jqh7mbj108az5dx5rdgar";

     

       118874
       118874
       +
              revision = "1";

     

       118875
       118875
       +
              editedCabalFile = "05jwmd6d127vykb1y13q7sjn5mhfs5pbbkal33jq5kg1rx3hj6kq";

     

       118872
       118876
        
              libraryHaskellDepends = [

     

       118873
       118877
        
                base bytestring deepseq ghc-prim integer-gmp text

     

       118874
       118878
        
              ];

     
···

       122173
       122177
        
            }:

     

       122174
       122178
        
            mkDerivation {

     

       122175
       122179
        
              pname = "hasklepias";

     

       122176
       122176
       -
              version = "0.15.1";

     

       122177
       122177
       -
              sha256 = "00n9fan0g3xdl9k0f0rw32xgrwzxb8x85vrj98yyk1dk490pgfhm";

     

       122180
       122180
       +
                base containers criterion deepseq fingertree hashable random time

     

       122181
       122181
       +
              sha256 = "19bskg552zfkfxrkgp7s3pcwjccn3ra3qc13inis55gxg56gwcs0";

     

       122178
       122182
        
              isLibrary = true;

     

       122179
       122183
        
              isExecutable = true;

     

       122180
       122184
        
              libraryHaskellDepends = [

     
···

       127511
       127515
        
              description = "Ethereum virtual machine evaluator";

     

       127512
       127516
        
              license = lib.licenses.agpl3Only;

     

       127513
       127517
        
              platforms = [

     

       127514
       127514
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       127518
       127518
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       127519
       127519
       +
                "x86_64-linux"

     

       127515
       127520
        
              ];

     

       127516
       127521
        
            }) {inherit (pkgs) libff; inherit (pkgs) secp256k1;};

     

       127517
       127522
        
       

     
···

       128147
       128152
        
                base containers criterion deepseq fingertree hashable random time

     

       128148
       128153
        
                base containers criterion deepseq fingertree hashable random time

     

       128149
       128154
        
              license = lib.licenses.bsd3;

     

       128150
       128150
       -
              platforms = [ "x86_64-darwin" ];

     

       128155
       128155
       +
              platforms = [ "aarch64-darwin" "x86_64-darwin" ];

     

       128151
       128156
        
                base containers criterion deepseq fingertree hashable random time

     

       128152
       128157
        
                base containers criterion deepseq fingertree hashable random time

     

       128153
       128158
        
       

     
···

       134726
       134731
        
       

     

       134727
       134732
        
         "hpack-dhall" = callPackage

     

       134728
       134733
        
           ({ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal

     

       134729
       134729
       -
            , dhall, dhall-json, Diff, directory, filepath, hpack, megaparsec

     

       134730
       134730
       -
            , microlens, optparse-applicative, prettyprinter, tasty

     

       134731
       134731
       -
            , tasty-golden, text, transformers, utf8-string, yaml

     

       134732
       134732
       -
            }:

     

       134733
       134733
       -
            mkDerivation {

     

       134734
       134734
       -
              pname = "hpack-dhall";

     

       134735
       134735
       -
              version = "0.5.2";

     

       134736
       134736
       -
              sha256 = "16mnh9hwp0224cn3rlpbjgqklgvbaffbzjskyksakpgxc0phk1zi";

     

       134737
       134737
       -
              isLibrary = true;

     

       134738
       134738
       -
              isExecutable = true;

     

       134739
       134739
       -
              libraryHaskellDepends = [

     

       134740
       134740
       -
                aeson aeson-pretty base bytestring dhall dhall-json filepath hpack

     

       134741
       134741
       -
                megaparsec microlens prettyprinter text transformers yaml

     

       134742
       134742
       -
              ];

     

       134743
       134743
       -
              executableHaskellDepends = [

     

       134744
       134744
       -
                aeson aeson-pretty base bytestring dhall dhall-json filepath hpack

     

       134745
       134745
       -
                megaparsec microlens optparse-applicative prettyprinter text

     

       134746
       134746
       -
                transformers yaml

     

       134747
       134747
       -
              ];

     

       134748
       134748
       -
              testHaskellDepends = [

     

       134749
       134749
       -
                aeson aeson-pretty base bytestring Cabal dhall dhall-json Diff

     

       134750
       134750
       -
                directory filepath hpack megaparsec microlens prettyprinter tasty

     

       134751
       134751
       -
                tasty-golden text transformers utf8-string yaml

     

       134752
       134752
       -
              ];

     

       134753
       134753
       -
              description = "hpack's dhalling";

     

       134754
       134754
       -
              license = lib.licenses.bsd3;

     

       134755
       134755
       -
            }) {};

     

       134756
       134756
       -
       

     

       134757
       134757
       -
         "hpack-dhall_0_5_3" = callPackage

     

       134758
       134758
       -
           ({ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal

     

       134759
       134734
        
            , dhall, dhall-json, Diff, directory, filepath, hlint, hpack

     

       134760
       134735
        
            , megaparsec, microlens, optparse-applicative, prettyprinter, tasty

     

       134761
       134736
        
            , tasty-golden, text, transformers, utf8-string, yaml

     
···

       134782
       134757
        
              ];

     

       134783
       134758
        
              description = "hpack's dhalling";

     

       134784
       134759
        
              license = lib.licenses.bsd3;

     

       134785
       134785
       -
              hydraPlatforms = lib.platforms.none;

     

       134786
       134760
        
            }) {};

     

       134787
       134761
        
       

     

       134788
       134762
        
         "hpaco" = callPackage

     
···

       136643
       136617
        
              isExecutable = true;

     

       136644
       136618
        
              executableHaskellDepends = [

     

       136645
       136619
        
                base Cabal containers directory filepath ghc mtl process strict

     

       136620
       136620
       +
              ];

     

       136621
       136621
       +
              description = "Create tag files (ctags and etags) for Haskell code";

     

       136622
       136622
       +
              license = lib.licenses.mit;

     

       136623
       136623
       +
              hydraPlatforms = lib.platforms.none;

     

       136624
       136624
       +
              broken = true;

     

       136625
       136625
       +
            }) {};

     

       136626
       136626
       +
       

     

       136627
       136627
       +
         "hs-tags_0_1_5_1" = callPackage

     

       136628
       136628
       +
           ({ mkDerivation, base, Cabal, containers, directory, filepath, ghc

     

       136629
       136629
       +
            , ghc-paths, mtl, process, strict

     

       136630
       136630
       +
            }:

     

       136631
       136631
       +
            mkDerivation {

     

       136632
       136632
       +
              pname = "hs-tags";

     

       136633
       136633
       +
              version = "0.1.5.1";

     

       136634
       136634
       +
              sha256 = "1yk1x24qar19hx47yjlr4f1qz3ld45hzpc74yxak73rsz08c08dx";

     

       136635
       136635
       +
              isLibrary = false;

     

       136636
       136636
       +
              isExecutable = true;

     

       136637
       136637
       +
              executableHaskellDepends = [

     

       136638
       136638
       +
                base Cabal containers directory filepath ghc ghc-paths mtl process

     

       136639
       136639
       +
                strict

     

       136646
       136640
        
              ];

     

       136647
       136641
        
              description = "Create tag files (ctags and etags) for Haskell code";

     

       136648
       136642
        
              license = lib.licenses.mit;

     
···

       140087
       140081
        
            }:

     

       140088
       140082
        
            mkDerivation {

     

       140089
       140083
        
              pname = "hspretty";

     

       140090
       140090
       -
              version = "0.1.0.0";

     

       140091
       140091
       -
              sha256 = "11mbrr785j6pa02zil705sy67cdvjhwq9l927mm74barf9ph776r";

     

       140084
       140084
       +
              version = "0.2.0.0";

     

       140085
       140085
       +
              sha256 = "1nxsw25a8g8xhfbcybsamn64bzrr7gl2q6ydd62zj073bkh413iq";

     

       140092
       140086
        
              isLibrary = true;

     

       140093
       140087
        
              isExecutable = true;

     

       140094
       140088
        
              libraryHaskellDepends = [

     
···

       141134
       141128
        
            }:

     

       141135
       141129
        
            mkDerivation {

     

       141136
       141130
        
              pname = "html-conduit";

     

       141137
       141137
       -
              version = "1.3.2.1";

     

       141138
       141138
       -
              sha256 = "196c8zcnjp1pc5qvqxd8arx3xkw0a90rvg9mmiw2l4zwnx65709n";

     

       141139
       141139
       -
              libraryHaskellDepends = [

     

       141140
       141140
       -
                attoparsec base bytestring conduit conduit-extra containers

     

       141141
       141141
       -
                resourcet text transformers xml-conduit xml-types

     

       141142
       141142
       -
              ];

     

       141143
       141143
       -
              testHaskellDepends = [

     

       141144
       141144
       -
                base bytestring containers deepseq hspec HUnit text xml-conduit

     

       141145
       141145
       -
              ];

     

       141146
       141146
       -
              description = "Parse HTML documents using xml-conduit datatypes";

     

       141147
       141147
       -
              license = lib.licenses.mit;

     

       141148
       141148
       -
            }) {};

     

       141149
       141149
       -
       

     

       141150
       141150
       -
         "html-conduit_1_3_2_2" = callPackage

     

       141151
       141151
       -
           ({ mkDerivation, attoparsec, base, bytestring, conduit

     

       141152
       141152
       -
            , conduit-extra, containers, deepseq, hspec, HUnit, resourcet, text

     

       141153
       141153
       -
            , transformers, xml-conduit, xml-types

     

       141154
       141154
       -
            }:

     

       141155
       141155
       -
            mkDerivation {

     

       141156
       141156
       -
              pname = "html-conduit";

     

       141157
       141131
        
              version = "1.3.2.2";

     

       141158
       141132
        
              sha256 = "09bwrdam3y47kqllgg6w098ghqb8jb10dp4wxirsvx5ddpx9zpi6";

     

       141159
       141133
        
              libraryHaskellDepends = [

     
···

       141165
       141139
        
              ];

     

       141166
       141140
        
              description = "Parse HTML documents using xml-conduit datatypes";

     

       141167
       141141
        
              license = lib.licenses.mit;

     

       141168
       141168
       -
              hydraPlatforms = lib.platforms.none;

     

       141169
       141142
        
            }) {};

     

       141170
       141143
        
       

     

       141171
       141144
        
         "html-email-validate" = callPackage

     
···

       141979
       141952
        
              license = lib.licenses.bsd3;

     

       141980
       141953
        
            }) {};

     

       141981
       141954
        
       

     

       141955
       141955
       +
         "http-common_0_8_3_4" = callPackage

     

       141956
       141956
       +
           ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring

     

       141957
       141957
       +
            , case-insensitive, directory, mtl, network, random, text

     

       141958
       141958
       +
            , transformers, unordered-containers

     

       141959
       141959
       +
            }:

     

       141960
       141960
       +
            mkDerivation {

     

       141961
       141961
       +
              pname = "http-common";

     

       141962
       141962
       +
              version = "0.8.3.4";

     

       141963
       141963
       +
              sha256 = "1xpbnfac0fqa5r670ggwm4kq3cmz9jpaw9bx40j9w9qiw6xi4i28";

     

       141964
       141964
       +
              libraryHaskellDepends = [

     

       141965
       141965
       +
                base base64-bytestring blaze-builder bytestring case-insensitive

     

       141966
       141966
       +
                directory mtl network random text transformers unordered-containers

     

       141967
       141967
       +
              ];

     

       141968
       141968
       +
              description = "Common types for HTTP clients and servers";

     

       141969
       141969
       +
              license = lib.licenses.bsd3;

     

       141970
       141970
       +
              hydraPlatforms = lib.platforms.none;

     

       141971
       141971
       +
            }) {};

     

       141972
       141972
       +
       

     

       141982
       141973
        
         "http-conduit" = callPackage

     

       141983
       141974
        
           ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring

     

       141984
       141975
        
            , case-insensitive, conduit, conduit-extra, connection, cookie

     
···

       142628
       142619
        
              license = lib.licenses.bsd3;

     

       142629
       142620
        
            }) {};

     

       142630
       142621
        
       

     

       142622
       142622
       +
         "http-streams_0_8_9_4" = callPackage

     

       142623
       142623
       +
           ({ mkDerivation, aeson, aeson-pretty, attoparsec, base

     

       142624
       142624
       +
            , base64-bytestring, blaze-builder, bytestring, case-insensitive

     

       142625
       142625
       +
            , directory, filepath, ghc-prim, HsOpenSSL, hspec

     

       142626
       142626
       +
            , hspec-expectations, http-common, HUnit, io-streams, lifted-base

     

       142627
       142627
       +
            , mtl, network, network-uri, openssl-streams, random, snap-core

     

       142628
       142628
       +
            , snap-server, system-fileio, system-filepath, text, transformers

     

       142629
       142629
       +
            , unordered-containers

     

       142630
       142630
       +
            }:

     

       142631
       142631
       +
            mkDerivation {

     

       142632
       142632
       +
              pname = "http-streams";

     

       142633
       142633
       +
              version = "0.8.9.4";

     

       142634
       142634
       +
              sha256 = "03xdcb0v735xdrkjlm1w56mskh3x08cbsjrcd7wn4li65ixc20xa";

     

       142635
       142635
       +
              libraryHaskellDepends = [

     

       142636
       142636
       +
                aeson attoparsec base base64-bytestring blaze-builder bytestring

     

       142637
       142637
       +
                case-insensitive directory filepath HsOpenSSL http-common

     

       142638
       142638
       +
                io-streams mtl network network-uri openssl-streams text

     

       142639
       142639
       +
                transformers unordered-containers

     

       142640
       142640
       +
              ];

     

       142641
       142641
       +
              testHaskellDepends = [

     

       142642
       142642
       +
                aeson aeson-pretty attoparsec base base64-bytestring blaze-builder

     

       142643
       142643
       +
                bytestring case-insensitive directory ghc-prim HsOpenSSL hspec

     

       142644
       142644
       +
                hspec-expectations http-common HUnit io-streams lifted-base mtl

     

       142645
       142645
       +
                network network-uri openssl-streams random snap-core snap-server

     

       142646
       142646
       +
                system-fileio system-filepath text transformers

     

       142647
       142647
       +
                unordered-containers

     

       142648
       142648
       +
              ];

     

       142649
       142649
       +
              description = "An HTTP client using io-streams";

     

       142650
       142650
       +
              license = lib.licenses.bsd3;

     

       142651
       142651
       +
              hydraPlatforms = lib.platforms.none;

     

       142652
       142652
       +
            }) {};

     

       142653
       142653
       +
       

     

       142631
       142654
        
         "http-test" = callPackage

     

       142632
       142655
        
           ({ mkDerivation, aeson, base, bytestring, http-client, lens

     

       142633
       142656
        
            , lens-aeson, mtl, tasty, tasty-hunit, text, time, wreq

     
···

       143276
       143299
        
           ({ mkDerivation, base, dejafu, exceptions, HUnit }:

     

       143277
       143300
        
            mkDerivation {

     

       143278
       143301
        
              pname = "hunit-dejafu";

     

       143279
       143279
       -
              version = "2.0.0.4";

     

       143280
       143280
       -
              sha256 = "11d52blw31mcsg7c3w1f7khy3vk2p03h4c5z6ja6wb9k5bg4d004";

     

       143281
       143281
       -
              libraryHaskellDepends = [ base dejafu exceptions HUnit ];

     

       143282
       143282
       -
              description = "Deja Fu support for the HUnit test framework";

     

       143283
       143283
       -
              license = lib.licenses.mit;

     

       143284
       143284
       -
            }) {};

     

       143285
       143285
       -
       

     

       143286
       143286
       -
         "hunit-dejafu_2_0_0_5" = callPackage

     

       143287
       143287
       -
           ({ mkDerivation, base, dejafu, exceptions, HUnit }:

     

       143288
       143288
       -
            mkDerivation {

     

       143289
       143289
       -
              pname = "hunit-dejafu";

     

       143290
       143302
        
              version = "2.0.0.5";

     

       143291
       143303
        
              sha256 = "0pbsbj70a2m7zvk25wa8mi0ymxv4c49g2vgg8819wpjcrxw8sy64";

     

       143292
       143304
        
              libraryHaskellDepends = [ base dejafu exceptions HUnit ];

     

       143293
       143305
        
              description = "Deja Fu support for the HUnit test framework";

     

       143294
       143306
        
              license = lib.licenses.mit;

     

       143295
       143295
       -
              hydraPlatforms = lib.platforms.none;

     

       143296
       143307
        
            }) {};

     

       143297
       143308
        
       

     

       143298
       143309
        
         "hunit-gui" = callPackage

     
···

       149434
       149445
        
              license = lib.licenses.mit;

     

       149435
       149446
        
            }) {};

     

       149436
       149447
        
       

     

       149448
       149448
       +
         "inspection-testing_0_4_6_0" = callPackage

     

       149449
       149449
       +
           ({ mkDerivation, base, containers, ghc, mtl, template-haskell

     

       149450
       149450
       +
            , transformers

     

       149451
       149451
       +
            }:

     

       149452
       149452
       +
            mkDerivation {

     

       149453
       149453
       +
              pname = "inspection-testing";

     

       149454
       149454
       +
              version = "0.4.6.0";

     

       149455
       149455
       +
              sha256 = "0qz1npyycj4bvyly9xmjbnhw569l52h38gx02rk0r7zhapw83aig";

     

       149456
       149456
       +
              libraryHaskellDepends = [

     

       149457
       149457
       +
                base containers ghc mtl template-haskell transformers

     

       149458
       149458
       +
              ];

     

       149459
       149459
       +
              testHaskellDepends = [ base ];

     

       149460
       149460
       +
              description = "GHC plugin to do inspection testing";

     

       149461
       149461
       +
              license = lib.licenses.mit;

     

       149462
       149462
       +
              hydraPlatforms = lib.platforms.none;

     

       149463
       149463
       +
            }) {};

     

       149464
       149464
       +
       

     

       149437
       149465
        
         "inspector-wrecker" = callPackage

     

       149438
       149466
        
           ({ mkDerivation, aeson, base, bytestring, case-insensitive

     

       149439
       149467
        
            , connection, data-default, http-client, http-client-tls

     
···

       150214
       150242
        
            }) {};

     

       150215
       150243
        
       

     

       150216
       150244
        
         "interpolation" = callPackage

     

       150217
       150217
       -
           ({ mkDerivation, array, base, containers, QuickCheck, utility-ht }:

     

       150218
       150218
       -
            mkDerivation {

     

       150219
       150219
       -
              pname = "interpolation";

     

       150220
       150220
       -
              version = "0.1.1.1";

     

       150221
       150221
       -
              sha256 = "081xlf59xp0j1svigkqfcz5an3yl3p8f5402i6492hz9rpv5qwy5";

     

       150222
       150222
       -
              isLibrary = true;

     

       150223
       150223
       -
              isExecutable = true;

     

       150224
       150224
       -
              libraryHaskellDepends = [ base utility-ht ];

     

       150225
       150225
       -
              testHaskellDepends = [

     

       150226
       150226
       -
                array base containers QuickCheck utility-ht

     

       150227
       150227
       -
              ];

     

       150228
       150228
       -
              description = "piecewise linear and cubic Hermite interpolation";

     

       150229
       150229
       -
              license = lib.licenses.bsd3;

     

       150230
       150230
       -
            }) {};

     

       150231
       150231
       -
       

     

       150232
       150232
       -
         "interpolation_0_1_1_2" = callPackage

     

       150233
       150245
        
           ({ mkDerivation, array, base, containers, doctest-exitcode-stdio

     

       150234
       150246
        
            , doctest-lib, QuickCheck, utility-ht

     

       150235
       150247
        
            }:

     
···

       150246
       150258
        
              ];

     

       150247
       150259
        
              description = "piecewise linear and cubic Hermite interpolation";

     

       150248
       150260
        
              license = lib.licenses.bsd3;

     

       150249
       150249
       -
              hydraPlatforms = lib.platforms.none;

     

       150250
       150261
        
            }) {};

     

       150251
       150262
        
       

     

       150252
       150263
        
         "interpolator" = callPackage

     
···

       150337
       150348
        
            }:

     

       150338
       150349
        
            mkDerivation {

     

       150339
       150350
        
              pname = "interval-algebra";

     

       150340
       150340
       -
              version = "0.10.0";

     

       150341
       150341
       -
              sha256 = "1b1a78rssxaqiw42hbb1zqmlq4lmxkxxkhrm3ybqpmrqk492mckv";

     

       150351
       150351
       +
              version = "0.10.1";

     

       150352
       150352
       +
              sha256 = "1nplznmspji7g51g2xxsr2b5lahhxqnmbs180mm3zmvkam8zizri";

     

       150342
       150353
        
              libraryHaskellDepends = [

     

       150343
       150354
        
                base containers foldl QuickCheck safe time witherable

     

       150344
       150355
        
              ];

     
···

       151389
       151400
        
            }:

     

       151390
       151401
        
            mkDerivation {

     

       151391
       151402
        
              pname = "irc-client";

     

       151392
       151392
       -
              version = "1.1.2.1";

     

       151393
       151393
       -
              sha256 = "1zaa8na730m96flgiyzcwq95v2ianvflsw3abvdavf7xpq4s71ld";

     

       151394
       151394
       -
              libraryHaskellDepends = [

     

       151395
       151395
       -
                base bytestring conduit connection containers contravariant

     

       151396
       151396
       -
                exceptions irc-conduit irc-ctcp mtl network-conduit-tls old-locale

     

       151397
       151397
       -
                profunctors stm stm-chans text time tls transformers x509

     

       151398
       151398
       -
                x509-store x509-validation

     

       151399
       151399
       -
              ];

     

       151400
       151400
       -
              description = "An IRC client library";

     

       151401
       151401
       -
              license = lib.licenses.mit;

     

       151402
       151402
       -
              maintainers = with lib.maintainers; [ sternenseemann ];

     

       151403
       151403
       -
            }) {};

     

       151404
       151404
       -
       

     

       151405
       151405
       -
         "irc-client_1_1_2_2" = callPackage

     

       151406
       151406
       -
           ({ mkDerivation, base, bytestring, conduit, connection, containers

     

       151407
       151407
       -
            , contravariant, exceptions, irc-conduit, irc-ctcp, mtl

     

       151408
       151408
       -
            , network-conduit-tls, old-locale, profunctors, stm, stm-chans

     

       151409
       151409
       -
            , text, time, tls, transformers, x509, x509-store, x509-validation

     

       151410
       151410
       -
            }:

     

       151411
       151411
       -
            mkDerivation {

     

       151412
       151412
       -
              pname = "irc-client";

     

       151413
       151403
        
              version = "1.1.2.2";

     

       151414
       151404
        
              sha256 = "0hhaf7xhy3q48gkp2j01jjiiz0ww9mwwjh8brbqs8phlal03ks70";

     

       151415
       151405
        
              libraryHaskellDepends = [

     
···

       151420
       151410
        
              ];

     

       151421
       151411
        
              description = "An IRC client library";

     

       151422
       151412
        
              license = lib.licenses.mit;

     

       151423
       151423
       -
              hydraPlatforms = lib.platforms.none;

     

       151424
       151413
        
              maintainers = with lib.maintainers; [ sternenseemann ];

     

       151425
       151414
        
            }) {};

     

       151426
       151415
        
       

     
···

       151442
       151431
        
            }:

     

       151443
       151432
        
            mkDerivation {

     

       151444
       151433
        
              pname = "irc-conduit";

     

       151445
       151445
       -
              version = "0.3.0.4";

     

       151446
       151446
       -
              sha256 = "0asaddcbdcnbp0bbhvzaq5514nw2l1cp1gac3jbn4mh7brgfwjc1";

     

       151447
       151447
       -
              libraryHaskellDepends = [

     

       151448
       151448
       -
                async base bytestring conduit conduit-extra connection irc irc-ctcp

     

       151449
       151449
       -
                network-conduit-tls profunctors text time tls transformers

     

       151450
       151450
       -
                x509-validation

     

       151451
       151451
       -
              ];

     

       151452
       151452
       -
              description = "Streaming IRC message library using conduits";

     

       151453
       151453
       -
              license = lib.licenses.mit;

     

       151454
       151454
       -
            }) {};

     

       151455
       151455
       -
       

     

       151456
       151456
       -
         "irc-conduit_0_3_0_5" = callPackage

     

       151457
       151457
       -
           ({ mkDerivation, async, base, bytestring, conduit, conduit-extra

     

       151458
       151458
       -
            , connection, irc, irc-ctcp, network-conduit-tls, profunctors, text

     

       151459
       151459
       -
            , time, tls, transformers, x509-validation

     

       151460
       151460
       -
            }:

     

       151461
       151461
       -
            mkDerivation {

     

       151462
       151462
       -
              pname = "irc-conduit";

     

       151463
       151434
        
              version = "0.3.0.5";

     

       151464
       151435
        
              sha256 = "02ziqjzqdyaizhrrzlbq4ddkfjfjf58jvwqfzrbf0mf0f5scv9cz";

     

       151465
       151436
        
              libraryHaskellDepends = [

     
···

       151469
       151440
        
              ];

     

       151470
       151441
        
              description = "Streaming IRC message library using conduits";

     

       151471
       151442
        
              license = lib.licenses.mit;

     

       151472
       151472
       -
              hydraPlatforms = lib.platforms.none;

     

       151473
       151443
        
            }) {};

     

       151474
       151444
        
       

     

       151475
       151445
        
         "irc-core" = callPackage

     
···

       151494
       151464
        
           ({ mkDerivation, base, bytestring, text }:

     

       151495
       151465
        
            mkDerivation {

     

       151496
       151466
        
              pname = "irc-ctcp";

     

       151497
       151497
       -
              version = "0.1.3.0";

     

       151498
       151498
       -
              sha256 = "16mp9dpp57id760zc932dszd5r1ncskwwxrp0djka5r1alddjz6n";

     

       151499
       151499
       -
              libraryHaskellDepends = [ base bytestring text ];

     

       151500
       151500
       -
              description = "A CTCP encoding and decoding library for IRC clients";

     

       151501
       151501
       -
              license = lib.licenses.mit;

     

       151502
       151502
       -
            }) {};

     

       151503
       151503
       -
       

     

       151504
       151504
       -
         "irc-ctcp_0_1_3_1" = callPackage

     

       151505
       151505
       -
           ({ mkDerivation, base, bytestring, text }:

     

       151506
       151506
       -
            mkDerivation {

     

       151507
       151507
       -
              pname = "irc-ctcp";

     

       151508
       151467
        
              version = "0.1.3.1";

     

       151509
       151468
        
              sha256 = "1ckdbxnjv96bpyhcpdi0vj6pjjq8wm4zyh75fps57wi1j61c4v2n";

     

       151510
       151469
        
              libraryHaskellDepends = [ base bytestring text ];

     

       151511
       151470
        
              description = "A CTCP encoding and decoding library for IRC clients";

     

       151512
       151471
        
              license = lib.licenses.mit;

     

       151513
       151513
       -
              hydraPlatforms = lib.platforms.none;

     

       151514
       151472
        
            }) {};

     

       151515
       151473
        
       

     

       151516
       151474
        
         "irc-dcc" = callPackage

     
···

       152004
       151962
        
              description = "A (bytestring-) builder for the ISO-14496-12 base media file format";

     

       152005
       151963
        
              license = lib.licenses.bsd3;

     

       152006
       151964
        
              hydraPlatforms = lib.platforms.none;

     

       151965
       151965
       +
            }) {};

     

       151966
       151966
       +
       

     

       151967
       151967
       +
         "isocline" = callPackage

     

       151968
       151968
       +
           ({ mkDerivation, base, bytestring, text }:

     

       151969
       151969
       +
            mkDerivation {

     

       151970
       151970
       +
              pname = "isocline";

     

       151971
       151971
       +
              version = "1.0.1";

     

       151972
       151972
       +
              sha256 = "1s57gqzhic1zjc0fn1j8l834cfa24w9q2rvhbxdfkb442qpw4piw";

     

       151973
       151973
       +
              isLibrary = true;

     

       151974
       151974
       +
              isExecutable = true;

     

       151975
       151975
       +
              libraryHaskellDepends = [ base bytestring text ];

     

       151976
       151976
       +
              executableHaskellDepends = [ base bytestring text ];

     

       151977
       151977
       +
              testHaskellDepends = [ base bytestring text ];

     

       151978
       151978
       +
              description = "A portable alternative to GNU Readline";

     

       151979
       151979
       +
              license = lib.licenses.mit;

     

       151980
       151980
       +
              hydraPlatforms = lib.platforms.none;

     

       151981
       151981
       +
              broken = true;

     

       152007
       151982
        
            }) {};

     

       152008
       151983
        
       

     

       152009
       151984
        
         "isohunt" = callPackage

     
···

       158256
       158231
        
              libraryToolDepends = [ c2hs ];

     

       158257
       158232
        
              description = "A binding to the kqueue event library";

     

       158258
       158233
        
              license = lib.licenses.bsd3;

     

       158259
       158259
       -
              platforms = [ "x86_64-darwin" ];

     

       158234
       158234
       +
              platforms = [ "aarch64-darwin" "x86_64-darwin" ];

     

       158260
       158235
        
            }) {};

     

       158261
       158236
        
       

     

       158262
       158237
        
         "kraken" = callPackage

     
···

       158453
       158428
        
              ];

     

       158454
       158429
        
              description = "Client library for Kubernetes";

     

       158455
       158430
        
              license = lib.licenses.asl20;

     

       158456
       158456
       -
              hydraPlatforms = lib.platforms.none;

     

       158457
       158431
        
            }) {};

     

       158458
       158432
        
       

     

       158459
       158433
        
         "kubernetes-client-core" = callPackage

     
···

       158907
       158881
        
              broken = true;

     

       158908
       158882
        
            }) {};

     

       158909
       158883
        
       

     

       158884
       158884
       +
         "lambda-cube" = callPackage

     

       158885
       158885
       +
           ({ mkDerivation, base, hspec, megaparsec, QuickCheck

     

       158886
       158886
       +
            , template-haskell, text

     

       158887
       158887
       +
            }:

     

       158888
       158888
       +
            mkDerivation {

     

       158889
       158889
       +
              pname = "lambda-cube";

     

       158890
       158890
       +
              version = "0.1.0.0";

     

       158891
       158891
       +
              sha256 = "0s5sh4r43r5xhlldxqy2snddc5dgnx2rpawk4pipxp69983xhazi";

     

       158892
       158892
       +
              revision = "3";

     

       158893
       158893
       +
              editedCabalFile = "0ycaf4j9g0zsbw4qjwd6san4vn7h6iiyyf0dqgqwcl0vfv7z2hf0";

     

       158894
       158894
       +
              libraryHaskellDepends = [ base megaparsec template-haskell text ];

     

       158895
       158895
       +
              testHaskellDepends = [ base hspec QuickCheck ];

     

       158896
       158896
       +
              description = "Haskell implementation of (some of) lambda cube calculi";

     

       158897
       158897
       +
              license = lib.licenses.mit;

     

       158898
       158898
       +
            }) {};

     

       158899
       158899
       +
       

     

       158910
       158900
        
         "lambda-devs" = callPackage

     

       158911
       158901
        
           ({ mkDerivation, base, binary, containers, dimensional

     

       158912
       158902
        
            , distributed-process, HUnit, numtype, QuickCheck, test-framework

     
···

       159085
       159075
        
            }:

     

       159086
       159076
        
            mkDerivation {

     

       159087
       159077
        
              pname = "lambdabot-core";

     

       159088
       159088
       -
              version = "5.3.0.1";

     

       159089
       159089
       -
              sha256 = "05xx68f3gpc7s1k8p81pwphmiznf7niradf52p39rss3nx8rr3ay";

     

       159090
       159090
       -
              libraryHaskellDepends = [

     

       159091
       159091
       -
                base binary bytestring containers dependent-map dependent-sum

     

       159092
       159092
       -
                dependent-sum-template directory edit-distance exceptions filepath

     

       159093
       159093
       -
                haskeline hslogger HTTP lifted-base monad-control mtl network

     

       159094
       159094
       -
                network-bsd parsec prim-uniq random random-fu random-source

     

       159095
       159095
       -
                regex-tdfa SafeSemaphore split syb template-haskell time

     

       159096
       159096
       -
                transformers transformers-base unix utf8-string zlib

     

       159097
       159097
       -
              ];

     

       159098
       159098
       -
              description = "Lambdabot core functionality";

     

       159099
       159099
       -
              license = "GPL";

     

       159100
       159100
       -
            }) {};

     

       159101
       159101
       -
       

     

       159102
       159102
       -
         "lambdabot-core_5_3_0_2" = callPackage

     

       159103
       159103
       -
           ({ mkDerivation, base, binary, bytestring, containers

     

       159104
       159104
       -
            , dependent-map, dependent-sum, dependent-sum-template, directory

     

       159105
       159105
       -
            , edit-distance, exceptions, filepath, haskeline, hslogger, HTTP

     

       159106
       159106
       -
            , lifted-base, monad-control, mtl, network, network-bsd, parsec

     

       159107
       159107
       -
            , prim-uniq, random, random-fu, random-source, regex-tdfa

     

       159108
       159108
       -
            , SafeSemaphore, split, syb, template-haskell, time, transformers

     

       159109
       159109
       -
            , transformers-base, unix, utf8-string, zlib

     

       159110
       159110
       -
            }:

     

       159111
       159111
       -
            mkDerivation {

     

       159112
       159112
       -
              pname = "lambdabot-core";

     

       159113
       159078
        
              version = "5.3.0.2";

     

       159114
       159079
        
              sha256 = "1i375kiw98j5gd4pixh59lcqk0lakwmrgxzpkr0431a48kxffq7r";

     

       159115
       159080
        
              libraryHaskellDepends = [

     
···

       159122
       159087
        
              ];

     

       159123
       159088
        
              description = "Lambdabot core functionality";

     

       159124
       159089
        
              license = "GPL";

     

       159125
       159125
       -
              hydraPlatforms = lib.platforms.none;

     

       159126
       159090
        
            }) {};

     

       159127
       159091
        
       

     

       159128
       159092
        
         "lambdabot-haskell-plugins" = callPackage

     
···

       160080
       160044
        
       

     

       160081
       160045
        
         "language-docker" = callPackage

     

       160082
       160046
        
           ({ mkDerivation, base, bytestring, containers, data-default-class

     

       160083
       160083
       -
            , hspec, HUnit, megaparsec, prettyprinter, QuickCheck, split, text

     

       160084
       160084
       -
            , time

     

       160085
       160085
       -
            }:

     

       160086
       160086
       -
            mkDerivation {

     

       160087
       160087
       -
              pname = "language-docker";

     

       160088
       160088
       -
              version = "10.0.1";

     

       160089
       160089
       -
              sha256 = "19pyms0ik37wpzjnlplj2vwikbjdjaw78llpfjp0a0467wlk7na6";

     

       160090
       160090
       -
              libraryHaskellDepends = [

     

       160091
       160091
       -
                base bytestring containers data-default-class megaparsec

     

       160092
       160092
       -
                prettyprinter split text time

     

       160093
       160093
       -
              ];

     

       160094
       160094
       -
              testHaskellDepends = [

     

       160095
       160095
       -
                base bytestring containers data-default-class hspec HUnit

     

       160096
       160096
       -
                megaparsec prettyprinter QuickCheck split text time

     

       160097
       160097
       -
              ];

     

       160098
       160098
       -
              description = "Dockerfile parser, pretty-printer and embedded DSL";

     

       160099
       160099
       -
              license = lib.licenses.gpl3Only;

     

       160100
       160100
       -
            }) {};

     

       160101
       160101
       -
       

     

       160102
       160102
       -
         "language-docker_10_0_2" = callPackage

     

       160103
       160103
       -
           ({ mkDerivation, base, bytestring, containers, data-default-class

     

       160104
       160047
        
            , hspec, hspec-megaparsec, HUnit, megaparsec, prettyprinter

     

       160105
       160048
        
            , QuickCheck, split, text, time

     

       160106
       160049
        
            }:

     
···

       160119
       160062
        
              ];

     

       160120
       160063
        
              description = "Dockerfile parser, pretty-printer and embedded DSL";

     

       160121
       160064
        
              license = lib.licenses.gpl3Only;

     

       160122
       160122
       -
              hydraPlatforms = lib.platforms.none;

     

       160123
       160065
        
            }) {};

     

       160124
       160066
        
       

     

       160125
       160067
        
         "language-dockerfile" = callPackage

     
···

       161159
       161101
        
            }:

     

       161160
       161102
        
            mkDerivation {

     

       161161
       161103
        
              pname = "lapack-comfort-array";

     

       161162
       161162
       -
              version = "0.0.0.1";

     

       161163
       161163
       -
              sha256 = "0kn9bb3q772sbzm54rdqbqrmp21kck2gvc0xagi974dq7b1wilh1";

     

       161164
       161164
       -
              libraryHaskellDepends = [

     

       161165
       161165
       -
                base comfort-array lapack-ffi netlib-comfort-array netlib-ffi

     

       161166
       161166
       -
                storable-complex transformers

     

       161167
       161167
       -
              ];

     

       161168
       161168
       -
              description = "Auto-generated interface to Fortran LAPACK via comfort-array";

     

       161169
       161169
       -
              license = lib.licenses.bsd3;

     

       161170
       161170
       -
              hydraPlatforms = lib.platforms.none;

     

       161171
       161171
       -
            }) {};

     

       161172
       161172
       -
       

     

       161173
       161173
       -
         "lapack-comfort-array_0_0_1" = callPackage

     

       161174
       161174
       -
           ({ mkDerivation, base, comfort-array, lapack-ffi

     

       161175
       161175
       -
            , netlib-comfort-array, netlib-ffi, storable-complex, transformers

     

       161176
       161176
       -
            }:

     

       161177
       161177
       -
            mkDerivation {

     

       161178
       161178
       -
              pname = "lapack-comfort-array";

     

       161179
       161104
        
              version = "0.0.1";

     

       161180
       161105
        
              sha256 = "1p4vfw95qnd48cbizncb7b7fgzkxbv7r3rp3ffw6r11wymhm67q0";

     

       161181
       161106
        
              libraryHaskellDepends = [

     
···

       161271
       161196
        
              description = "Efficiently hash (large) Haskell values";

     

       161272
       161197
        
              license = lib.licenses.bsd3;

     

       161273
       161198
        
              platforms = [

     

       161274
       161274
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       161199
       161199
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       161200
       161200
       +
                "x86_64-linux"

     

       161275
       161201
        
              ];

     

       161276
       161202
        
              maintainers = with lib.maintainers; [ sternenseemann ];

     

       161277
       161203
        
            }) {};

     

       161278
       161204
        
       

     

       161205
       161205
       +
         "large-records" = callPackage

     

       161206
       161206
       +
           ({ mkDerivation, aeson, base, containers, generic-deriving

     

       161207
       161207
       +
            , generics-sop, ghc-dump-core, haskell-src-exts, haskell-src-meta

     

       161208
       161208
       +
            , json-sop, microlens, mtl, newtype, QuickCheck

     

       161209
       161209
       +
            , record-dot-preprocessor, record-hasfield, sop-core, syb, tasty

     

       161210
       161210
       +
            , tasty-hunit, tasty-quickcheck, template-haskell, text

     

       161211
       161211
       +
            , transformers, vector

     

       161212
       161212
       +
            }:

     

       161213
       161213
       +
            mkDerivation {

     

       161214
       161214
       +
              pname = "large-records";

     

       161215
       161215
       +
              version = "0.1.0.0";

     

       161216
       161216
       +
              sha256 = "1l4j7vb3lckqn1cvyvcg6g3bnvi8x69nsjmkmmi7666025bxfw61";

     

       161217
       161217
       +
              revision = "1";

     

       161218
       161218
       +
              editedCabalFile = "1j89aypcp97vwb7qyg4n2ffilsp064z1w7kck1wh2rp69wk5r51n";

     

       161219
       161219
       +
              libraryHaskellDepends = [

     

       161220
       161220
       +
                aeson base containers generics-sop haskell-src-exts

     

       161221
       161221
       +
                haskell-src-meta microlens mtl record-hasfield sop-core syb

     

       161222
       161222
       +
                template-haskell text vector

     

       161223
       161223
       +
              ];

     

       161224
       161224
       +
              testHaskellDepends = [

     

       161225
       161225
       +
                aeson base generic-deriving generics-sop ghc-dump-core json-sop

     

       161226
       161226
       +
                microlens mtl newtype QuickCheck record-dot-preprocessor

     

       161227
       161227
       +
                record-hasfield sop-core tasty tasty-hunit tasty-quickcheck

     

       161228
       161228
       +
                template-haskell transformers vector

     

       161229
       161229
       +
              ];

     

       161230
       161230
       +
              testToolDepends = [ record-dot-preprocessor ];

     

       161231
       161231
       +
              description = "Efficient compilation for large records, linear in the size of the record";

     

       161232
       161232
       +
              license = lib.licenses.bsd3;

     

       161233
       161233
       +
            }) {};

     

       161234
       161234
       +
       

     

       161279
       161235
        
         "largeword" = callPackage

     

       161280
       161236
        
           ({ mkDerivation, base, binary, bytestring, HUnit, QuickCheck

     

       161281
       161237
        
            , test-framework, test-framework-hunit, test-framework-quickcheck2

     
···

       165595
       165551
        
              description = "Use SMT solvers to solve linear systems over integers and rationals";

     

       165596
       165552
        
              license = lib.licenses.bsd3;

     

       165597
       165553
        
              platforms = [

     

       165598
       165598
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       165554
       165554
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       165555
       165555
       +
                "x86_64-linux"

     

       165599
       165556
        
              ];

     

       165600
       165557
        
            }) {};

     

       165601
       165558
        
       

     
···

       169871
       169828
        
              ];

     

       169872
       169829
        
              description = "Core functionality for LTI 1.3.";

     

       169873
       169830
        
              license = lib.licenses.lgpl3Only;

     

       169874
       169874
       -
              hydraPlatforms = lib.platforms.none;

     

       169875
       169831
        
            }) {};

     

       169876
       169832
        
       

     

       169877
       169833
        
         "ltiv1p1" = callPackage

     
···

       174208
       174164
        
              ];

     

       174209
       174165
        
              description = "Sample from a posterior using Markov chain Monte Carlo";

     

       174210
       174166
        
              license = lib.licenses.gpl3Plus;

     

       174211
       174211
       -
              hydraPlatforms = lib.platforms.none;

     

       174212
       174167
        
            }) {};

     

       174213
       174168
        
       

     

       174214
       174169
        
         "mcmc-samplers" = callPackage

     
···

       177859
       177814
        
            }:

     

       177860
       177815
        
            mkDerivation {

     

       177861
       177816
        
              pname = "mixed-types-num";

     

       177862
       177862
       -
              version = "0.5.8.0";

     

       177863
       177863
       -
              sha256 = "1i40g6kf4my91i7xg54wfi6n2s8ivmx5k08ccqz3iycn6gha8pr7";

     

       177864
       177864
       -
              libraryHaskellDepends = [

     

       177865
       177865
       -
                base collect-errors hspec hspec-smallcheck mtl QuickCheck

     

       177866
       177866
       -
                smallcheck template-haskell

     

       177867
       177867
       -
              ];

     

       177868
       177868
       -
              testHaskellDepends = [

     

       177869
       177869
       -
                base collect-errors hspec hspec-smallcheck QuickCheck smallcheck

     

       177870
       177870
       -
              ];

     

       177871
       177871
       -
              description = "Alternative Prelude with numeric and logic expressions typed bottom-up";

     

       177872
       177872
       -
              license = lib.licenses.bsd3;

     

       177873
       177873
       -
            }) {};

     

       177874
       177874
       -
       

     

       177875
       177875
       -
         "mixed-types-num_0_5_9_1" = callPackage

     

       177876
       177876
       -
           ({ mkDerivation, base, collect-errors, hspec, hspec-smallcheck, mtl

     

       177877
       177877
       -
            , QuickCheck, smallcheck, template-haskell

     

       177878
       177878
       -
            }:

     

       177879
       177879
       -
            mkDerivation {

     

       177880
       177880
       -
              pname = "mixed-types-num";

     

       177881
       177817
        
              version = "0.5.9.1";

     

       177882
       177818
        
              sha256 = "009hsagx0g1myf2jlljqnf96mwnz3a4jbcmrcjs0lizskprzj1n2";

     

       177883
       177819
        
              libraryHaskellDepends = [

     
···

       177889
       177825
        
              ];

     

       177890
       177826
        
              description = "Alternative Prelude with numeric and logic expressions typed bottom-up";

     

       177891
       177827
        
              license = lib.licenses.bsd3;

     

       177892
       177892
       -
              hydraPlatforms = lib.platforms.none;

     

       177893
       177828
        
            }) {};

     

       177894
       177829
        
       

     

       177895
       177830
        
         "mixpanel-client" = callPackage

     
···

       179180
       179115
        
            }:

     

       179181
       179116
        
            mkDerivation {

     

       179182
       179117
        
              pname = "monad-control";

     

       179183
       179183
       -
              version = "1.0.3";

     

       179184
       179184
       -
              sha256 = "16rdv4s85ni1xdbd8nzarm4sh331198jnmakrn5wxla9hrfwg2fi";

     

       179185
       179185
       -
              libraryHaskellDepends = [

     

       179186
       179186
       -
                base stm transformers transformers-base transformers-compat

     

       179187
       179187
       -
              ];

     

       179188
       179188
       -
              description = "Lift control operations, like exception catching, through monad transformers";

     

       179189
       179189
       -
              license = lib.licenses.bsd3;

     

       179190
       179190
       -
            }) {};

     

       179191
       179191
       -
       

     

       179192
       179192
       -
         "monad-control_1_0_3_1" = callPackage

     

       179193
       179193
       -
           ({ mkDerivation, base, stm, transformers, transformers-base

     

       179194
       179194
       -
            , transformers-compat

     

       179195
       179195
       -
            }:

     

       179196
       179196
       -
            mkDerivation {

     

       179197
       179197
       -
              pname = "monad-control";

     

       179198
       179118
        
              version = "1.0.3.1";

     

       179199
       179119
        
              sha256 = "0g3if9km8ik80bcy130a826ig9wlk4bnf0qli3vmwdwr9nhaw2xf";

     

       179200
       179120
        
              libraryHaskellDepends = [

     
···

       179202
       179122
        
              ];

     

       179203
       179123
        
              description = "Lift control operations, like exception catching, through monad transformers";

     

       179204
       179124
        
              license = lib.licenses.bsd3;

     

       179205
       179205
       -
              hydraPlatforms = lib.platforms.none;

     

       179206
       179125
        
            }) {};

     

       179207
       179126
        
       

     

       179208
       179127
        
         "monad-control-aligned" = callPackage

     
···

       179241
       179160
        
            }:

     

       179242
       179161
        
            mkDerivation {

     

       179243
       179162
        
              pname = "monad-coroutine";

     

       179244
       179244
       -
              version = "0.9.1.2";

     

       179245
       179245
       -
              sha256 = "1s4975q1k23b2skyq9mwkkda08f2zxkv96x0yplzhz9n64kchhf3";

     

       179246
       179246
       -
              libraryHaskellDepends = [

     

       179247
       179247
       -
                base monad-parallel transformers transformers-compat

     

       179248
       179248
       -
              ];

     

       179249
       179249
       -
              description = "Coroutine monad transformer for suspending and resuming monadic computations";

     

       179250
       179250
       -
              license = "GPL";

     

       179251
       179251
       -
            }) {};

     

       179252
       179252
       -
       

     

       179253
       179253
       -
         "monad-coroutine_0_9_1_3" = callPackage

     

       179254
       179254
       -
           ({ mkDerivation, base, monad-parallel, transformers

     

       179255
       179255
       -
            , transformers-compat

     

       179256
       179256
       -
            }:

     

       179257
       179257
       -
            mkDerivation {

     

       179258
       179258
       -
              pname = "monad-coroutine";

     

       179259
       179163
        
              version = "0.9.1.3";

     

       179260
       179164
        
              sha256 = "0ns8863695hm4yabd4908znpn1bqc7ayfnzl9bkkqhs70rff2dmh";

     

       179261
       179165
        
              libraryHaskellDepends = [

     
···

       179263
       179167
        
              ];

     

       179264
       179168
        
              description = "Coroutine monad transformer for suspending and resuming monadic computations";

     

       179265
       179169
        
              license = "GPL";

     

       179266
       179266
       -
              hydraPlatforms = lib.platforms.none;

     

       179267
       179170
        
            }) {};

     

       179268
       179171
        
       

     

       179269
       179172
        
         "monad-dijkstra" = callPackage

     
···

       179838
       179741
        
            }:

     

       179839
       179742
        
            mkDerivation {

     

       179840
       179743
        
              pname = "monad-parallel";

     

       179841
       179841
       -
              version = "0.7.2.4";

     

       179842
       179842
       -
              sha256 = "1h36hwbk800v0cq2x8kxf7v3gkr8maws7ijxckvsqp480xr4r5xx";

     

       179843
       179843
       -
              libraryHaskellDepends = [

     

       179844
       179844
       -
                base parallel transformers transformers-compat

     

       179845
       179845
       -
              ];

     

       179846
       179846
       -
              description = "Parallel execution of monadic computations";

     

       179847
       179847
       -
              license = lib.licenses.bsd3;

     

       179848
       179848
       -
            }) {};

     

       179849
       179849
       -
       

     

       179850
       179850
       -
         "monad-parallel_0_7_2_5" = callPackage

     

       179851
       179851
       -
           ({ mkDerivation, base, parallel, transformers, transformers-compat

     

       179852
       179852
       -
            }:

     

       179853
       179853
       -
            mkDerivation {

     

       179854
       179854
       -
              pname = "monad-parallel";

     

       179855
       179744
        
              version = "0.7.2.5";

     

       179856
       179745
        
              sha256 = "0yjn8acn8z8b1v5nnmwrmrcim9lqh942kgi2c03cnnklfdc1cqip";

     

       179857
       179746
        
              libraryHaskellDepends = [

     
···

       179859
       179748
        
              ];

     

       179860
       179749
        
              description = "Parallel execution of monadic computations";

     

       179861
       179750
        
              license = lib.licenses.bsd3;

     

       179862
       179862
       -
              hydraPlatforms = lib.platforms.none;

     

       179863
       179751
        
            }) {};

     

       179864
       179752
        
       

     

       179865
       179753
        
         "monad-parallel-progressbar" = callPackage

     
···

       180163
       180051
        
              broken = true;

     

       180164
       180052
        
            }) {};

     

       180165
       180053
        
       

     

       180054
       180054
       +
         "monad-tree" = callPackage

     

       180055
       180055
       +
           ({ mkDerivation, base }:

     

       180056
       180056
       +
            mkDerivation {

     

       180057
       180057
       +
              pname = "monad-tree";

     

       180058
       180058
       +
              version = "0.1.0";

     

       180059
       180059
       +
              sha256 = "1rjrcai2wqz3qkn3sk1fj6c0vvzk58gmghzwp9w9xvr09kd7zyd2";

     

       180060
       180060
       +
              libraryHaskellDepends = [ base ];

     

       180061
       180061
       +
              description = "Tree data structure for nondeterministic computations";

     

       180062
       180062
       +
              license = lib.licenses.mit;

     

       180063
       180063
       +
            }) {};

     

       180064
       180064
       +
       

     

       180166
       180065
        
         "monad-tx" = callPackage

     

       180167
       180066
        
           ({ mkDerivation, base }:

     

       180168
       180067
        
            mkDerivation {

     
···

       181020
       180919
        
            }:

     

       181021
       180920
        
            mkDerivation {

     

       181022
       180921
        
              pname = "monomer";

     

       181023
       181023
       -
              version = "1.0.0.1";

     

       181024
       181024
       -
              sha256 = "1ns4zm1vny8r49k0iq77b75s17gqmzxjv3kj70a4k5j4jx5s70fr";

     

       180922
       180922
       +
              version = "1.0.0.2";

     

       180923
       180923
       +
              sha256 = "1m0c6ldc5sg2if4b21n7b13f5rpyws0vmw9nn8gjqly7rbq446az";

     

       181025
       180924
        
              isLibrary = true;

     

       181026
       180925
        
              isExecutable = true;

     

       181027
       180926
        
              libraryHaskellDepends = [

     
···

       181048
       180947
        
              ];

     

       181049
       180948
        
              description = "A GUI library for writing native Haskell applications";

     

       181050
       180949
        
              license = lib.licenses.bsd3;

     

       181051
       181051
       -
              hydraPlatforms = lib.platforms.none;

     

       181052
       180950
        
            }) {inherit (pkgs) glew;};

     

       181053
       180951
        
       

     

       181054
       180952
        
         "monomorphic" = callPackage

     
···

       182086
       181984
        
              description = "Save your spot when watching movies with @mplayer@";

     

       182087
       181985
        
              license = lib.licenses.bsd3;

     

       182088
       181986
        
              platforms = [

     

       182089
       182089
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       181987
       181987
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       181988
       181988
       +
                "x86_64-linux"

     

       182090
       181989
        
              ];

     

       182091
       181990
        
            }) {};

     

       182092
       181991
        
       

     
···

       184710
       184609
        
            }:

     

       184711
       184610
        
            mkDerivation {

     

       184712
       184611
        
              pname = "mwc-random";

     

       184713
       184713
       -
              version = "0.15.0.1";

     

       184714
       184714
       -
              sha256 = "1p8c5g4hb72k90ai39rgpn6cr942i6636l1y0zfp9xgjb3v0a2q3";

     

       184715
       184715
       -
              revision = "2";

     

       184716
       184716
       -
              editedCabalFile = "0si7d23ycyg1072w10v06zh1xx4yy5jxwmrrs65inrs7fhdb1r28";

     

       184717
       184717
       -
              libraryHaskellDepends = [

     

       184718
       184718
       -
                base math-functions primitive random time vector

     

       184719
       184719
       -
              ];

     

       184720
       184720
       -
              testHaskellDepends = [

     

       184721
       184721
       -
                base bytestring doctest primitive QuickCheck random tasty

     

       184722
       184722
       -
                tasty-hunit tasty-quickcheck vector

     

       184723
       184723
       -
              ];

     

       184724
       184724
       -
              benchmarkHaskellDepends = [

     

       184725
       184725
       -
                base gauge mersenne-random random vector

     

       184726
       184726
       -
              ];

     

       184727
       184727
       -
              doCheck = false;

     

       184728
       184728
       -
              description = "Fast, high quality pseudo random number generation";

     

       184729
       184729
       -
              license = lib.licenses.bsd3;

     

       184730
       184730
       -
            }) {};

     

       184731
       184731
       -
       

     

       184732
       184732
       -
         "mwc-random_0_15_0_2" = callPackage

     

       184733
       184733
       -
           ({ mkDerivation, base, bytestring, doctest, gauge, math-functions

     

       184734
       184734
       -
            , mersenne-random, primitive, QuickCheck, random, tasty

     

       184735
       184735
       -
            , tasty-hunit, tasty-quickcheck, time, vector

     

       184736
       184736
       -
            }:

     

       184737
       184737
       -
            mkDerivation {

     

       184738
       184738
       -
              pname = "mwc-random";

     

       184739
       184612
        
              version = "0.15.0.2";

     

       184740
       184613
        
              sha256 = "0ny2mw4am24d6ykrm8rbcjnrq6p2cjmzjb4m6qfk54wfdxflvmim";

     

       184741
       184614
        
              libraryHaskellDepends = [

     
···

       184751
       184624
        
              doCheck = false;

     

       184752
       184625
        
              description = "Fast, high quality pseudo random number generation";

     

       184753
       184626
        
              license = lib.licenses.bsd3;

     

       184754
       184754
       -
              hydraPlatforms = lib.platforms.none;

     

       184755
       184627
        
            }) {};

     

       184756
       184628
        
       

     

       184757
       184629
        
         "mwc-random-accelerate" = callPackage

     
···

       185847
       185719
        
            }:

     

       185848
       185720
        
            mkDerivation {

     

       185849
       185721
        
              pname = "nanovg";

     

       185850
       185850
       -
              version = "0.7.0.0";

     

       185851
       185851
       -
              sha256 = "1mrn5dy05nl5kkxw5vfgf57wifllq7jnv0akd1wi9wnlgvvqjnqz";

     

       185722
       185722
       +
              version = "0.8.0.0";

     

       185723
       185723
       +
              sha256 = "1il4305wv7f53225jv5s04nf7gf5rw6cfxm8j3v1di2xvhdingz5";

     

       185852
       185724
        
              isLibrary = true;

     

       185853
       185725
        
              isExecutable = true;

     

       185854
       185726
        
              libraryHaskellDepends = [ base bytestring containers text vector ];

     

       185855
       185855
       -
              librarySystemDepends = [ freetype glew libGL libGLU libX11 ];

     

       185856
       185856
       -
              libraryPkgconfigDepends = [ glew ];

     

       185727
       185727
       +
              librarySystemDepends = [ glew libGL libGLU libX11 ];

     

       185728
       185728
       +
              libraryPkgconfigDepends = [ freetype glew ];

     

       185857
       185729
        
              libraryToolDepends = [ c2hs ];

     

       185858
       185730
        
              testHaskellDepends = [ base containers hspec inline-c QuickCheck ];

     

       185859
       185731
        
              description = "Haskell bindings for nanovg";

     

       185860
       185732
        
              license = lib.licenses.isc;

     

       185861
       185861
       -
              hydraPlatforms = lib.platforms.none;

     

       185862
       185862
       -
              broken = true;

     

       185863
       185733
        
            }) {inherit (pkgs) freetype; inherit (pkgs) glew; 

     

       185864
       185734
        
                inherit (pkgs) libGL; inherit (pkgs) libGLU; 

     

       185865
       185735
        
                inherit (pkgs.xorg) libX11;};

     
···

       185879
       185749
        
              ];

     

       185880
       185750
        
              description = "Simple interface to rendering with NanoVG";

     

       185881
       185751
        
              license = lib.licenses.bsd3;

     

       185882
       185882
       -
              hydraPlatforms = lib.platforms.none;

     

       185883
       185752
        
            }) {};

     

       185884
       185753
        
       

     

       185885
       185754
        
         "nanq" = callPackage

     
···

       187052
       186921
        
           ({ mkDerivation, base, comfort-array, netlib-ffi, transformers }:

     

       187053
       186922
        
            mkDerivation {

     

       187054
       186923
        
              pname = "netlib-comfort-array";

     

       187055
       187055
       -
              version = "0.0.0.1";

     

       187056
       187056
       -
              sha256 = "0v4p1l8gjqkxncjrp6bv664x6xs3y6n5h76pvgccsja5rammwbp3";

     

       187057
       187057
       -
              libraryHaskellDepends = [

     

       187058
       187058
       -
                base comfort-array netlib-ffi transformers

     

       187059
       187059
       -
              ];

     

       187060
       187060
       -
              description = "Helper modules for comfort-array wrappers to BLAS and LAPACK";

     

       187061
       187061
       -
              license = lib.licenses.bsd3;

     

       187062
       187062
       -
            }) {};

     

       187063
       187063
       -
       

     

       187064
       187064
       -
         "netlib-comfort-array_0_0_0_2" = callPackage

     

       187065
       187065
       -
           ({ mkDerivation, base, comfort-array, netlib-ffi, transformers }:

     

       187066
       187066
       -
            mkDerivation {

     

       187067
       187067
       -
              pname = "netlib-comfort-array";

     

       187068
       186924
        
              version = "0.0.0.2";

     

       187069
       186925
        
              sha256 = "1mwgdll9m0ryy5y1385sx2asff98kqfkz4bif8s4i0dkrqalsfx4";

     

       187070
       186926
        
              libraryHaskellDepends = [

     
···

       187072
       186928
        
              ];

     

       187073
       186929
        
              description = "Helper modules for comfort-array wrappers to BLAS and LAPACK";

     

       187074
       186930
        
              license = lib.licenses.bsd3;

     

       187075
       187075
       -
              hydraPlatforms = lib.platforms.none;

     

       187076
       186931
        
            }) {};

     

       187077
       186932
        
       

     

       187078
       186933
        
         "netlib-ffi" = callPackage

     
···

       190578
       190433
        
              hydraPlatforms = lib.platforms.none;

     

       190579
       190434
        
            }) {};

     

       190580
       190435
        
       

     

       190436
       190436
       +
         "not-prelude" = callPackage

     

       190437
       190437
       +
           ({ mkDerivation, base-noprelude, data-default, exceptions, failable

     

       190438
       190438
       +
            , mtl, text, transformers

     

       190439
       190439
       +
            }:

     

       190440
       190440
       +
            mkDerivation {

     

       190441
       190441
       +
              pname = "not-prelude";

     

       190442
       190442
       +
              version = "0.1.0.0";

     

       190443
       190443
       +
              sha256 = "0hb3ri6g1v21wi3saaai56b1a2r76g2dgaa7xqqchi31lh004131";

     

       190444
       190444
       +
              libraryHaskellDepends = [

     

       190445
       190445
       +
                base-noprelude data-default exceptions failable mtl text

     

       190446
       190446
       +
                transformers

     

       190447
       190447
       +
              ];

     

       190448
       190448
       +
              description = "An opinionated Prelude replacement library";

     

       190449
       190449
       +
              license = lib.licenses.mit;

     

       190450
       190450
       +
            }) {};

     

       190451
       190451
       +
       

     

       190581
       190452
        
         "notcpp" = callPackage

     

       190582
       190453
        
           ({ mkDerivation, base, template-haskell }:

     

       190583
       190454
        
            mkDerivation {

     
···

       193358
       193229
        
            }:

     

       193359
       193230
        
            mkDerivation {

     

       193360
       193231
        
              pname = "opaleye";

     

       193361
       193361
       -
              version = "0.7.3.0";

     

       193362
       193362
       -
              sha256 = "0ls8hk8iy47hna1y7kbakzv9ihp61lv605f1ap4di95fv03wy288";

     

       193363
       193363
       -
              libraryHaskellDepends = [

     

       193364
       193364
       -
                aeson base base16-bytestring bytestring case-insensitive

     

       193365
       193365
       -
                contravariant postgresql-simple pretty product-profunctors

     

       193366
       193366
       -
                profunctors scientific semigroups text time time-locale-compat

     

       193367
       193367
       -
                transformers uuid void

     

       193368
       193368
       -
              ];

     

       193369
       193369
       -
              testHaskellDepends = [

     

       193370
       193370
       -
                aeson base bytestring containers contravariant dotenv hspec

     

       193371
       193371
       -
                hspec-discover multiset postgresql-simple product-profunctors

     

       193372
       193372
       -
                profunctors QuickCheck semigroups text time transformers uuid

     

       193373
       193373
       -
              ];

     

       193374
       193374
       -
              testToolDepends = [ hspec-discover ];

     

       193375
       193375
       -
              description = "An SQL-generating DSL targeting PostgreSQL";

     

       193376
       193376
       -
              license = lib.licenses.bsd3;

     

       193377
       193377
       -
            }) {};

     

       193378
       193378
       -
       

     

       193379
       193379
       -
         "opaleye_0_7_4_0" = callPackage

     

       193380
       193380
       -
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       193381
       193381
       -
            , case-insensitive, containers, contravariant, dotenv, hspec

     

       193382
       193382
       -
            , hspec-discover, multiset, postgresql-simple, pretty

     

       193383
       193383
       -
            , product-profunctors, profunctors, QuickCheck, scientific

     

       193384
       193384
       -
            , semigroups, text, time, time-locale-compat, transformers, uuid

     

       193385
       193385
       -
            , void

     

       193386
       193386
       -
            }:

     

       193387
       193387
       -
            mkDerivation {

     

       193388
       193388
       -
              pname = "opaleye";

     

       193389
       193232
        
              version = "0.7.4.0";

     

       193390
       193233
        
              sha256 = "1v4gxqnjacyj7npcvl70dzksgl12qrgwscv4l47kvzmf76i1x6rd";

     

       193391
       193234
        
              libraryHaskellDepends = [

     
···

       193402
       193245
        
              testToolDepends = [ hspec-discover ];

     

       193403
       193246
        
              description = "An SQL-generating DSL targeting PostgreSQL";

     

       193404
       193247
        
              license = lib.licenses.bsd3;

     

       193405
       193405
       -
              hydraPlatforms = lib.platforms.none;

     

       193406
       193248
        
            }) {};

     

       193407
       193249
        
       

     

       193408
       193250
        
         "opaleye-classy" = callPackage

     
···

       197108
       196950
        
              maintainers = with lib.maintainers; [ peti ];

     

       197109
       196951
        
            }) {};

     

       197110
       196952
        
       

     

       197111
       197111
       -
         "pandoc_2_14_1" = callPackage

     

       196953
       196953
       +
         "pandoc_2_14_2" = callPackage

     

       197112
       196954
        
           ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base

     

       197113
       196955
        
            , base64-bytestring, binary, blaze-html, blaze-markup, bytestring

     

       197114
       196956
        
            , case-insensitive, citeproc, commonmark, commonmark-extensions

     
···

       197116
       196958
        
            , Diff, directory, doclayout, doctemplates, emojis, exceptions

     

       197117
       196959
        
            , file-embed, filepath, Glob, haddock-library, hslua

     

       197118
       196960
        
            , hslua-module-path, hslua-module-system, hslua-module-text, HsYAML

     

       197119
       197119
       -
            , HTTP, http-client, http-client-tls, http-types, ipynb

     

       197120
       197120
       -
            , jira-wiki-markup, JuicyPixels, mtl, network, network-uri

     

       197121
       197121
       -
            , pandoc-types, parsec, process, QuickCheck, random, safe

     

       197122
       197122
       -
            , scientific, SHA, skylighting, skylighting-core, split, syb

     

       197123
       197123
       -
            , tagsoup, tasty, tasty-bench, tasty-golden, tasty-hunit, tasty-lua

     

       197124
       197124
       -
            , tasty-quickcheck, temporary, texmath, text, text-conversions

     

       197125
       197125
       -
            , time, unicode-collation, unicode-transforms, unix

     

       197126
       197126
       -
            , unordered-containers, xml, xml-conduit, zip-archive, zlib

     

       196961
       196961
       +
            , http-client, http-client-tls, http-types, ipynb, jira-wiki-markup

     

       196962
       196962
       +
            , JuicyPixels, mtl, network, network-uri, pandoc-types, parsec

     

       196963
       196963
       +
            , process, QuickCheck, random, safe, scientific, SHA, skylighting

     

       196964
       196964
       +
            , skylighting-core, split, syb, tagsoup, tasty, tasty-bench

     

       196965
       196965
       +
            , tasty-golden, tasty-hunit, tasty-lua, tasty-quickcheck, temporary

     

       196966
       196966
       +
            , texmath, text, text-conversions, time, unicode-collation

     

       196967
       196967
       +
            , unicode-transforms, unix, unordered-containers, xml, xml-conduit

     

       196968
       196968
       +
            , zip-archive, zlib

     

       197127
       196969
        
            }:

     

       197128
       196970
        
            mkDerivation {

     

       197129
       196971
        
              pname = "pandoc";

     

       197130
       197130
       -
              version = "2.14.1";

     

       197131
       197131
       -
              sha256 = "1jj011az45zpd201f3dwb90m22p60nv5bmpbh39li885xwv46qyq";

     

       196972
       196972
       +
              version = "2.14.2";

     

       196973
       196973
       +
              sha256 = "1bjw5di5dwfpnxgkj2qmri8f1nv6yin23cd8s38chwan29vd7xrc";

     

       197132
       196974
        
              configureFlags = [ "-fhttps" "-f-trypandoc" ];

     

       197133
       196975
        
              isLibrary = true;

     

       197134
       196976
        
              isExecutable = true;

     
···

       197139
       196981
        
                commonmark commonmark-extensions commonmark-pandoc connection

     

       197140
       196982
        
                containers data-default deepseq directory doclayout doctemplates

     

       197141
       196983
        
                emojis exceptions file-embed filepath Glob haddock-library hslua

     

       197142
       197142
       -
                hslua-module-path hslua-module-system hslua-module-text HsYAML HTTP

     

       196984
       196984
       +
                hslua-module-path hslua-module-system hslua-module-text HsYAML

     

       197143
       196985
        
                http-client http-client-tls http-types ipynb jira-wiki-markup

     

       197144
       196986
        
                JuicyPixels mtl network network-uri pandoc-types parsec process

     

       197145
       196987
        
                random safe scientific SHA skylighting skylighting-core split syb

     
···

       197573
       197415
        
              ];

     

       197574
       197416
        
              description = "A Pandoc filter to include figures generated from code blocks using your plotting toolkit of choice";

     

       197575
       197417
        
              license = lib.licenses.gpl2Plus;

     

       197418
       197418
       +
            }) {};

     

       197419
       197419
       +
       

     

       197420
       197420
       +
         "pandoc-plot_1_3_0" = callPackage

     

       197421
       197421
       +
           ({ mkDerivation, base, bytestring, containers, criterion

     

       197422
       197422
       +
            , data-default, directory, filepath, gitrev, hashable, hspec

     

       197423
       197423
       +
            , hspec-expectations, lifted-async, lifted-base, mtl

     

       197424
       197424
       +
            , optparse-applicative, pandoc, pandoc-types, shakespeare, tagsoup

     

       197425
       197425
       +
            , tasty, tasty-hspec, tasty-hunit, template-haskell, text

     

       197426
       197426
       +
            , typed-process, unix, yaml

     

       197427
       197427
       +
            }:

     

       197428
       197428
       +
            mkDerivation {

     

       197429
       197429
       +
              pname = "pandoc-plot";

     

       197430
       197430
       +
              version = "1.3.0";

     

       197431
       197431
       +
              sha256 = "0d33cbw0ygsdwh718q7q5gw2s6565dbrjwi3rz0qdf78q14wiayi";

     

       197432
       197432
       +
              isLibrary = true;

     

       197433
       197433
       +
              isExecutable = true;

     

       197434
       197434
       +
              libraryHaskellDepends = [

     

       197435
       197435
       +
                base bytestring containers data-default directory filepath hashable

     

       197436
       197436
       +
                lifted-async lifted-base mtl pandoc pandoc-types shakespeare

     

       197437
       197437
       +
                tagsoup template-haskell text typed-process unix yaml

     

       197438
       197438
       +
              ];

     

       197439
       197439
       +
              executableHaskellDepends = [

     

       197440
       197440
       +
                base containers directory filepath gitrev optparse-applicative

     

       197441
       197441
       +
                pandoc pandoc-types template-haskell text typed-process

     

       197442
       197442
       +
              ];

     

       197443
       197443
       +
              testHaskellDepends = [

     

       197444
       197444
       +
                base containers directory filepath hspec hspec-expectations

     

       197445
       197445
       +
                pandoc-types tasty tasty-hspec tasty-hunit text

     

       197446
       197446
       +
              ];

     

       197447
       197447
       +
              benchmarkHaskellDepends = [

     

       197448
       197448
       +
                base criterion pandoc-types template-haskell text

     

       197449
       197449
       +
              ];

     

       197450
       197450
       +
              description = "A Pandoc filter to include figures generated from code blocks using your plotting toolkit of choice";

     

       197451
       197451
       +
              license = lib.licenses.gpl2Plus;

     

       197452
       197452
       +
              hydraPlatforms = lib.platforms.none;

     

       197576
       197453
        
            }) {};

     

       197577
       197454
        
       

     

       197578
       197455
        
         "pandoc-pyplot" = callPackage

     
···

       199759
       199636
        
              ];

     

       199760
       199637
        
              description = "Hashing and checking of passwords";

     

       199761
       199638
        
              license = lib.licenses.bsd3;

     

       199762
       199762
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       199639
       199639
       +
              platforms = [

     

       199640
       199640
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       199641
       199641
       +
              ];

     

       199763
       199642
        
              maintainers = with lib.maintainers; [ cdepillabout ];

     

       199764
       199643
        
            }) {};

     

       199765
       199644
        
       

     
···

       199784
       199663
        
              ];

     

       199785
       199664
        
              description = "typeclass instances for password package";

     

       199786
       199665
        
              license = lib.licenses.bsd3;

     

       199787
       199787
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       199666
       199666
       +
              platforms = [

     

       199667
       199667
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       199668
       199668
       +
              ];

     

       199788
       199669
        
              maintainers = with lib.maintainers; [ cdepillabout ];

     

       199789
       199670
        
            }) {};

     

       199790
       199671
        
       

     
···

       200787
       200668
        
              license = lib.licenses.asl20;

     

       200788
       200669
        
            }) {};

     

       200789
       200670
        
       

     

       200790
       200790
       -
         "pcre2_2_0_0" = callPackage

     

       200791
       200791
       -
           ({ mkDerivation, base, containers, criterion, hspec

     

       200671
       200671
       +
         "pcre2_2_0_1" = callPackage

     

       200672
       200672
       +
           ({ mkDerivation, base, containers, criterion, hspec, microlens

     

       200792
       200673
        
            , microlens-platform, mtl, pcre-light, regex-pcre-builtin

     

       200793
       200674
        
            , template-haskell, text

     

       200794
       200675
        
            }:

     

       200795
       200676
        
            mkDerivation {

     

       200796
       200677
        
              pname = "pcre2";

     

       200797
       200797
       -
              version = "2.0.0";

     

       200798
       200798
       -
              sha256 = "1jkyc2s3x5n7zrw9b78gk8jj262xfmg8cva2gr7mlzzl0hd9r11y";

     

       200678
       200678
       +
              version = "2.0.1";

     

       200679
       200679
       +
              sha256 = "0f93z99qhlhyvq7xsfn0nap9cxpxg2hs7790jqc5hi5kmqxlwvmy";

     

       200799
       200680
        
              libraryHaskellDepends = [

     

       200800
       200800
       -
                base containers mtl template-haskell text

     

       200681
       200681
       +
                base containers microlens mtl template-haskell text

     

       200801
       200682
        
              ];

     

       200802
       200683
        
              testHaskellDepends = [

     

       200803
       200803
       -
                base containers hspec microlens-platform mtl template-haskell text

     

       200684
       200684
       +
                base containers hspec microlens microlens-platform mtl

     

       200685
       200685
       +
                template-haskell text

     

       200804
       200686
        
              ];

     

       200805
       200687
        
              benchmarkHaskellDepends = [

     

       200806
       200806
       -
                base containers criterion microlens-platform mtl pcre-light

     

       200807
       200807
       -
                regex-pcre-builtin template-haskell text

     

       200688
       200688
       +
                base containers criterion microlens microlens-platform mtl

     

       200689
       200689
       +
                pcre-light regex-pcre-builtin template-haskell text

     

       200808
       200690
        
              ];

     

       200809
       200691
        
              description = "Regular expressions via the PCRE2 C library (included)";

     

       200810
       200692
        
              license = lib.licenses.asl20;

     
···

       201959
       201841
        
              ];

     

       201960
       201842
        
              description = "Serialization library with state and leb128 encoding";

     

       201961
       201843
        
              license = lib.licenses.bsd3;

     

       201962
       201962
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       201844
       201844
       +
              platforms = [

     

       201845
       201845
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       201846
       201846
       +
              ];

     

       201963
       201847
        
            }) {};

     

       201964
       201848
        
       

     

       201965
       201849
        
         "persist2er" = callPackage

     
···

       204517
       204401
        
            }:

     

       204518
       204402
        
            mkDerivation {

     

       204519
       204403
        
              pname = "pinned-warnings";

     

       204520
       204520
       -
              version = "0.1.0.6";

     

       204521
       204521
       -
              sha256 = "1n0h2v71x3j0wn0g2f3zq3xw681s16hl7ffywi83z50hacd8x6kx";

     

       204404
       204404
       +
              version = "0.1.0.8";

     

       204405
       204405
       +
              sha256 = "0ky5lqvf1bfbjzblqgnj47jhkxw4fb7gz7k268hnf41gfnbsy3i4";

     

       204522
       204406
        
              libraryHaskellDepends = [

     

       204523
       204407
        
                base bytestring containers directory ghc time transformers

     

       204524
       204408
        
              ];

     
···

       212008
       211892
        
       

     

       212009
       211893
        
         "primitive" = callPackage

     

       212010
       211894
        
           ({ mkDerivation, base, base-orphans, deepseq, ghc-prim, QuickCheck

     

       212011
       212011
       -
            , quickcheck-classes-base, semigroups, tagged, tasty

     

       212012
       212012
       -
            , tasty-quickcheck, transformers, transformers-compat

     

       212013
       212013
       -
            }:

     

       212014
       212014
       -
            mkDerivation {

     

       212015
       212015
       -
              pname = "primitive";

     

       212016
       212016
       -
              version = "0.7.1.0";

     

       212017
       212017
       -
              sha256 = "1w53i4mk248g58xrffmksznr4nmn2bbbycajzpcqfxx5ybyyrsvb";

     

       212018
       212018
       -
              revision = "3";

     

       212019
       212019
       -
              editedCabalFile = "03vgkhib8w3g0m0zwpz74hsixrf0pvgh6ql0xcy05fpq1kynppi9";

     

       212020
       212020
       -
              libraryHaskellDepends = [ base deepseq transformers ];

     

       212021
       212021
       -
              testHaskellDepends = [

     

       212022
       212022
       -
                base base-orphans ghc-prim QuickCheck quickcheck-classes-base

     

       212023
       212023
       -
                semigroups tagged tasty tasty-quickcheck transformers

     

       212024
       212024
       -
                transformers-compat

     

       212025
       212025
       -
              ];

     

       212026
       212026
       -
              description = "Primitive memory-related operations";

     

       212027
       212027
       -
              license = lib.licenses.bsd3;

     

       212028
       212028
       -
            }) {};

     

       212029
       212029
       -
       

     

       212030
       212030
       -
         "primitive_0_7_2_0" = callPackage

     

       212031
       212031
       -
           ({ mkDerivation, base, base-orphans, deepseq, ghc-prim, QuickCheck

     

       212032
       211895
        
            , quickcheck-classes-base, tagged, tasty, tasty-quickcheck

     

       212033
       211896
        
            , transformers, transformers-compat

     

       212034
       211897
        
            }:

     
···

       212043
       211906
        
              ];

     

       212044
       211907
        
              description = "Primitive memory-related operations";

     

       212045
       211908
        
              license = lib.licenses.bsd3;

     

       212046
       212046
       -
              hydraPlatforms = lib.platforms.none;

     

       212047
       211909
        
            }) {};

     

       212048
       211910
        
       

     

       212049
       211911
        
         "primitive-addr" = callPackage

     
···

       224882
       224744
        
            }:

     

       224883
       224745
        
            mkDerivation {

     

       224884
       224746
        
              pname = "replace-attoparsec";

     

       224885
       224885
       -
              version = "1.4.4.0";

     

       224886
       224886
       -
              sha256 = "06js4adbzvm2qn18vlaaxhav2dq1hqp825lmsvpg69cylp72fzif";

     

       224887
       224887
       -
              libraryHaskellDepends = [ attoparsec base bytestring text ];

     

       224888
       224888
       -
              testHaskellDepends = [

     

       224889
       224889
       -
                attoparsec base bytestring Cabal parsers text

     

       224890
       224890
       -
              ];

     

       224891
       224891
       -
              description = "Find, replace, and split string patterns with Attoparsec parsers (instead of regex)";

     

       224892
       224892
       -
              license = lib.licenses.bsd2;

     

       224893
       224893
       -
            }) {};

     

       224894
       224894
       -
       

     

       224895
       224895
       -
         "replace-attoparsec_1_4_5_0" = callPackage

     

       224896
       224896
       -
           ({ mkDerivation, attoparsec, base, bytestring, Cabal, parsers, text

     

       224897
       224897
       -
            }:

     

       224898
       224898
       -
            mkDerivation {

     

       224899
       224899
       -
              pname = "replace-attoparsec";

     

       224900
       224747
        
              version = "1.4.5.0";

     

       224901
       224748
        
              sha256 = "1mr7d6w5x6igsvl6mccchr2wbxxr5p86kpyxlbk7m17dplvwazcq";

     

       224902
       224749
        
              libraryHaskellDepends = [ attoparsec base bytestring text ];

     
···

       224905
       224752
        
              ];

     

       224906
       224753
        
              description = "Find, replace, and split string patterns with Attoparsec parsers (instead of regex)";

     

       224907
       224754
        
              license = lib.licenses.bsd2;

     

       224908
       224908
       -
              hydraPlatforms = lib.platforms.none;

     

       224909
       224755
        
            }) {};

     

       224910
       224756
        
       

     

       224911
       224757
        
         "replace-megaparsec" = callPackage

     
···

       225198
       225044
        
       

     

       225199
       225045
        
         "req-conduit" = callPackage

     

       225200
       225046
        
           ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec

     

       225201
       225201
       -
            , http-client, req, resourcet, temporary, transformers, weigh

     

       225202
       225202
       -
            }:

     

       225203
       225203
       -
            mkDerivation {

     

       225204
       225204
       -
              pname = "req-conduit";

     

       225205
       225205
       -
              version = "1.0.0";

     

       225206
       225206
       -
              sha256 = "193bv4jp7rrbpb1i9as9s2l978wz5kbz5kvr7ppllif5ppj699qx";

     

       225207
       225207
       -
              revision = "8";

     

       225208
       225208
       -
              editedCabalFile = "1md7zajmw87qrx6rvs35yrkbjs3s9nm0akg35jmf7a34xccrr7a7";

     

       225209
       225209
       -
              libraryHaskellDepends = [

     

       225210
       225210
       -
                base bytestring conduit http-client req resourcet transformers

     

       225211
       225211
       -
              ];

     

       225212
       225212
       -
              testHaskellDepends = [

     

       225213
       225213
       -
                base bytestring conduit conduit-extra hspec req resourcet temporary

     

       225214
       225214
       -
                transformers

     

       225215
       225215
       -
              ];

     

       225216
       225216
       -
              benchmarkHaskellDepends = [

     

       225217
       225217
       -
                base bytestring conduit conduit-extra req resourcet temporary weigh

     

       225218
       225218
       -
              ];

     

       225219
       225219
       -
              description = "Conduit helpers for the req HTTP client library";

     

       225220
       225220
       -
              license = lib.licenses.bsd3;

     

       225221
       225221
       -
              hydraPlatforms = lib.platforms.none;

     

       225222
       225222
       -
              broken = true;

     

       225223
       225223
       -
            }) {};

     

       225224
       225224
       -
       

     

       225225
       225225
       -
         "req-conduit_1_0_1" = callPackage

     

       225226
       225226
       -
           ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec

     

       225227
       225047
        
            , hspec-discover, http-client, req, resourcet, temporary

     

       225228
       225048
        
            , transformers, weigh

     

       225229
       225049
        
            }:

     
···

       225730
       225550
        
            }:

     

       225731
       225551
        
            mkDerivation {

     

       225732
       225552
        
              pname = "resourcet";

     

       225733
       225733
       -
              version = "1.2.4.2";

     

       225734
       225734
       -
              sha256 = "11zb4figcs22hjaq6zsknf70kf9k2bxnw6w03ab9kl9s0i10iwhp";

     

       225735
       225735
       -
              libraryHaskellDepends = [

     

       225736
       225736
       -
                base containers exceptions mtl primitive transformers unliftio-core

     

       225737
       225737
       -
              ];

     

       225738
       225738
       -
              testHaskellDepends = [ base exceptions hspec transformers ];

     

       225739
       225739
       -
              description = "Deterministic allocation and freeing of scarce resources";

     

       225740
       225740
       -
              license = lib.licenses.bsd3;

     

       225741
       225741
       -
            }) {};

     

       225742
       225742
       -
       

     

       225743
       225743
       -
         "resourcet_1_2_4_3" = callPackage

     

       225744
       225744
       -
           ({ mkDerivation, base, containers, exceptions, hspec, mtl

     

       225745
       225745
       -
            , primitive, transformers, unliftio-core

     

       225746
       225746
       -
            }:

     

       225747
       225747
       -
            mkDerivation {

     

       225748
       225748
       -
              pname = "resourcet";

     

       225749
       225553
        
              version = "1.2.4.3";

     

       225750
       225554
        
              sha256 = "0zrvnikw1a0r2j59k12fxikyrg0ki5a7xhqhjgfl9h6dqpz54h85";

     

       225751
       225555
        
              libraryHaskellDepends = [

     
···

       225754
       225558
        
              testHaskellDepends = [ base exceptions hspec transformers ];

     

       225755
       225559
        
              description = "Deterministic allocation and freeing of scarce resources";

     

       225756
       225560
        
              license = lib.licenses.bsd3;

     

       225757
       225757
       -
              hydraPlatforms = lib.platforms.none;

     

       225758
       225561
        
            }) {};

     

       225759
       225562
        
       

     

       225760
       225563
        
         "resourcet-pool" = callPackage

     
···

       226221
       226024
        
              license = lib.licenses.mit;

     

       226222
       226025
        
            }) {};

     

       226223
       226026
        
       

     

       226027
       226027
       +
         "retroclash-lib" = callPackage

     

       226028
       226028
       +
           ({ mkDerivation, barbies, base, clash-ghc, clash-lib, clash-prelude

     

       226029
       226029
       +
            , containers, ghc-typelits-extra, ghc-typelits-knownnat

     

       226030
       226030
       +
            , ghc-typelits-natnormalise, lens, lift-type, monoidal-containers

     

       226031
       226031
       +
            , mtl, template-haskell, transformers

     

       226032
       226032
       +
            }:

     

       226033
       226033
       +
            mkDerivation {

     

       226034
       226034
       +
              pname = "retroclash-lib";

     

       226035
       226035
       +
              version = "0.1.0";

     

       226036
       226036
       +
              sha256 = "062pjqhba41d4bb9gb8wxpd87mpsmzj3np8y9ymagjrnv5iyaf5w";

     

       226037
       226037
       +
              libraryHaskellDepends = [

     

       226038
       226038
       +
                barbies base clash-ghc clash-lib clash-prelude containers

     

       226039
       226039
       +
                ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise

     

       226040
       226040
       +
                lens lift-type monoidal-containers mtl template-haskell

     

       226041
       226041
       +
                transformers

     

       226042
       226042
       +
              ];

     

       226043
       226043
       +
              description = "Code shared across the code samples in the book \"Retrocomputing with Clash\"";

     

       226044
       226044
       +
              license = lib.licenses.mit;

     

       226045
       226045
       +
              hydraPlatforms = lib.platforms.none;

     

       226046
       226046
       +
            }) {};

     

       226047
       226047
       +
       

     

       226048
       226048
       +
         "retroclash-sim" = callPackage

     

       226049
       226049
       +
           ({ mkDerivation, array, arrows, base, clash-ghc, clash-lib

     

       226050
       226050
       +
            , clash-prelude, ghc-typelits-extra, ghc-typelits-knownnat

     

       226051
       226051
       +
            , ghc-typelits-natnormalise, lens, mtl, retroclash-lib, sdl2, text

     

       226052
       226052
       +
            , transformers

     

       226053
       226053
       +
            }:

     

       226054
       226054
       +
            mkDerivation {

     

       226055
       226055
       +
              pname = "retroclash-sim";

     

       226056
       226056
       +
              version = "0.1.0";

     

       226057
       226057
       +
              sha256 = "1wv8is17ds9y49an832dlgixly9b98h8x6ybc5dj7zzf1jwplyp8";

     

       226058
       226058
       +
              libraryHaskellDepends = [

     

       226059
       226059
       +
                array arrows base clash-ghc clash-lib clash-prelude

     

       226060
       226060
       +
                ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise

     

       226061
       226061
       +
                lens mtl retroclash-lib sdl2 text transformers

     

       226062
       226062
       +
              ];

     

       226063
       226063
       +
              description = "High-level simulators from the book \"Retrocomputing with Clash\"";

     

       226064
       226064
       +
              license = lib.licenses.mit;

     

       226065
       226065
       +
              hydraPlatforms = lib.platforms.none;

     

       226066
       226066
       +
            }) {};

     

       226067
       226067
       +
       

     

       226224
       226068
        
         "retry" = callPackage

     

       226225
       226069
        
           ({ mkDerivation, base, exceptions, ghc-prim, hedgehog, HUnit, mtl

     

       226226
       226070
        
            , random, stm, tasty, tasty-hedgehog, tasty-hunit, time

     
···

       227165
       227009
        
       

     

       227166
       227010
        
         "rio" = callPackage

     

       227167
       227011
        
           ({ mkDerivation, base, bytestring, containers, deepseq, directory

     

       227168
       227168
       -
            , exceptions, filepath, hashable, hspec, microlens, microlens-mtl

     

       227169
       227169
       -
            , mtl, primitive, process, QuickCheck, text, time, typed-process

     

       227170
       227170
       -
            , unix, unliftio, unliftio-core, unordered-containers, vector

     

       227171
       227171
       -
            }:

     

       227172
       227172
       -
            mkDerivation {

     

       227173
       227173
       -
              pname = "rio";

     

       227174
       227174
       -
              version = "0.1.20.0";

     

       227175
       227175
       -
              sha256 = "0x5b5c0y97b5n1lvbcsqlkhbv4nbbznx1w1fp3a17a03pz7qf61s";

     

       227176
       227176
       -
              libraryHaskellDepends = [

     

       227177
       227177
       -
                base bytestring containers deepseq directory exceptions filepath

     

       227178
       227178
       -
                hashable microlens microlens-mtl mtl primitive process text time

     

       227179
       227179
       -
                typed-process unix unliftio unliftio-core unordered-containers

     

       227180
       227180
       -
                vector

     

       227181
       227181
       -
              ];

     

       227182
       227182
       -
              testHaskellDepends = [

     

       227183
       227183
       -
                base bytestring containers deepseq directory exceptions filepath

     

       227184
       227184
       -
                hashable hspec microlens microlens-mtl mtl primitive process

     

       227185
       227185
       -
                QuickCheck text time typed-process unix unliftio unliftio-core

     

       227186
       227186
       -
                unordered-containers vector

     

       227187
       227187
       -
              ];

     

       227188
       227188
       -
              description = "A standard library for Haskell";

     

       227189
       227189
       -
              license = lib.licenses.mit;

     

       227190
       227190
       -
            }) {};

     

       227191
       227191
       -
       

     

       227192
       227192
       -
         "rio_0_1_21_0" = callPackage

     

       227193
       227193
       -
           ({ mkDerivation, base, bytestring, containers, deepseq, directory

     

       227194
       227012
        
            , exceptions, filepath, hashable, hspec, hspec-discover, microlens

     

       227195
       227013
        
            , microlens-mtl, mtl, primitive, process, QuickCheck, text, time

     

       227196
       227014
        
            , typed-process, unix, unliftio, unliftio-core

     
···

       227215
       227033
        
              testToolDepends = [ hspec-discover ];

     

       227216
       227034
        
              description = "A standard library for Haskell";

     

       227217
       227035
        
              license = lib.licenses.mit;

     

       227218
       227218
       -
              hydraPlatforms = lib.platforms.none;

     

       227219
       227036
        
            }) {};

     

       227220
       227037
        
       

     

       227221
       227038
        
         "rio-app" = callPackage

     
···

       231350
       231167
        
              description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";

     

       231351
       231168
        
              license = lib.licenses.bsd3;

     

       231352
       231169
        
              platforms = [

     

       231353
       231353
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       231170
       231170
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       231171
       231171
       +
                "x86_64-linux"

     

       231354
       231172
        
              ];

     

       231355
       231173
        
              hydraPlatforms = lib.platforms.none;

     

       231356
       231174
        
            }) {inherit (pkgs) z3;};

     
···

       231385
       231203
        
              description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";

     

       231386
       231204
        
              license = lib.licenses.bsd3;

     

       231387
       231205
        
              platforms = [

     

       231388
       231388
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       231206
       231206
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       231207
       231207
       +
                "x86_64-linux"

     

       231389
       231208
        
              ];

     

       231390
       231209
        
            }) {inherit (pkgs) z3;};

     

       231391
       231210
        
       

     

       231211
       231211
       +
         "sbv_8_16" = callPackage

     

       231212
       231212
       +
           ({ mkDerivation, array, async, base, bench-show, bytestring

     

       231213
       231213
       +
            , containers, deepseq, directory, doctest, filepath, gauge, Glob

     

       231214
       231214
       +
            , hlint, libBF, mtl, pretty, process, QuickCheck, random, silently

     

       231215
       231215
       +
            , syb, tasty, tasty-golden, tasty-hunit, tasty-quickcheck

     

       231216
       231216
       +
            , template-haskell, text, time, transformers, uniplate, z3

     

       231217
       231217
       +
            }:

     

       231218
       231218
       +
            mkDerivation {

     

       231219
       231219
       +
              pname = "sbv";

     

       231220
       231220
       +
              version = "8.16";

     

       231221
       231221
       +
              sha256 = "1jmcc9qz659my5i3ir6lq34zfbjp9wcnq61fppic1hlwm39qjppd";

     

       231222
       231222
       +
              enableSeparateDataOutput = true;

     

       231223
       231223
       +
              libraryHaskellDepends = [

     

       231224
       231224
       +
                array async base containers deepseq directory filepath libBF mtl

     

       231225
       231225
       +
                pretty process QuickCheck random syb template-haskell text time

     

       231226
       231226
       +
                transformers uniplate

     

       231227
       231227
       +
              ];

     

       231228
       231228
       +
              testHaskellDepends = [

     

       231229
       231229
       +
                base bytestring containers directory doctest filepath Glob hlint

     

       231230
       231230
       +
                mtl QuickCheck random tasty tasty-golden tasty-hunit

     

       231231
       231231
       +
                tasty-quickcheck

     

       231232
       231232
       +
              ];

     

       231233
       231233
       +
              testSystemDepends = [ z3 ];

     

       231234
       231234
       +
              benchmarkHaskellDepends = [

     

       231235
       231235
       +
                base bench-show containers deepseq directory filepath gauge mtl

     

       231236
       231236
       +
                process random silently syb text time

     

       231237
       231237
       +
              ];

     

       231238
       231238
       +
              description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";

     

       231239
       231239
       +
              license = lib.licenses.bsd3;

     

       231240
       231240
       +
              platforms = [

     

       231241
       231241
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       231242
       231242
       +
                "x86_64-linux"

     

       231243
       231243
       +
              ];

     

       231244
       231244
       +
              hydraPlatforms = lib.platforms.none;

     

       231245
       231245
       +
            }) {inherit (pkgs) z3;};

     

       231246
       231246
       +
       

     

       231392
       231247
        
         "sbvPlugin" = callPackage

     

       231393
       231248
        
           ({ mkDerivation, base, containers, directory, filepath, ghc

     

       231394
       231249
        
            , ghc-prim, mtl, process, sbv, tasty, tasty-golden

     
···

       231748
       231603
        
              ];

     

       231749
       231604
        
              description = "Generates unique passwords for various websites from a single password";

     

       231750
       231605
        
              license = lib.licenses.bsd3;

     

       231751
       231751
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       231606
       231606
       +
              platforms = [

     

       231607
       231607
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       231608
       231608
       +
              ];

     

       231752
       231609
        
            }) {};

     

       231753
       231610
        
       

     

       231754
       231611
        
         "scc" = callPackage

     
···

       232931
       232788
        
              ];

     

       232932
       232789
        
              description = "Stronger password hashing via sequential memory-hard functions";

     

       232933
       232790
        
              license = lib.licenses.bsd3;

     

       232934
       232934
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       232791
       232791
       +
              platforms = [

     

       232792
       232792
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       232793
       232793
       +
              ];

     

       232935
       232794
        
            }) {};

     

       232936
       232795
        
       

     

       232937
       232796
        
         "scrz" = callPackage

     
···

       240292
       240151
        
              license = lib.licenses.bsd3;

     

       240293
       240152
        
              hydraPlatforms = lib.platforms.none;

     

       240294
       240153
        
              broken = true;

     

       240154
       240154
       +
            }) {};

     

       240155
       240155
       +
       

     

       240156
       240156
       +
         "shortbytestring" = callPackage

     

       240157
       240157
       +
           ({ mkDerivation, base, bytestring, deepseq, exceptions, ghc-prim

     

       240158
       240158
       +
            , primitive, random, tasty, tasty-bench, tasty-quickcheck

     

       240159
       240159
       +
            , template-haskell, text, word16, word8

     

       240160
       240160
       +
            }:

     

       240161
       240161
       +
            mkDerivation {

     

       240162
       240162
       +
              pname = "shortbytestring";

     

       240163
       240163
       +
              version = "0.1.0.0";

     

       240164
       240164
       +
              sha256 = "1wjk73xlrk0qgnn8j53ngnikh034v295mm7w9nqadvwg9y3absfy";

     

       240165
       240165
       +
              libraryHaskellDepends = [

     

       240166
       240166
       +
                base bytestring exceptions primitive template-haskell text word16

     

       240167
       240167
       +
                word8

     

       240168
       240168
       +
              ];

     

       240169
       240169
       +
              testHaskellDepends = [

     

       240170
       240170
       +
                base bytestring deepseq ghc-prim tasty tasty-quickcheck word16

     

       240171
       240171
       +
                word8

     

       240172
       240172
       +
              ];

     

       240173
       240173
       +
              benchmarkHaskellDepends = [

     

       240174
       240174
       +
                base bytestring deepseq random tasty-bench

     

       240175
       240175
       +
              ];

     

       240176
       240176
       +
              description = "Additional ShortByteString API";

     

       240177
       240177
       +
              license = lib.licenses.mit;

     

       240295
       240178
        
            }) {};

     

       240296
       240179
        
       

     

       240297
       240180
        
         "shortcircuit" = callPackage

     
···

       246608
       246491
        
              hydraPlatforms = lib.platforms.none;

     

       246609
       246492
        
            }) {};

     

       246610
       246493
        
       

     

       246494
       246494
       +
         "some-dict-of" = callPackage

     

       246495
       246495
       +
           ({ mkDerivation, base, constraints }:

     

       246496
       246496
       +
            mkDerivation {

     

       246497
       246497
       +
              pname = "some-dict-of";

     

       246498
       246498
       +
              version = "0.1.0.0";

     

       246499
       246499
       +
              sha256 = "0c7gr41fqak777wnh0q81mkpv89j6m1q3qqca5r2mzqhkqli4d4d";

     

       246500
       246500
       +
              libraryHaskellDepends = [ base constraints ];

     

       246501
       246501
       +
              testHaskellDepends = [ base constraints ];

     

       246502
       246502
       +
              description = "Carry evidence of constraints around";

     

       246503
       246503
       +
              license = lib.licenses.bsd3;

     

       246504
       246504
       +
            }) {};

     

       246505
       246505
       +
       

     

       246611
       246506
        
         "sonic-visualiser" = callPackage

     

       246612
       246507
        
           ({ mkDerivation, array, base, bytestring, bzlib, containers, mtl

     

       246613
       246508
        
            , pretty, utf8-string, xml

     
···

       248861
       248756
        
              pname = "srt-dhall";

     

       248862
       248757
        
              version = "0.1.0.0";

     

       248863
       248758
        
              sha256 = "16ygxiqb9d0js3gr4823fdkk8pzsairby6iywnvsafas1qvhm0yp";

     

       248759
       248759
       +
              revision = "1";

     

       248760
       248760
       +
              editedCabalFile = "0y1x65mmhsa78svk19nwf7211fny9c4w3gf9d31d10j9bglyly8f";

     

       248864
       248761
        
              libraryHaskellDepends = [

     

       248865
       248762
        
                attoparsec base dhall either formatting simple-media-timestamp

     

       248866
       248763
        
                simple-media-timestamp-formatting srt srt-attoparsec srt-formatting

     
···

       251928
       251825
        
            }:

     

       251929
       251826
        
            mkDerivation {

     

       251930
       251827
        
              pname = "store";

     

       251931
       251931
       -
              version = "0.7.11";

     

       251932
       251932
       -
              sha256 = "03i9gd18xqbfmj5kmiv4k4sw44gn6mn4faj71r2723abm3qwklwr";

     

       251933
       251933
       -
              libraryHaskellDepends = [

     

       251934
       251934
       -
                array async base base-orphans base64-bytestring bifunctors

     

       251935
       251935
       -
                bytestring containers contravariant cryptohash deepseq directory

     

       251936
       251936
       -
                filepath free ghc-prim hashable hspec hspec-smallcheck integer-gmp

     

       251937
       251937
       -
                lifted-base monad-control mono-traversable nats network primitive

     

       251938
       251938
       -
                resourcet safe smallcheck store-core syb template-haskell text

     

       251939
       251939
       -
                th-lift th-lift-instances th-orphans th-reify-many th-utilities

     

       251940
       251940
       -
                time transformers unordered-containers vector void

     

       251941
       251941
       -
              ];

     

       251942
       251942
       -
              testHaskellDepends = [

     

       251943
       251943
       -
                array async base base-orphans base64-bytestring bifunctors

     

       251944
       251944
       -
                bytestring clock containers contravariant cryptohash deepseq

     

       251945
       251945
       -
                directory filepath free ghc-prim hashable hspec hspec-smallcheck

     

       251946
       251946
       -
                integer-gmp lifted-base monad-control mono-traversable nats network

     

       251947
       251947
       -
                primitive resourcet safe smallcheck store-core syb template-haskell

     

       251948
       251948
       -
                text th-lift th-lift-instances th-orphans th-reify-many

     

       251949
       251949
       -
                th-utilities time transformers unordered-containers vector void

     

       251950
       251950
       -
              ];

     

       251951
       251951
       -
              benchmarkHaskellDepends = [

     

       251952
       251952
       -
                array async base base-orphans base64-bytestring bifunctors

     

       251953
       251953
       -
                bytestring cereal cereal-vector containers contravariant criterion

     

       251954
       251954
       -
                cryptohash deepseq directory filepath free ghc-prim hashable hspec

     

       251955
       251955
       -
                hspec-smallcheck integer-gmp lifted-base monad-control

     

       251956
       251956
       -
                mono-traversable nats network primitive resourcet safe smallcheck

     

       251957
       251957
       -
                store-core syb template-haskell text th-lift th-lift-instances

     

       251958
       251958
       -
                th-orphans th-reify-many th-utilities time transformers

     

       251959
       251959
       -
                unordered-containers vector vector-binary-instances void weigh

     

       251960
       251960
       -
              ];

     

       251961
       251961
       -
              description = "Fast binary serialization";

     

       251962
       251962
       -
              license = lib.licenses.mit;

     

       251963
       251963
       -
            }) {};

     

       251964
       251964
       -
       

     

       251965
       251965
       -
         "store_0_7_12" = callPackage

     

       251966
       251966
       -
           ({ mkDerivation, array, async, base, base-orphans

     

       251967
       251967
       -
            , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector

     

       251968
       251968
       -
            , clock, containers, contravariant, criterion, cryptohash, deepseq

     

       251969
       251969
       -
            , directory, filepath, free, ghc-prim, hashable, hspec

     

       251970
       251970
       -
            , hspec-smallcheck, integer-gmp, lifted-base, monad-control

     

       251971
       251971
       -
            , mono-traversable, nats, network, primitive, resourcet, safe

     

       251972
       251972
       -
            , smallcheck, store-core, syb, template-haskell, text, th-lift

     

       251973
       251973
       -
            , th-lift-instances, th-orphans, th-reify-many, th-utilities, time

     

       251974
       251974
       -
            , transformers, unordered-containers, vector

     

       251975
       251975
       -
            , vector-binary-instances, void, weigh

     

       251976
       251976
       -
            }:

     

       251977
       251977
       -
            mkDerivation {

     

       251978
       251978
       -
              pname = "store";

     

       251979
       251828
        
              version = "0.7.12";

     

       251980
       251829
        
              sha256 = "1r6wajaxjlh38bivzmcdx8p0x89g04p6alddlibpa356drzl3jbp";

     

       251981
       251830
        
              libraryHaskellDepends = [

     
···

       252008
       251857
        
              ];

     

       252009
       251858
        
              description = "Fast binary serialization";

     

       252010
       251859
        
              license = lib.licenses.mit;

     

       252011
       252011
       -
              hydraPlatforms = lib.platforms.none;

     

       252012
       251860
        
            }) {};

     

       252013
       251861
        
       

     

       252014
       251862
        
         "store-core" = callPackage

     
···

       259523
       259371
        
              license = lib.licenses.mit;

     

       259524
       259372
        
            }) {};

     

       259525
       259373
        
       

     

       259374
       259374
       +
         "tasty_1_4_2" = callPackage

     

       259375
       259375
       +
           ({ mkDerivation, ansi-terminal, base, clock, containers, mtl

     

       259376
       259376
       +
            , optparse-applicative, stm, tagged, unbounded-delays, unix

     

       259377
       259377
       +
            , wcwidth

     

       259378
       259378
       +
            }:

     

       259379
       259379
       +
            mkDerivation {

     

       259380
       259380
       +
              pname = "tasty";

     

       259381
       259381
       +
              version = "1.4.2";

     

       259382
       259382
       +
              sha256 = "0574hbqzxzyv6vsk5kzbf04kz58y0iy8x9ydcj4b8fpncgmgy63g";

     

       259383
       259383
       +
              libraryHaskellDepends = [

     

       259384
       259384
       +
                ansi-terminal base clock containers mtl optparse-applicative stm

     

       259385
       259385
       +
                tagged unbounded-delays unix wcwidth

     

       259386
       259386
       +
              ];

     

       259387
       259387
       +
              description = "Modern and extensible testing framework";

     

       259388
       259388
       +
              license = lib.licenses.mit;

     

       259389
       259389
       +
              hydraPlatforms = lib.platforms.none;

     

       259390
       259390
       +
            }) {};

     

       259391
       259391
       +
       

     

       259526
       259392
        
         "tasty-ant-xml" = callPackage

     

       259527
       259393
        
           ({ mkDerivation, base, containers, directory, filepath

     

       259528
       259394
        
            , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers

     
···

       259639
       259505
        
           ({ mkDerivation, base, dejafu, random, tagged, tasty }:

     

       259640
       259506
        
            mkDerivation {

     

       259641
       259507
        
              pname = "tasty-dejafu";

     

       259642
       259642
       -
              version = "2.0.0.7";

     

       259643
       259643
       -
              sha256 = "0jzaqra7gsrvy33j1g6bnrwg7x5pyg5p50l5mgvpz71kd946725l";

     

       259644
       259644
       -
              libraryHaskellDepends = [ base dejafu random tagged tasty ];

     

       259645
       259645
       -
              description = "Deja Fu support for the Tasty test framework";

     

       259646
       259646
       -
              license = lib.licenses.mit;

     

       259647
       259647
       -
            }) {};

     

       259648
       259648
       -
       

     

       259649
       259649
       -
         "tasty-dejafu_2_0_0_8" = callPackage

     

       259650
       259650
       -
           ({ mkDerivation, base, dejafu, random, tagged, tasty }:

     

       259651
       259651
       -
            mkDerivation {

     

       259652
       259652
       -
              pname = "tasty-dejafu";

     

       259653
       259508
        
              version = "2.0.0.8";

     

       259654
       259509
        
              sha256 = "0v0vkbj8nr4jg62a5c0qygj1pjkz1vnssiicafv87qis02j36myx";

     

       259655
       259510
        
              libraryHaskellDepends = [ base dejafu random tagged tasty ];

     

       259656
       259511
        
              description = "Deja Fu support for the Tasty test framework";

     

       259657
       259512
        
              license = lib.licenses.mit;

     

       259658
       259658
       -
              hydraPlatforms = lib.platforms.none;

     

       259659
       259513
        
            }) {};

     

       259660
       259514
        
       

     

       259661
       259515
        
         "tasty-discover" = callPackage

     
···

       262916
       262770
        
            }:

     

       262917
       262771
        
            mkDerivation {

     

       262918
       262772
        
              pname = "texmath";

     

       262919
       262919
       -
              version = "0.12.3";

     

       262920
       262920
       -
              sha256 = "0lhbgnswhss56lrp25i70hvmn6zg6xcfwdigfmwjggmhz0h5q88x";

     

       262921
       262921
       -
              isLibrary = true;

     

       262922
       262922
       -
              isExecutable = true;

     

       262923
       262923
       -
              libraryHaskellDepends = [

     

       262924
       262924
       -
                base containers mtl pandoc-types parsec split syb text xml

     

       262925
       262925
       -
              ];

     

       262926
       262926
       -
              testHaskellDepends = [

     

       262927
       262927
       -
                base bytestring directory filepath process temporary text

     

       262928
       262928
       -
                utf8-string xml

     

       262929
       262929
       -
              ];

     

       262930
       262930
       -
              description = "Conversion between formats used to represent mathematics";

     

       262931
       262931
       -
              license = lib.licenses.gpl2Only;

     

       262932
       262932
       -
            }) {};

     

       262933
       262933
       -
       

     

       262934
       262934
       -
         "texmath_0_12_3_1" = callPackage

     

       262935
       262935
       -
           ({ mkDerivation, base, bytestring, containers, directory, filepath

     

       262936
       262936
       -
            , mtl, pandoc-types, parsec, process, split, syb, temporary, text

     

       262937
       262937
       -
            , utf8-string, xml

     

       262938
       262938
       -
            }:

     

       262939
       262939
       -
            mkDerivation {

     

       262940
       262940
       -
              pname = "texmath";

     

       262941
       262773
        
              version = "0.12.3.1";

     

       262942
       262774
        
              sha256 = "1qyiihb9h7w7074p495yd4s8dj9adz0dy865gyp822z69jvmkcki";

     

       262943
       262775
        
              isLibrary = true;

     
···

       262951
       262783
        
              ];

     

       262952
       262784
        
              description = "Conversion between formats used to represent mathematics";

     

       262953
       262785
        
              license = lib.licenses.gpl2Only;

     

       262954
       262954
       -
              hydraPlatforms = lib.platforms.none;

     

       262955
       262786
        
            }) {};

     

       262956
       262787
        
       

     

       262957
       262788
        
         "texrunner" = callPackage

     
···

       263455
       263286
        
              benchmarkHaskellDepends = [ base criterion deepseq text weigh ];

     

       263456
       263287
        
              description = "Calculate various string metrics efficiently";

     

       263457
       263288
        
              license = lib.licenses.bsd3;

     

       263289
       263289
       +
            }) {};

     

       263290
       263290
       +
       

     

       263291
       263291
       +
         "text-metrics_0_3_1" = callPackage

     

       263292
       263292
       +
           ({ mkDerivation, base, containers, criterion, deepseq, hspec

     

       263293
       263293
       +
            , QuickCheck, text, vector, weigh

     

       263294
       263294
       +
            }:

     

       263295
       263295
       +
            mkDerivation {

     

       263296
       263296
       +
              pname = "text-metrics";

     

       263297
       263297
       +
              version = "0.3.1";

     

       263298
       263298
       +
              sha256 = "17bp1lnbkqr5ykrcd6v5sqv0fhljck7hky8zrrpw7rlkb1f3sdc2";

     

       263299
       263299
       +
              libraryHaskellDepends = [ base containers text vector ];

     

       263300
       263300
       +
              testHaskellDepends = [ base hspec QuickCheck text ];

     

       263301
       263301
       +
              benchmarkHaskellDepends = [ base criterion deepseq text weigh ];

     

       263302
       263302
       +
              description = "Calculate various string metrics efficiently";

     

       263303
       263303
       +
              license = lib.licenses.bsd3;

     

       263304
       263304
       +
              hydraPlatforms = lib.platforms.none;

     

       263458
       263305
        
            }) {};

     

       263459
       263306
        
       

     

       263460
       263307
        
         "text-normal" = callPackage

     
···

       265577
       265424
        
              license = lib.licenses.bsd3;

     

       265578
       265425
        
            }) {};

     

       265579
       265426
        
       

     

       265427
       265427
       +
         "ticket-management" = callPackage

     

       265428
       265428
       +
           ({ mkDerivation, base, bytestring, cereal, containers, directory

     

       265429
       265429
       +
            , optparse-applicative, QuickCheck, text, time, unliftio

     

       265430
       265430
       +
            }:

     

       265431
       265431
       +
            mkDerivation {

     

       265432
       265432
       +
              pname = "ticket-management";

     

       265433
       265433
       +
              version = "0.2.0.0";

     

       265434
       265434
       +
              sha256 = "0cbdkjjh2sfsj4cjgxvxjrva6rb0gli36q3g8idhwf7wa2llyz4w";

     

       265435
       265435
       +
              isLibrary = true;

     

       265436
       265436
       +
              isExecutable = true;

     

       265437
       265437
       +
              libraryHaskellDepends = [

     

       265438
       265438
       +
                base bytestring cereal containers directory optparse-applicative

     

       265439
       265439
       +
                QuickCheck text time unliftio

     

       265440
       265440
       +
              ];

     

       265441
       265441
       +
              executableHaskellDepends = [ base ];

     

       265442
       265442
       +
              testHaskellDepends = [ base QuickCheck text ];

     

       265443
       265443
       +
              description = "A basic implementation of a personal ticket management system";

     

       265444
       265444
       +
              license = lib.licenses.mit;

     

       265445
       265445
       +
              hydraPlatforms = lib.platforms.none;

     

       265446
       265446
       +
              broken = true;

     

       265447
       265447
       +
            }) {};

     

       265448
       265448
       +
       

     

       265580
       265449
        
         "tickle" = callPackage

     

       265581
       265450
        
           ({ mkDerivation, base, bifunctors, bytestring, checkers, filepath

     

       265582
       265451
        
            , lens, mtl, papa, QuickCheck, semigroupoids, semigroups, tasty

     
···

       267094
       266963
        
            }:

     

       267095
       266964
        
            mkDerivation {

     

       267096
       266965
        
              pname = "tldr";

     

       267097
       267097
       -
              version = "0.9.0";

     

       267098
       267098
       -
              sha256 = "0dixx8i6ka3ksfcr6bjybs1i3ry0wpiffsmskh56cxxcys0jgm5h";

     

       267099
       267099
       -
              isLibrary = true;

     

       267100
       267100
       -
              isExecutable = true;

     

       267101
       267101
       -
              libraryHaskellDepends = [

     

       267102
       267102
       -
                ansi-terminal base bytestring cmark containers directory filepath

     

       267103
       267103
       -
                http-conduit optparse-applicative semigroups text time zip-archive

     

       267104
       267104
       -
              ];

     

       267105
       267105
       -
              executableHaskellDepends = [ base ];

     

       267106
       267106
       -
              testHaskellDepends = [ base tasty tasty-golden ];

     

       267107
       267107
       -
              description = "Haskell tldr client";

     

       267108
       267108
       -
              license = lib.licenses.bsd3;

     

       267109
       267109
       -
            }) {};

     

       267110
       267110
       -
       

     

       267111
       267111
       -
         "tldr_0_9_1" = callPackage

     

       267112
       267112
       -
           ({ mkDerivation, ansi-terminal, base, bytestring, cmark, containers

     

       267113
       267113
       -
            , directory, filepath, http-conduit, optparse-applicative

     

       267114
       267114
       -
            , semigroups, tasty, tasty-golden, text, time, zip-archive

     

       267115
       267115
       -
            }:

     

       267116
       267116
       -
            mkDerivation {

     

       267117
       267117
       -
              pname = "tldr";

     

       267118
       266966
        
              version = "0.9.1";

     

       267119
       266967
        
              sha256 = "0xgj3mf51iv68fhgyrjvxfmzrbcwnk7siaynm213x0kgcyvkwbz0";

     

       267120
       266968
        
              isLibrary = true;

     
···

       267127
       266975
        
              testHaskellDepends = [ base tasty tasty-golden ];

     

       267128
       266976
        
              description = "Haskell tldr client";

     

       267129
       266977
        
              license = lib.licenses.bsd3;

     

       267130
       267130
       -
              hydraPlatforms = lib.platforms.none;

     

       267131
       266978
        
            }) {};

     

       267132
       266979
        
       

     

       267133
       266980
        
         "tlex" = callPackage

     
···

       269125
       268972
        
            }:

     

       269126
       268973
        
            mkDerivation {

     

       269127
       268974
        
              pname = "transformers-base";

     

       269128
       269128
       -
              version = "0.4.5.2";

     

       269129
       269129
       -
              sha256 = "1s256bi0yh0x2hp2gwd30f3mg1cv53zz397dv1yhfsnfzmihrj6h";

     

       269130
       269130
       -
              revision = "1";

     

       269131
       269131
       -
              editedCabalFile = "18j122ypx12rbl9bbf622fvj8nif4rsci8z4qw2llmznbvfl09s0";

     

       269132
       269132
       -
              libraryHaskellDepends = [

     

       269133
       269133
       -
                base base-orphans stm transformers transformers-compat

     

       269134
       269134
       -
              ];

     

       269135
       269135
       -
              description = "Lift computations from the bottom of a transformer stack";

     

       269136
       269136
       -
              license = lib.licenses.bsd3;

     

       269137
       269137
       -
            }) {};

     

       269138
       269138
       -
       

     

       269139
       269139
       -
         "transformers-base_0_4_6" = callPackage

     

       269140
       269140
       -
           ({ mkDerivation, base, base-orphans, stm, transformers

     

       269141
       269141
       -
            , transformers-compat

     

       269142
       269142
       -
            }:

     

       269143
       269143
       -
            mkDerivation {

     

       269144
       269144
       -
              pname = "transformers-base";

     

       269145
       268975
        
              version = "0.4.6";

     

       269146
       268976
        
              sha256 = "146g69yxmlrmvqnzwcw4frxfl3z04lda9zqwcqib34dnkrlghfrj";

     

       269147
       268977
        
              libraryHaskellDepends = [

     
···

       269149
       268979
        
              ];

     

       269150
       268980
        
              description = "Lift computations from the bottom of a transformer stack";

     

       269151
       268981
        
              license = lib.licenses.bsd3;

     

       269152
       269152
       -
              hydraPlatforms = lib.platforms.none;

     

       269153
       268982
        
            }) {};

     

       269154
       268983
        
       

     

       269155
       268984
        
         "transformers-bifunctors" = callPackage

     
···

       270833
       270662
        
              license = lib.licenses.mit;

     

       270834
       270663
        
            }) {};

     

       270835
       270664
        
       

     

       270665
       270665
       +
         "ttc_1_1_0_2" = callPackage

     

       270666
       270666
       +
           ({ mkDerivation, base, bytestring, tasty, tasty-hunit

     

       270667
       270667
       +
            , template-haskell, text

     

       270668
       270668
       +
            }:

     

       270669
       270669
       +
            mkDerivation {

     

       270670
       270670
       +
              pname = "ttc";

     

       270671
       270671
       +
              version = "1.1.0.2";

     

       270672
       270672
       +
              sha256 = "0i1jnign6xb0i4y5rkwz2rp2lj7q3r50i4bkjghz8i2djw2sd1cw";

     

       270673
       270673
       +
              libraryHaskellDepends = [ base bytestring template-haskell text ];

     

       270674
       270674
       +
              testHaskellDepends = [

     

       270675
       270675
       +
                base bytestring tasty tasty-hunit template-haskell text

     

       270676
       270676
       +
              ];

     

       270677
       270677
       +
              description = "Textual Type Classes";

     

       270678
       270678
       +
              license = lib.licenses.mit;

     

       270679
       270679
       +
              hydraPlatforms = lib.platforms.none;

     

       270680
       270680
       +
            }) {};

     

       270681
       270681
       +
       

     

       270836
       270682
        
         "ttl-hashtables" = callPackage

     

       270837
       270683
        
           ({ mkDerivation, base, clock, containers, data-default, failable

     

       270838
       270684
        
            , hashable, hashtables, hspec, mtl, transformers

     
···

       272214
       272060
        
           ({ mkDerivation, base, doctest, Glob }:

     

       272215
       272061
        
            mkDerivation {

     

       272216
       272062
        
              pname = "type-errors-pretty";

     

       272217
       272217
       -
              version = "0.0.1.1";

     

       272218
       272218
       -
              sha256 = "1z6rqah3qnvnlckcw3xhsp4yyfd21harw6kzqbz20y6k7a22jlf0";

     

       272219
       272219
       -
              revision = "1";

     

       272220
       272220
       -
              editedCabalFile = "1qfm0018ids9s7kdwf6d3r1cwnb5aqn55in4vdwklas3ydi8mmrx";

     

       272221
       272221
       -
              libraryHaskellDepends = [ base ];

     

       272222
       272222
       -
              testHaskellDepends = [ base doctest Glob ];

     

       272223
       272223
       -
              description = "Combinators for writing pretty type errors easily";

     

       272224
       272224
       -
              license = lib.licenses.mpl20;

     

       272225
       272225
       -
            }) {};

     

       272226
       272226
       -
       

     

       272227
       272227
       -
         "type-errors-pretty_0_0_1_2" = callPackage

     

       272228
       272228
       -
           ({ mkDerivation, base, doctest, Glob }:

     

       272229
       272229
       -
            mkDerivation {

     

       272230
       272230
       -
              pname = "type-errors-pretty";

     

       272231
       272063
        
              version = "0.0.1.2";

     

       272232
       272064
        
              sha256 = "01zdb5mw77d5rj3yvabqdch132mjw49awpjnjvms20hdhwjgqb6b";

     

       272233
       272065
        
              libraryHaskellDepends = [ base ];

     

       272234
       272066
        
              testHaskellDepends = [ base doctest Glob ];

     

       272235
       272067
        
              description = "Combinators for writing pretty type errors easily";

     

       272236
       272068
        
              license = lib.licenses.mpl20;

     

       272237
       272237
       -
              hydraPlatforms = lib.platforms.none;

     

       272238
       272069
        
            }) {};

     

       272239
       272070
        
       

     

       272240
       272071
        
         "type-fun" = callPackage

     
···

       272906
       272737
        
            }:

     

       272907
       272738
        
            mkDerivation {

     

       272908
       272739
        
              pname = "typed-process";

     

       272909
       272909
       -
              version = "0.2.6.0";

     

       272910
       272910
       -
              sha256 = "1cf2pfym8zdxvvy7xv72ixj7wy3rjrdss6f57k1ysgs66cgsi8ii";

     

       272911
       272911
       -
              libraryHaskellDepends = [

     

       272912
       272912
       -
                async base bytestring process stm transformers unliftio-core

     

       272913
       272913
       -
              ];

     

       272914
       272914
       -
              testHaskellDepends = [

     

       272915
       272915
       -
                async base base64-bytestring bytestring hspec process stm temporary

     

       272916
       272916
       -
                transformers unliftio-core

     

       272917
       272917
       -
              ];

     

       272918
       272918
       -
              description = "Run external processes, with strong typing of streams";

     

       272919
       272919
       -
              license = lib.licenses.mit;

     

       272920
       272920
       -
            }) {};

     

       272921
       272921
       -
       

     

       272922
       272922
       -
         "typed-process_0_2_6_1" = callPackage

     

       272923
       272923
       -
           ({ mkDerivation, async, base, base64-bytestring, bytestring, hspec

     

       272924
       272924
       -
            , process, stm, temporary, transformers, unliftio-core

     

       272925
       272925
       -
            }:

     

       272926
       272926
       -
            mkDerivation {

     

       272927
       272927
       -
              pname = "typed-process";

     

       272928
       272740
        
              version = "0.2.6.1";

     

       272929
       272741
        
              sha256 = "0w4c76qln49967nnhf7f1zj3gbdfqp2qgf5ym8svhqyhp5gh61ws";

     

       272930
       272742
        
              libraryHaskellDepends = [

     
···

       272936
       272748
        
              ];

     

       272937
       272749
        
              description = "Run external processes, with strong typing of streams";

     

       272938
       272750
        
              license = lib.licenses.mit;

     

       272939
       272939
       -
              hydraPlatforms = lib.platforms.none;

     

       272940
       272751
        
            }) {};

     

       272941
       272752
        
       

     

       272942
       272753
        
         "typed-spreadsheet" = callPackage

     
···

       278219
       278030
        
              broken = true;

     

       278220
       278031
        
            }) {};

     

       278221
       278032
        
       

     

       278033
       278033
       +
         "valida" = callPackage

     

       278034
       278034
       +
           ({ mkDerivation, base, smallcheck, tasty, tasty-hunit

     

       278035
       278035
       +
            , tasty-quickcheck, tasty-smallcheck

     

       278036
       278036
       +
            }:

     

       278037
       278037
       +
            mkDerivation {

     

       278038
       278038
       +
              pname = "valida";

     

       278039
       278039
       +
              version = "0.1.0";

     

       278040
       278040
       +
              sha256 = "1spdf40jcm9b6ah18m5nw550x2mlq4bjmqvscf4cnjpc7izdmdng";

     

       278041
       278041
       +
              libraryHaskellDepends = [ base ];

     

       278042
       278042
       +
              testHaskellDepends = [

     

       278043
       278043
       +
                base smallcheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck

     

       278044
       278044
       +
              ];

     

       278045
       278045
       +
              description = "Simple applicative validation for product types, batteries included!";

     

       278046
       278046
       +
              license = lib.licenses.mit;

     

       278047
       278047
       +
            }) {};

     

       278048
       278048
       +
       

     

       278222
       278049
        
         "validate" = callPackage

     

       278223
       278050
        
           ({ mkDerivation }:

     

       278224
       278051
        
            mkDerivation {

     
···

       279814
       279641
        
              description = "An intermediate language for Hoare logic style verification";

     

       279815
       279642
        
              license = lib.licenses.asl20;

     

       279816
       279643
        
              platforms = [

     

       279817
       279817
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       279644
       279644
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       279645
       279645
       +
                "x86_64-linux"

     

       279818
       279646
        
              ];

     

       279819
       279647
        
            }) {};

     

       279820
       279648
        
       

     
···

       281116
       280944
        
            }:

     

       281117
       280945
        
            mkDerivation {

     

       281118
       280946
        
              pname = "vulkan";

     

       281119
       281119
       -
              version = "3.12.1";

     

       281120
       281120
       -
              sha256 = "0y9ykv0dx5hvh2683yyn8mdl3jxqk9zaf2a1rkyr5zgc43wsbm05";

     

       280947
       280947
       +
              version = "3.12.2";

     

       280948
       280948
       +
              sha256 = "1vypjnwvvvd0rw99qsb00jnwpq792s9x1wi62zdyzq9cwlf47ici";

     

       281121
       280949
        
              libraryHaskellDepends = [ base bytestring transformers vector ];

     

       281122
       280950
        
              libraryPkgconfigDepends = [ vulkan ];

     

       281123
       280951
        
              testHaskellDepends = [

     
···

       281979
       281807
        
            }) {};

     

       281980
       281808
        
       

     

       281981
       281809
        
         "wai-middleware-auth" = callPackage

     

       281982
       281982
       -
           ({ mkDerivation, aeson, base, base64-bytestring, binary

     

       281983
       281983
       -
            , blaze-builder, blaze-html, bytestring, case-insensitive, cereal

     

       281984
       281984
       -
            , clientsession, cookie, exceptions, hedgehog, hoauth2, http-client

     

       281985
       281985
       -
            , http-client-tls, http-conduit, http-reverse-proxy, http-types

     

       281986
       281986
       -
            , jose, microlens, mtl, optparse-applicative, optparse-simple

     

       281987
       281987
       -
            , regex-posix, safe-exceptions, shakespeare, tasty, tasty-hedgehog

     

       281988
       281988
       -
            , tasty-hunit, text, time, unix-compat, unordered-containers

     

       281989
       281989
       -
            , uri-bytestring, vault, wai, wai-app-static, wai-extra, warp, yaml

     

       281990
       281990
       -
            }:

     

       281991
       281991
       -
            mkDerivation {

     

       281992
       281992
       -
              pname = "wai-middleware-auth";

     

       281993
       281993
       -
              version = "0.2.5.0";

     

       281994
       281994
       -
              sha256 = "12yv8rcybd7saflfcyjy08p1m6il07nk831pkj0isxk8mwjq64l4";

     

       281995
       281995
       -
              isLibrary = true;

     

       281996
       281996
       -
              isExecutable = true;

     

       281997
       281997
       -
              libraryHaskellDepends = [

     

       281998
       281998
       -
                aeson base base64-bytestring binary blaze-builder blaze-html

     

       281999
       281999
       -
                bytestring case-insensitive cereal clientsession cookie exceptions

     

       282000
       282000
       -
                hoauth2 http-client http-client-tls http-conduit http-reverse-proxy

     

       282001
       282001
       -
                http-types jose microlens mtl regex-posix safe-exceptions

     

       282002
       282002
       -
                shakespeare text time unix-compat unordered-containers

     

       282003
       282003
       -
                uri-bytestring vault wai wai-app-static wai-extra yaml

     

       282004
       282004
       -
              ];

     

       282005
       282005
       -
              executableHaskellDepends = [

     

       282006
       282006
       -
                base bytestring cereal clientsession optparse-applicative

     

       282007
       282007
       -
                optparse-simple wai-extra warp

     

       282008
       282008
       -
              ];

     

       282009
       282009
       -
              testHaskellDepends = [

     

       282010
       282010
       -
                aeson base binary bytestring clientsession cookie hedgehog hoauth2

     

       282011
       282011
       -
                http-types jose microlens mtl tasty tasty-hedgehog tasty-hunit text

     

       282012
       282012
       -
                time uri-bytestring wai wai-extra warp

     

       282013
       282013
       -
              ];

     

       282014
       282014
       -
              description = "Authentication middleware that secures WAI application";

     

       282015
       282015
       -
              license = lib.licenses.mit;

     

       282016
       282016
       -
            }) {};

     

       282017
       282017
       -
       

     

       282018
       282018
       -
         "wai-middleware-auth_0_2_5_1" = callPackage

     

       282019
       281810
        
           ({ mkDerivation, aeson, base, base64-bytestring, binary

     

       282020
       281811
        
            , blaze-builder, blaze-html, bytestring, case-insensitive, cereal

     

       282021
       281812
        
            , clientsession, cookie, exceptions, hedgehog, hoauth2, http-client

     
···

       282050
       281841
        
              ];

     

       282051
       281842
        
              description = "Authentication middleware that secures WAI application";

     

       282052
       281843
        
              license = lib.licenses.mit;

     

       282053
       282053
       -
              hydraPlatforms = lib.platforms.none;

     

       282054
       281844
        
            }) {};

     

       282055
       281845
        
       

     

       282056
       281846
        
         "wai-middleware-brotli" = callPackage

     
···

       285217
       285007
        
              hydraPlatforms = lib.platforms.none;

     

       285218
       285008
        
            }) {};

     

       285219
       285009
        
       

     

       285010
       285010
       +
         "wgpu-hs" = callPackage

     

       285011
       285011
       +
           ({ mkDerivation, base, bytestring, data-default, GLFW-b, text

     

       285012
       285012
       +
            , transformers, vector, wgpu-raw-hs

     

       285013
       285013
       +
            }:

     

       285014
       285014
       +
            mkDerivation {

     

       285015
       285015
       +
              pname = "wgpu-hs";

     

       285016
       285016
       +
              version = "0.2.0.0";

     

       285017
       285017
       +
              sha256 = "1kc5xmknfhh9dmn90rbnplmx8n7f07xwvrvz7dcybjpiw8pr2dml";

     

       285018
       285018
       +
              isLibrary = true;

     

       285019
       285019
       +
              isExecutable = true;

     

       285020
       285020
       +
              libraryHaskellDepends = [

     

       285021
       285021
       +
                base bytestring data-default GLFW-b text transformers vector

     

       285022
       285022
       +
                wgpu-raw-hs

     

       285023
       285023
       +
              ];

     

       285024
       285024
       +
              executableHaskellDepends = [

     

       285025
       285025
       +
                base data-default GLFW-b text transformers

     

       285026
       285026
       +
              ];

     

       285027
       285027
       +
              doHaddock = false;

     

       285028
       285028
       +
              description = "WGPU";

     

       285029
       285029
       +
              license = lib.licenses.bsd3;

     

       285030
       285030
       +
            }) {};

     

       285031
       285031
       +
       

     

       285220
       285032
        
         "wgpu-raw-hs" = callPackage

     

       285221
       285033
        
           ({ mkDerivation, base, GLFW-b, unix }:

     

       285222
       285034
        
            mkDerivation {

     

       285223
       285035
        
              pname = "wgpu-raw-hs";

     

       285224
       285224
       -
              version = "0.1.0.2";

     

       285225
       285225
       -
              sha256 = "1hagn99jdmwjcyz2afmmd9ws31dncas9fssv6lx75kshar6x4rah";

     

       285226
       285226
       -
              isLibrary = true;

     

       285227
       285227
       -
              isExecutable = true;

     

       285036
       285036
       +
              version = "0.2.0.0";

     

       285037
       285037
       +
              sha256 = "05dzz6q5laxw7wwhly7v5i4bppfqz4yahh8qq6qc0h2c8v0qmdzp";

     

       285228
       285038
        
              libraryHaskellDepends = [ base GLFW-b unix ];

     

       285229
       285229
       -
              executableHaskellDepends = [ base GLFW-b ];

     

       285230
       285039
        
              description = "WGPU Raw";

     

       285231
       285040
        
              license = lib.licenses.bsd3;

     

       285232
       285041
        
            }) {};

     
···

       286365
       286174
        
              license = lib.licenses.bsd3;

     

       286366
       286175
        
            }) {};

     

       286367
       286176
        
       

     

       286177
       286177
       +
         "word16" = callPackage

     

       286178
       286178
       +
           ({ mkDerivation, base, bytestring, criterion, hspec, hspec-discover

     

       286179
       286179
       +
            , template-haskell, text

     

       286180
       286180
       +
            }:

     

       286181
       286181
       +
            mkDerivation {

     

       286182
       286182
       +
              pname = "word16";

     

       286183
       286183
       +
              version = "0.1.0.0";

     

       286184
       286184
       +
              sha256 = "0z2nabnh7b42bl7hqy2iw68a1gxay26pgsid7m4hs8s2d7cghndx";

     

       286185
       286185
       +
              libraryHaskellDepends = [ base bytestring template-haskell text ];

     

       286186
       286186
       +
              testHaskellDepends = [ base hspec ];

     

       286187
       286187
       +
              testToolDepends = [ hspec-discover ];

     

       286188
       286188
       +
              benchmarkHaskellDepends = [ base bytestring criterion ];

     

       286189
       286189
       +
              description = "Word16 library";

     

       286190
       286190
       +
              license = lib.licenses.mit;

     

       286191
       286191
       +
            }) {};

     

       286192
       286192
       +
       

     

       286368
       286193
        
         "word24" = callPackage

     

       286369
       286194
        
           ({ mkDerivation, base, criterion, deepseq, QuickCheck

     

       286370
       286195
        
            , test-framework, test-framework-quickcheck2

     
···

       288182
       288007
        
              executableSystemDepends = [ xgboost ];

     

       288183
       288008
        
              description = "XGBoost library for Haskell";

     

       288184
       288009
        
              license = lib.licenses.mit;

     

       288185
       288185
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       288010
       288010
       +
              platforms = [

     

       288011
       288011
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       288012
       288012
       +
              ];

     

       288186
       288013
        
            }) {inherit (pkgs) xgboost;};

     

       288187
       288014
        
       

     

       288188
       288015
        
         "xhaskell-library" = callPackage

     
···

       291012
       290839
        
            }) {};

     

       291013
       290840
        
       

     

       291014
       290841
        
         "yapb" = callPackage

     

       291015
       291015
       -
           ({ mkDerivation, base, bytestring, directory, hashable, network

     

       291016
       291016
       -
            , process, regex-tdfa

     

       290842
       290842
       +
           ({ mkDerivation, base, bytestring, directory, hashable, hspec

     

       290843
       290843
       +
            , network, process, regex-tdfa

     

       291017
       290844
        
            }:

     

       291018
       290845
        
            mkDerivation {

     

       291019
       290846
        
              pname = "yapb";

     

       291020
       291020
       -
              version = "0.1.1";

     

       291021
       291021
       -
              sha256 = "1zbk2whfi09wzx9ql4dhkbg50s7v45y309avxljypg7z9i9pvx3x";

     

       290847
       290847
       +
              version = "0.1.3";

     

       290848
       290848
       +
              sha256 = "11p3ygnfpsh9dqlnpppi02baa5bk86pw6w6f1gawdd848qh7q9if";

     

       291022
       290849
        
              isLibrary = true;

     

       291023
       290850
        
              isExecutable = true;

     

       291024
       290851
        
              libraryHaskellDepends = [

     

       291025
       291025
       -
                base bytestring directory hashable network process regex-tdfa

     

       290852
       290852
       +
                base bytestring directory hashable hspec network process regex-tdfa

     

       291026
       290853
        
              ];

     

       291027
       291027
       -
              executableHaskellDepends = [ base regex-tdfa ];

     

       291028
       291028
       -
              testHaskellDepends = [ base ];

     

       290854
       290854
       +
              executableHaskellDepends = [ base hspec regex-tdfa ];

     

       290855
       290855
       +
              testHaskellDepends = [ base hspec process ];

     

       291029
       290856
        
              description = "Yet Another Parser Builder (YAPB)";

     

       291030
       290857
        
              license = lib.licenses.bsd3;

     

       290858
       290858
       +
              hydraPlatforms = lib.platforms.none;

     

       290859
       290859
       +
              broken = true;

     

       291031
       290860
        
            }) {};

     

       291032
       290861
        
       

     

       291033
       290862
        
         "yarn-lock" = callPackage

     
···

       291857
       291686
        
              ];

     

       291858
       291687
        
              description = "A yesod-auth plugin for LTI 1.3";

     

       291859
       291688
        
              license = lib.licenses.lgpl3Only;

     

       291860
       291860
       -
              hydraPlatforms = lib.platforms.none;

     

       291861
       291689
        
            }) {};

     

       291862
       291690
        
       

     

       291863
       291691
        
         "yesod-auth-nopassword" = callPackage

+16 -1

pkgs/development/libraries/fftw/default.nix

···

       1
       1
       -
       { fetchurl, stdenv, lib, gfortran, llvmPackages ? null, precision ? "double", perl }:

     

       1
       1
       +
       { fetchurl

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , lib

     

       4
       4
       +
       , gfortran

     

       5
       5
       +
       , perl

     

       6
       6
       +
       , llvmPackages ? null

     

       7
       7
       +
       , precision ? "double"

     

       8
       8
       +
       , enableAvx ? stdenv.hostPlatform.avxSupport

     

       9
       9
       +
       , enableAvx2 ? stdenv.hostPlatform.avx2Support

     

       10
       10
       +
       , enableAvx512 ? stdenv.hostPlatform.avx512Support

     

       11
       11
       +
       , enableFma ? stdenv.hostPlatform.fmaSupport

     

       12
       12
       +
       }:

     

       2
       13
        
       

     

       3
       14
        
       with lib;

     

       4
       15
        
       

     
···

       40
       51
        
           # all x86_64 have sse2

     

       41
       52
        
           # however, not all float sizes fit

     

       42
       53
        
           ++ optional (stdenv.isx86_64 && (precision == "single" || precision == "double") )  "--enable-sse2"

     

       54
       54
       +
           ++ optional enableAvx "--enable-avx"

     

       55
       55
       +
           ++ optional enableAvx2 "--enable-avx2"

     

       56
       56
       +
           ++ optional enableAvx512 "--enable-avx512"

     

       57
       57
       +
           ++ optional enableFma "--enable-fma"

     

       43
       58
        
           ++ [ "--enable-openmp" ]

     

       44
       59
        
           # doc generation causes Fortran wrapper generation which hard-codes gcc

     

       45
       60
        
           ++ optional (!withDoc) "--disable-doc";

+29

pkgs/development/libraries/kddockwidgets/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , mkDerivation

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , cmake

     

       5
       5
       +
       , qtbase

     

       6
       6
       +
       , qtx11extras

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       mkDerivation rec {

     

       10
       10
       +
         pname = "KDDockWidgets";

     

       11
       11
       +
         version = "1.4.0";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchFromGitHub {

     

       14
       14
       +
           owner = "KDAB";

     

       15
       15
       +
           repo = pname;

     

       16
       16
       +
           rev = "v${version}";

     

       17
       17
       +
           sha256 = "sha256-lgNRuRoJhBw0n/Hb58uxpa+4aXoOrK4bRldtIXYIKLI=";

     

       18
       18
       +
         };

     

       19
       19
       +
       

     

       20
       20
       +
         nativeBuildInputs = [ cmake ];

     

       21
       21
       +
         buildInputs = [ qtbase qtx11extras ];

     

       22
       22
       +
       

     

       23
       23
       +
         meta = with lib; {

     

       24
       24
       +
           description = "KDAB's Dock Widget Framework for Qt";

     

       25
       25
       +
           homepage = "https://www.kdab.com/development-resources/qt-tools/kddockwidgets";

     

       26
       26
       +
           license = with licenses; [ gpl2Only gpl3Only ];

     

       27
       27
       +
           maintainers = with maintainers; [ _1000teslas ];

     

       28
       28
       +
         };

     

       29
       29
       +
       }

+2 -1

pkgs/development/libraries/libint/default.nix

···

       1
       1
        
       { lib, stdenv, fetchFromGitHub, autoconf, automake, libtool

     

       2
       2
        
       , python3, perl, gmpxx, mpfr, boost, eigen, gfortran, cmake

     

       3
       3
       -
       , enableFMA ? false, enableFortran ? true

     

       3
       3
       +
       , enableFMA ? stdenv.hostPlatform.fmaSupport

     

       4
       4
       +
       , enableFortran ? true

     

       4
       5
        
       }:

     

       5
       6
        
       

     

       6
       7
        
       let

+73

pkgs/development/libraries/rustc-demangle/add-Cargo.lock.patch

···

       1
       1
       +
       diff --git a/Cargo.lock b/Cargo.lock

     

       2
       2
       +
       new file mode 100644

     

       3
       3
       +
       index 0000000..0268b3b

     

       4
       4
       +
       --- /dev/null

     

       5
       5
       +
       +++ b/Cargo.lock

     

       6
       6
       +
       @@ -0,0 +1,67 @@

     

       7
       7
       +
       +# This file is automatically @generated by Cargo.

     

       8
       8
       +
       +# It is not intended for manual editing.

     

       9
       9
       +
       +version = 3

     

       10
       10
       +
       +

     

       11
       11
       +
       +[[package]]

     

       12
       12
       +
       +name = "arbitrary"

     

       13
       13
       +
       +version = "1.0.1"

     

       14
       14
       +
       +source = "registry+https://github.com/rust-lang/crates.io-index"

     

       15
       15
       +
       +checksum = "237430fd6ed3740afe94eefcc278ae21e050285be882804e0d6e8695f0c94691"

     

       16
       16
       +
       +

     

       17
       17
       +
       +[[package]]

     

       18
       18
       +
       +name = "cc"

     

       19
       19
       +
       +version = "1.0.69"

     

       20
       20
       +
       +source = "registry+https://github.com/rust-lang/crates.io-index"

     

       21
       21
       +
       +checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"

     

       22
       22
       +
       +

     

       23
       23
       +
       +[[package]]

     

       24
       24
       +
       +name = "compiler_builtins"

     

       25
       25
       +
       +version = "0.1.49"

     

       26
       26
       +
       +source = "registry+https://github.com/rust-lang/crates.io-index"

     

       27
       27
       +
       +checksum = "20b1438ef42c655665a8ab2c1c6d605a305f031d38d9be689ddfef41a20f3aa2"

     

       28
       28
       +
       +

     

       29
       29
       +
       +[[package]]

     

       30
       30
       +
       +name = "libfuzzer-sys"

     

       31
       31
       +
       +version = "0.4.2"

     

       32
       32
       +
       +source = "registry+https://github.com/rust-lang/crates.io-index"

     

       33
       33
       +
       +checksum = "36a9a84a6e8b55dfefb04235e55edb2b9a2a18488fcae777a6bdaa6f06f1deb3"

     

       34
       34
       +
       +dependencies = [

     

       35
       35
       +
       + "arbitrary",

     

       36
       36
       +
       + "cc",

     

       37
       37
       +
       + "once_cell",

     

       38
       38
       +
       +]

     

       39
       39
       +
       +

     

       40
       40
       +
       +[[package]]

     

       41
       41
       +
       +name = "once_cell"

     

       42
       42
       +
       +version = "1.8.0"

     

       43
       43
       +
       +source = "registry+https://github.com/rust-lang/crates.io-index"

     

       44
       44
       +
       +checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"

     

       45
       45
       +
       +

     

       46
       46
       +
       +[[package]]

     

       47
       47
       +
       +name = "rustc-demangle"

     

       48
       48
       +
       +version = "0.1.20"

     

       49
       49
       +
       +dependencies = [

     

       50
       50
       +
       + "compiler_builtins",

     

       51
       51
       +
       + "rustc-std-workspace-core",

     

       52
       52
       +
       +]

     

       53
       53
       +
       +

     

       54
       54
       +
       +[[package]]

     

       55
       55
       +
       +name = "rustc-demangle-capi"

     

       56
       56
       +
       +version = "0.1.0"

     

       57
       57
       +
       +dependencies = [

     

       58
       58
       +
       + "rustc-demangle",

     

       59
       59
       +
       +]

     

       60
       60
       +
       +

     

       61
       61
       +
       +[[package]]

     

       62
       62
       +
       +name = "rustc-demangle-fuzz"

     

       63
       63
       +
       +version = "0.0.0"

     

       64
       64
       +
       +dependencies = [

     

       65
       65
       +
       + "libfuzzer-sys",

     

       66
       66
       +
       + "rustc-demangle",

     

       67
       67
       +
       +]

     

       68
       68
       +
       +

     

       69
       69
       +
       +[[package]]

     

       70
       70
       +
       +name = "rustc-std-workspace-core"

     

       71
       71
       +
       +version = "1.0.0"

     

       72
       72
       +
       +source = "registry+https://github.com/rust-lang/crates.io-index"

     

       73
       73
       +
       +checksum = "1956f5517128a2b6f23ab2dadf1a976f4f5b27962e7724c2bf3d45e539ec098c"

+34

pkgs/development/libraries/rustc-demangle/default.nix

···

       1
       1
       +
       { rustPlatform, fetchFromGitHub, rust, lib, stdenv }:

     

       2
       2
       +
       

     

       3
       3
       +
       rustPlatform.buildRustPackage rec {

     

       4
       4
       +
         pname = "rustc-demangle";

     

       5
       5
       +
         version = "0.1.20";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "alexcrichton";

     

       9
       9
       +
           repo = pname;

     

       10
       10
       +
           rev = version;

     

       11
       11
       +
           sha256 = "sha256-elxclyuLmr3N66s+pR4/6OU98k1oXI2wKVJtzWPY8FI=";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         cargoPatches = [

     

       15
       15
       +
           # generated using `cargo generate-lockfile` since repo is missing lockfile

     

       16
       16
       +
           ./add-Cargo.lock.patch

     

       17
       17
       +
         ];

     

       18
       18
       +
         cargoSha256 = "sha256-1tW5TOap5MstxTXAFij3IB8TIpI+FryEX9TXlVXjRl4=";

     

       19
       19
       +
         cargoBuildFlags = "-p rustc-demangle-capi";

     

       20
       20
       +
         postInstall = ''

     

       21
       21
       +
           mkdir -p $out/lib

     

       22
       22
       +
           cp target/${rust.toRustTargetSpec stdenv.hostPlatform}/release/librustc_demangle.so $out/lib

     

       23
       23
       +
           cp -R crates/capi/include $out

     

       24
       24
       +
         '';

     

       25
       25
       +
       

     

       26
       26
       +
         meta = with lib; {

     

       27
       27
       +
           description = "Rust symbol demangling";

     

       28
       28
       +
           homepage = "https://github.com/alexcrichton/rustc-demangle";

     

       29
       29
       +
           license = with licenses; [ asl20 mit ];

     

       30
       30
       +
           # upstream supports other platforms, but maintainer can only test on linux

     

       31
       31
       +
           platforms = platforms.linux;

     

       32
       32
       +
           maintainers = with maintainers; [ _1000teslas ];

     

       33
       33
       +
         };

     

       34
       34
       +
       }

+6 -1

pkgs/development/python-modules/buildbot/default.nix

···

       8
       8
        
       

     

       9
       9
        
       let

     

       10
       10
        
         withPlugins = plugins: buildPythonPackage {

     

       11
       11
       -
           name = "${package.name}-with-plugins";

     

       11
       11
       +
           pname = "${package.pname}-with-plugins";

     

       12
       12
       +
           inherit (package) version;

     

       13
       13
       +
       

     

       12
       14
        
           dontUnpack = true;

     

       15
       15
       +
           dontBuild = true;

     

       16
       16
       +
           doCheck = false;

     

       17
       17
       +
       

     

       13
       18
        
           nativeBuildInputs = [ makeWrapper ];

     

       14
       19
        
           propagatedBuildInputs = plugins ++ package.propagatedBuildInputs;

     

       15
       20

+29

pkgs/development/python-modules/protonup/default.nix

···

       1
       1
       +
       { lib, buildPythonPackage, pythonOlder, fetchPypi, requests, configparser }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildPythonPackage rec {

     

       4
       4
       +
         pname = "protonup";

     

       5
       5
       +
         version = "0.1.4";

     

       6
       6
       +
         disabled = pythonOlder "3.6";

     

       7
       7
       +
       

     

       8
       8
       +
         src = fetchPypi {

     

       9
       9
       +
           inherit pname version;

     

       10
       10
       +
           sha256 = "0z5q0s9h51w2bqm9lkafml14g13v2dgm4nm9x06v7nxqc9msmyyy";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         postPatch = ''

     

       14
       14
       +
           substituteInPlace setup.cfg \

     

       15
       15
       +
             --replace "argparse" ""

     

       16
       16
       +
         '';

     

       17
       17
       +
       

     

       18
       18
       +
         propagatedBuildInputs = [ requests configparser ];

     

       19
       19
       +
       

     

       20
       20
       +
         doCheck = false; # protonup does not have any tests

     

       21
       21
       +
         pythonImportsCheck = [ "protonup" ];

     

       22
       22
       +
       

     

       23
       23
       +
         meta = with lib; {

     

       24
       24
       +
           homepage = "https://github.com/AUNaseef/protonup";

     

       25
       25
       +
           description = "CLI program and API to automate the installation and update of GloriousEggroll's Proton-GE";

     

       26
       26
       +
           license = licenses.gpl3Only;

     

       27
       27
       +
           maintainers = with maintainers; [ flexagoon ];

     

       28
       28
       +
         };

     

       29
       29
       +
       }

+34 -19

pkgs/development/tools/analysis/hotspot/default.nix

···

       1
       1
       -
       { lib,

     

       2
       2
       -
         mkDerivation,

     

       3
       3
       -
         cmake,

     

       4
       4
       -
         elfutils,

     

       5
       5
       -
         extra-cmake-modules,

     

       6
       6
       -
         fetchFromGitHub,

     

       7
       7
       -
         kconfigwidgets,

     

       8
       8
       -
         ki18n,

     

       9
       9
       -
         kio,

     

       10
       10
       -
         kitemmodels,

     

       11
       11
       -
         kitemviews,

     

       12
       12
       -
         kwindowsystem,

     

       13
       13
       -
         libelf,

     

       14
       14
       -
         qtbase,

     

       15
       15
       -
         threadweaver,

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , mkDerivation

     

       3
       3
       +
       , cmake

     

       4
       4
       +
       , elfutils

     

       5
       5
       +
       , extra-cmake-modules

     

       6
       6
       +
       , fetchFromGitHub

     

       7
       7
       +
       , kconfigwidgets

     

       8
       8
       +
       , ki18n

     

       9
       9
       +
       , kio

     

       10
       10
       +
       , kitemmodels

     

       11
       11
       +
       , kitemviews

     

       12
       12
       +
       , kwindowsystem

     

       13
       13
       +
       , libelf

     

       14
       14
       +
       , qtbase

     

       15
       15
       +
       , threadweaver

     

       16
       16
       +
       , qtx11extras

     

       17
       17
       +
       , zstd

     

       18
       18
       +
       , kddockwidgets

     

       19
       19
       +
       , rustc-demangle

     

       16
       20
        
       }:

     

       17
       21
        
       

     

       18
       22
        
       mkDerivation rec {

     
···

       27
       31
        
           fetchSubmodules = true;

     

       28
       32
        
         };

     

       29
       33
        
       

     

       30
       30
       -
         nativeBuildInputs = [ cmake ];

     

       34
       34
       +
         nativeBuildInputs = [

     

       35
       35
       +
           cmake

     

       36
       36
       +
           extra-cmake-modules

     

       37
       37
       +
         ];

     

       31
       38
        
         buildInputs = [

     

       32
       39
        
           elfutils

     

       33
       33
       -
           extra-cmake-modules

     

       34
       40
        
           kconfigwidgets

     

       35
       41
        
           ki18n

     

       36
       42
        
           kio

     
···

       40
       46
        
           libelf

     

       41
       47
        
           qtbase

     

       42
       48
        
           threadweaver

     

       49
       49
       +
           qtx11extras

     

       50
       50
       +
           zstd

     

       51
       51
       +
           kddockwidgets

     

       52
       52
       +
           rustc-demangle

     

       43
       53
        
         ];

     

       44
       54
        
       

     

       45
       55
        
         # hotspot checks for the presence of third party libraries'

     
···

       47
       57
        
         # submodules; but Nix clones them and removes .git (for reproducibility).

     

       48
       58
        
         # So we need to fake their existence here.

     

       49
       59
        
         postPatch = ''

     

       50
       50
       -
           mkdir -p 3rdparty/perfparser/.git

     

       60
       60
       +
           mkdir -p 3rdparty/{perfparser,PrefixTickLabels}/.git

     

       51
       61
        
         '';

     

       52
       62
        
       

     

       63
       63
       +
         cmakeFlags = [

     

       64
       64
       +
           "-DRUSTC_DEMANGLE_INCLUDE_DIR=${rustc-demangle}/include"

     

       65
       65
       +
           "-DRUSTC_DEMANGLE_LIBRARY=${rustc-demangle}/lib/librustc_demangle.so"

     

       66
       66
       +
         ];

     

       67
       67
       +
       

     

       53
       68
        
         meta = {

     

       54
       69
        
           description = "A GUI for Linux perf";

     

       55
       70
        
           longDescription = ''

     
···

       58
       73
        
             then displays the result in a graphical way.

     

       59
       74
        
           '';

     

       60
       75
        
           homepage = "https://github.com/KDAB/hotspot";

     

       61
       61
       -
           license = with lib.licenses; [ gpl2 gpl3 ];

     

       76
       76
       +
           license = with lib.licenses; [ gpl2Only gpl3Only ];

     

       62
       77
        
           platforms = lib.platforms.linux;

     

       63
       78
        
           maintainers = with lib.maintainers; [ nh2 ];

     

       64
       79
        
         };

+2 -2

pkgs/development/tools/build-managers/bear/default.nix

···

       18
       18
        
       

     

       19
       19
        
       stdenv.mkDerivation rec {

     

       20
       20
        
         pname = "bear";

     

       21
       21
       -
         version = "3.0.13";

     

       21
       21
       +
         version = "3.0.14";

     

       22
       22
        
       

     

       23
       23
        
         src = fetchFromGitHub {

     

       24
       24
        
           owner = "rizsotto";

     

       25
       25
        
           repo = pname;

     

       26
       26
        
           rev = version;

     

       27
       27
       -
           sha256 = "sha256-oMrTH3GjxiLBKX0i3ZuV+bNqpA7PkoAQAb/08Q/uELs=";

     

       27
       27
       +
           sha256 = "0qy96dyd29bjvfhi46y30hli5cvshw8am0spvcv9v43660wbczd7";

     

       28
       28
        
         };

     

       29
       29
        
       

     

       30
       30
        
         nativeBuildInputs = [ cmake pkg-config ];

+1 -1

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

···

       1
       1
       -
       { lib, supportedGhcVersions ? [ "884" "8106" ], stdenv, haskellPackages

     

       1
       1
       +
       { lib, supportedGhcVersions ? [ "884" "8107" ], stdenv, haskellPackages

     

       2
       2
        
       , haskell }:

     

       3
       3
        
       #

     

       4
       4
        
       # The recommended way to override this package is

+3 -3

pkgs/development/tools/inferno/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "inferno";

     

       5
       5
       -
         version = "0.10.6";

     

       5
       5
       +
         version = "0.10.7";

     

       6
       6
        
       

     

       7
       7
        
         # github version doesn't have a Cargo.lock

     

       8
       8
        
         src = fetchCrate {

     

       9
       9
        
           inherit pname version;

     

       10
       10
       -
           sha256 = "1pn3ask36mv8byd62xhm8bjv59k12i1s533jgb5syml64w1cnn12";

     

       10
       10
       +
           sha256 = "0bzrwa87j56sv03frl0lp6izfxsldn0692g2vpwfndhrsm0gy8z9";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
       -
         cargoSha256 = "0w5w9pyv34x0iy9knr79491kb9bgbcagh6251pq72mv4pvx0axip";

     

       13
       13
       +
         cargoSha256 = "1dvk1y1afqlmmqqdm91lg2wvny5q47yfjvmjzaryk2ic1s6g17b1";

     

       14
       14
        
       

     

       15
       15
        
         # these tests depend on a patched version of flamegraph which is included in

     

       16
       16
        
         # the github repository as a submodule, but absent from the crates version

+4 -3

pkgs/os-specific/linux/ddcci/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "ddcci-driver";

     

       5
       5
       -
         version = "0.3.3";

     

       5
       5
       +
         version = "0.4.1";

     

       6
       6
        
         name = "${pname}-${kernel.version}-${version}";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitLab {

     

       9
       9
        
           owner = "${pname}-linux";

     

       10
       10
        
           repo = "${pname}-linux";

     

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

     

       12
       12
       -
           sha256 = "0vkkja3ykjil783zjpwp0vz7jy2fp9ccazzi3afd4fjk8gldin7f";

     

       12
       12
       +
           sha256 = "1qhsm0ccwfmwn0r6sbc6ms4lf4a3iqfcgqmbs6afr6hhxkqll3fg";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         hardeningDisable = [ "pic" ];

     
···

       35
       35
        
         meta = with lib; {

     

       36
       36
        
           description = "Kernel module driver for DDC/CI monitors";

     

       37
       37
        
           homepage = "https://gitlab.com/ddcci-driver-linux/ddcci-driver-linux";

     

       38
       38
       -
           license = licenses.gpl2;

     

       38
       38
       +
           license = licenses.gpl2Plus;

     

       39
       39
        
           maintainers = with maintainers; [ bricewge ];

     

       40
       40
        
           platforms = platforms.linux;

     

       41
       41
       +
           broken = kernel.kernelOlder "5.1";

     

       41
       42
        
         };

     

       42
       43
        
       }

+2 -2

pkgs/os-specific/linux/kernel/linux-4.14.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       buildLinux (args // rec {

     

       6
       6
       -
         version = "4.14.245";

     

       6
       6
       +
         version = "4.14.246";

     

       7
       7
        
       

     

       8
       8
        
         # modDirVersion needs to be x.y.z, will automatically add .0 if needed

     

       9
       9
        
         modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;

     
···

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";

     

       16
       16
       -
           sha256 = "085jls7b2rzxlmvp0zsp4l3wi5xdrqlv2qczzwvbhzna1f4n2x0d";

     

       16
       16
       +
           sha256 = "0fpgig84shpas1jc0h4s3aw9brkcq1as84gjbk4bfhc48bpi4mlw";

     

       17
       17
        
         };

     

       18
       18
        
       } // (args.argsOverride or {}))

+2 -2

pkgs/os-specific/linux/kernel/linux-4.19.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       buildLinux (args // rec {

     

       6
       6
       -
         version = "4.19.205";

     

       6
       6
       +
         version = "4.19.206";

     

       7
       7
        
       

     

       8
       8
        
         # modDirVersion needs to be x.y.z, will automatically add .0 if needed

     

       9
       9
        
         modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;

     
···

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";

     

       16
       16
       -
           sha256 = "1ii9l44d6jxhyd5qkc5h83ixailma9v7hyl60wi3rskkafqnwv2m";

     

       16
       16
       +
           sha256 = "1h44lvzxd0cngj71bk8qba9dz7jlqj68ir6xjwfafglb81ppgsxp";

     

       17
       17
        
         };

     

       18
       18
        
       } // (args.argsOverride or {}))

+2 -2

pkgs/os-specific/linux/kernel/linux-4.4.nix

···

       1
       1
        
       { buildPackages, fetchurl, perl, buildLinux, nixosTests, stdenv, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       buildLinux (args // rec {

     

       4
       4
       -
         version = "4.4.282";

     

       4
       4
       +
         version = "4.4.283";

     

       5
       5
        
         extraMeta.branch = "4.4";

     

       6
       6
        
         extraMeta.broken = stdenv.isAarch64;

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";

     

       10
       10
       -
           sha256 = "1rgxznjb6gsi64wk7x2rylyi64y2nx5yiah5gfm40c6l2f7lb9cc";

     

       10
       10
       +
           sha256 = "1d9v4h4cbc4i371lhhwpxbmg88gna6xyi2ahfvv0clz60802y982";

     

       11
       11
        
         };

     

       12
       12
        
       } // (args.argsOverride or {}))

+2 -2

pkgs/os-specific/linux/kernel/linux-4.9.nix

···

       1
       1
        
       { buildPackages, fetchurl, perl, buildLinux, nixosTests, stdenv, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       buildLinux (args // rec {

     

       4
       4
       -
         version = "4.9.281";

     

       4
       4
       +
         version = "4.9.282";

     

       5
       5
        
         extraMeta.branch = "4.9";

     

       6
       6
        
         extraMeta.broken = stdenv.isAarch64;

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";

     

       10
       10
       -
           sha256 = "1dg70jv3bqanmjs31s0x2p7nd5g37bqzjn9rc1y6wvkgm4pwahi6";

     

       10
       10
       +
           sha256 = "059fin4si93ya13xy831w84q496ksxidpd3kyw38918sfy4p6wk7";

     

       11
       11
        
         };

     

       12
       12
        
       } // (args.argsOverride or {}))

+2 -2

pkgs/os-specific/linux/kernel/linux-5.10.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       buildLinux (args // rec {

     

       6
       6
       -
         version = "5.10.61";

     

       6
       6
       +
         version = "5.10.62";

     

       7
       7
        
       

     

       8
       8
        
         # modDirVersion needs to be x.y.z, will automatically add .0 if needed

     

       9
       9
        
         modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;

     
···

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";

     

       16
       16
       -
           sha256 = "1lci78584c0rg5m5rkylssppnv001pzh4769m9mds4fdqn6f7sl2";

     

       16
       16
       +
           sha256 = "1cc6z2xzi1s69805jk4f91iarx19v0yyqvssx1f1mc0l9l1db389";

     

       17
       17
        
         };

     

       18
       18
        
       } // (args.argsOverride or {}))

+2 -2

pkgs/os-specific/linux/kernel/linux-5.13.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       buildLinux (args // rec {

     

       6
       6
       -
         version = "5.13.13";

     

       6
       6
       +
         version = "5.13.14";

     

       7
       7
        
       

     

       8
       8
        
         # modDirVersion needs to be x.y.z, will automatically add .0 if needed

     

       9
       9
        
         modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;

     
···

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";

     

       16
       16
       -
           sha256 = "0d1lr3rivgf9j3bn2a9hpzdf74nq8kybf3rfxxvw68vr1hhd4cam";

     

       16
       16
       +
           sha256 = "06lbjsbr86qa8yai5gfclbfxvcqsw33kxj9b4r93hh6z1wajmx82";

     

       17
       17
        
         };

     

       18
       18
        
       } // (args.argsOverride or { }))

+2 -2

pkgs/os-specific/linux/kernel/linux-5.14.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       buildLinux (args // rec {

     

       6
       6
       -
         version = "5.14";

     

       6
       6
       +
         version = "5.14.1";

     

       7
       7
        
       

     

       8
       8
        
         # modDirVersion needs to be x.y.z, will automatically add .0 if needed

     

       9
       9
        
         modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;

     
···

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";

     

       16
       16
       -
           sha256 = "1cki6af9r30k8820j73qdyycp23mwpf2a2rjwl82p9i61mg8n1ky";

     

       16
       16
       +
           sha256 = "1iq8s031fviccc4710biwl7gxqdimm3nhlvxd0m3fykvhhmcanq0";

     

       17
       17
        
         };

     

       18
       18
        
       } // (args.argsOverride or { }))

+2 -2

pkgs/os-specific/linux/kernel/linux-5.4.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       buildLinux (args // rec {

     

       6
       6
       -
         version = "5.4.143";

     

       6
       6
       +
         version = "5.4.144";

     

       7
       7
        
       

     

       8
       8
        
         # modDirVersion needs to be x.y.z, will automatically add .0 if needed

     

       9
       9
        
         modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;

     
···

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";

     

       16
       16
       -
           sha256 = "090x087p8hxnc1daf2xwj7vg8hg1jhz5i4andkbhdy550l5nalq9";

     

       16
       16
       +
           sha256 = "11aqp12xwbg7ysac3f9iaxwkhvasdg9bw4r43jj8af5bf61bjhxw";

     

       17
       17
        
         };

     

       18
       18
        
       } // (args.argsOverride or {}))

+2 -2

pkgs/os-specific/linux/kernel/linux-libre.nix

···

       1
       1
        
       { stdenv, lib, fetchsvn, linux

     

       2
       2
        
       , scripts ? fetchsvn {

     

       3
       3
        
           url = "https://www.fsfla.org/svn/fsfla/software/linux-libre/releases/branches/";

     

       4
       4
       -
           rev = "18268";

     

       5
       5
       -
           sha256 = "050rk485csj41yfydr1cvn60vhb3lzbb3486sm832vp55d34i8fd";

     

       4
       4
       +
           rev = "18298";

     

       5
       5
       +
           sha256 = "027fp6h7295cc9m5g46phqd6hixcnvihpfsyrnzvsxz6pkvjzpw4";

     

       6
       6
        
         }

     

       7
       7
        
       , ...

     

       8
       8
        
       }:

+3 -3

pkgs/os-specific/linux/kernel/linux-rt-5.4.nix

···

       6
       6
        
       , ... } @ args:

     

       7
       7
        
       

     

       8
       8
        
       let

     

       9
       9
       -
         version = "5.4.138-rt62"; # updated by ./update-rt.sh

     

       9
       9
       +
         version = "5.4.143-rt63"; # updated by ./update-rt.sh

     

       10
       10
        
         branch = lib.versions.majorMinor version;

     

       11
       11
        
         kversion = builtins.elemAt (lib.splitString "-" version) 0;

     

       12
       12
        
       in buildLinux (args // {

     
···

       14
       14
        
       

     

       15
       15
        
         src = fetchurl {

     

       16
       16
        
           url = "mirror://kernel/linux/kernel/v5.x/linux-${kversion}.tar.xz";

     

       17
       17
       -
           sha256 = "0mw6k9zrcmv1j4b3han5c0q8xbh38bka2wkkbl1y3ralg9r5ffd4";

     

       17
       17
       +
           sha256 = "090x087p8hxnc1daf2xwj7vg8hg1jhz5i4andkbhdy550l5nalq9";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         kernelPatches = let rt-patch = {

     

       21
       21
        
           name = "rt";

     

       22
       22
        
           patch = fetchurl {

     

       23
       23
        
             url = "mirror://kernel/linux/kernel/projects/rt/${branch}/older/patch-${version}.patch.xz";

     

       24
       24
       -
             sha256 = "1zw7806fxx9cai9n6siv534x5r52d8fc13r07ypgw461pijcy5p6";

     

       24
       24
       +
             sha256 = "13d9sx6vw3hlh0cpccfsfqkjj6yfjmbh4wp4x6ry84i39lrfbwg3";

     

       25
       25
        
           };

     

       26
       26
        
         }; in [ rt-patch ] ++ kernelPatches;

     

       27
       27

pkgs/os-specific/linux/kexectools/default.nix pkgs/os-specific/linux/kexec-tools/default.nix

+3 -3

pkgs/os-specific/linux/systemd/default.nix

···

       52
       52
        
       , libselinux

     

       53
       53
        
       , withLibseccomp ? lib.meta.availableOn stdenv.hostPlatform libseccomp

     

       54
       54
        
       , libseccomp

     

       55
       55
       -
       , withKexectools ? lib.meta.availableOn stdenv.hostPlatform kexectools

     

       56
       56
       -
       , kexectools

     

       55
       55
       +
       , withKexectools ? lib.meta.availableOn stdenv.hostPlatform kexec-tools

     

       56
       56
       +
       , kexec-tools

     

       57
       57
        
       , bashInteractive

     

       58
       58
        
       , libmicrohttpd

     

       59
       59
        
       

     
···

       302
       302
        
         ++ lib.optionals withCompression [ bzip2 lz4 xz ]

     

       303
       303
        
         ++ lib.optional withCryptsetup (lib.getDev cryptsetup.dev)

     

       304
       304
        
         ++ lib.optional withEfi gnu-efi

     

       305
       305
       -
         ++ lib.optional withKexectools kexectools

     

       305
       305
       +
         ++ lib.optional withKexectools kexec-tools

     

       306
       306
        
         ++ lib.optional withLibseccomp libseccomp

     

       307
       307
        
         ++ lib.optional withNetworkd iptables

     

       308
       308
        
         ++ lib.optional withPCRE2 pcre2

+3 -3

pkgs/tools/networking/corerad/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "corerad";

     

       5
       5
       -
         version = "0.3.3";

     

       5
       5
       +
         version = "0.3.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "mdlayher";

     

       9
       9
        
           repo = "corerad";

     

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

     

       11
       11
       -
           sha256 = "1xfqjxygf6r5wbf3brilx4d4hm0h518zaadmmzvkmbbz6w0fyl0k";

     

       11
       11
       +
           sha256 = "0sf2r4q57hwdakv0b4skn76b0xy7bwj2j9rpj6frs5fkk6gsi6sm";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "0ydyfdx9syrv719knwv64srfx4d1m9pzkivfc3q188bx5qx67pjw";

     

       14
       14
       +
         vendorSha256 = "123f9y1pfayfd5amkw5b8jzi8dbn7a16kbf7lzbmw69c1gj4gx9z";

     

       15
       15
        
       

     

       16
       16
        
         doCheck = false;

     

       17
       17

pkgs/top-level/aliases.nix

···

       387
       387
        
         keepassx-community = keepassxc; # added 2017-11

     

       388
       388
        
         keepassx-reboot = keepassx-community; # added 2017-02-01

     

       389
       389
        
         keepassx2-http = keepassx-reboot; # added 2016-10-17

     

       390
       390
       +
         kexectools = kexec-tools; # added 2021-09-03

     

       390
       391
        
         keybase-go = keybase;  # added 2016-08-24

     

       391
       392
        
         kinetic-cpp-client = throw "kinetic-cpp-client has been removed from nixpkgs, as it's abandoned."; # 2020-04-28

     

       392
       393
        
         kicad-with-packages3d = kicad; # added 2019-11-25

+11 -5

pkgs/top-level/all-packages.nix

···

       1029
       1029
        
         };

     

       1030
       1030
        
         termite-unwrapped = callPackage ../applications/terminal-emulators/termite { };

     

       1031
       1031
        
       

     

       1032
       1032
       -
         termonad-with-packages = callPackage ../applications/terminal-emulators/termonad {

     

       1033
       1033
       -
           inherit (haskellPackages) ghcWithPackages;

     

       1034
       1034
       -
         };

     

       1032
       1032
       +
         termonad-with-packages = callPackage ../applications/terminal-emulators/termonad { };

     

       1033
       1033
       +
       

     

       1034
       1034
       +
         termonad = termonad-with-packages;

     

       1035
       1035
        
       

     

       1036
       1036
        
         termsyn = callPackage ../data/fonts/termsyn { };

     

       1037
       1037
        
       

     
···

       6352
       6352
        
       

     

       6353
       6353
        
         keeperrl = callPackage ../games/keeperrl { };

     

       6354
       6354
        
       

     

       6355
       6355
       -
         kexectools = callPackage ../os-specific/linux/kexectools { };

     

       6355
       6355
       +
         kexec-tools = callPackage ../os-specific/linux/kexec-tools { };

     

       6356
       6356
        
       

     

       6357
       6357
        
         keepkey_agent = with python3Packages; toPythonApplication keepkey_agent;

     

       6358
       6358
        
       

     
···

       11480
       11480
        
       

     

       11481
       11481
        
         # Please update doc/languages-frameworks/haskell.section.md, “Our

     

       11482
       11482
        
         # current default compiler is”, if you bump this:

     

       11483
       11483
       -
         haskellPackages = dontRecurseIntoAttrs haskell.packages.ghc8106;

     

       11483
       11483
       +
         haskellPackages = dontRecurseIntoAttrs haskell.packages.ghc8107;

     

       11484
       11484
        
       

     

       11485
       11485
        
         inherit (haskellPackages) ghc;

     

       11486
       11486
        
       

     
···

       16336
       16336
        
       

     

       16337
       16337
        
         judy = callPackage ../development/libraries/judy { };

     

       16338
       16338
        
       

     

       16339
       16339
       +
         kddockwidgets = libsForQt5.callPackage ../development/libraries/kddockwidgets { };

     

       16340
       16340
       +
       

     

       16339
       16341
        
         keybinder = callPackage ../development/libraries/keybinder {

     

       16340
       16342
        
           automake = automake111x;

     

       16341
       16343
        
           lua = lua5_1;

     
···

       18560
       18562
        
         rttr = callPackage ../development/libraries/rttr { };

     

       18561
       18563
        
       

     

       18562
       18564
        
         rubberband = callPackage ../development/libraries/rubberband { };

     

       18565
       18565
       +
       

     

       18566
       18566
       +
         rustc-demangle = callPackage ../development/libraries/rustc-demangle { };

     

       18563
       18567
        
       

     

       18564
       18568
        
         s2geometry = callPackage ../development/libraries/s2geometry { };

     

       18565
       18569
        
       

     
···

       29468
       29472
        
           inherit winetricks;

     

       29469
       29473
        
           inherit (gnome) zenity;

     

       29470
       29474
        
         };

     

       29475
       29475
       +
       

     

       29476
       29476
       +
         protonup = with python3Packages; toPythonApplication protonup;

     

       29471
       29477
        
       

     

       29472
       29478
        
         sdlpop = callPackage ../games/sdlpop { };

     

       29473
       29479

+40 -17

pkgs/top-level/haskell-packages.nix

···

       6
       6
        
           "ghc865Binary"

     

       7
       7
        
           "ghc8102Binary"

     

       8
       8
        
           "ghc8102BinaryMinimal"

     

       9
       9
       -
           "ghc8105Binary"

     

       10
       10
       -
           "ghc8105BinaryMinimal"

     

       9
       9
       +
           "ghc8107Binary"

     

       10
       10
       +
           "ghc8107BinaryMinimal"

     

       11
       11
        
           "integer-simple"

     

       12
       12
        
           "native-bignum"

     

       13
       13
        
           "ghcHEAD"

     
···

       59
       59
        
             minimal = true;

     

       60
       60
        
           };

     

       61
       61
        
       

     

       62
       62
       -
           ghc8105Binary = callPackage ../development/compilers/ghc/8.10.5-binary.nix {

     

       62
       62
       +
           ghc8107Binary = callPackage ../development/compilers/ghc/8.10.7-binary.nix {

     

       63
       63
        
             llvmPackages = pkgs.llvmPackages_11;

     

       64
       64
        
           };

     

       65
       65
        
       

     

       66
       66
       -
           ghc8105BinaryMinimal = callPackage ../development/compilers/ghc/8.10.5-binary.nix {

     

       66
       66
       +
           ghc8107BinaryMinimal = callPackage ../development/compilers/ghc/8.10.7-binary.nix {

     

       67
       67
        
             llvmPackages = pkgs.llvmPackages_11;

     

       68
       68
        
             minimal = true;

     

       69
       69
        
           };

     
···

       71
       71
        
           ghc884 = callPackage ../development/compilers/ghc/8.8.4.nix {

     

       72
       72
        
             # the oldest ghc with aarch64-darwin support is 8.10.5

     

       73
       73
        
             bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then

     

       74
       74
       -
                 packages.ghc8105BinaryMinimal

     

       74
       74
       +
                 packages.ghc8107BinaryMinimal

     

       75
       75
        
               # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar

     

       76
       76
        
               # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them

     

       77
       77
        
               else if stdenv.isAarch64 || stdenv.targetPlatform.isMusl then

     
···

       82
       82
        
             buildLlvmPackages = buildPackages.llvmPackages_7;

     

       83
       83
        
             llvmPackages = pkgs.llvmPackages_7;

     

       84
       84
        
           };

     

       85
       85
       -
           ghc8106 = callPackage ../development/compilers/ghc/8.10.6.nix {

     

       85
       85
       +
           ghc8107 = callPackage ../development/compilers/ghc/8.10.7.nix {

     

       86
       86
        
             # the oldest ghc with aarch64-darwin support is 8.10.5

     

       87
       87
        
             bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then

     

       88
       88
       -
                 packages.ghc8105BinaryMinimal

     

       88
       88
       +
                 packages.ghc8107BinaryMinimal

     

       89
       89
        
               # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar

     

       90
       90
        
               # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them

     

       91
       91
        
               else if stdenv.isAarch64 || stdenv.isAarch32 || stdenv.targetPlatform.isMusl then

     
···

       103
       103
        
           ghc901 = callPackage ../development/compilers/ghc/9.0.1.nix {

     

       104
       104
        
             # the oldest ghc with aarch64-darwin support is 8.10.5

     

       105
       105
        
             bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then

     

       106
       106
       -
                 packages.ghc8105BinaryMinimal

     

       106
       106
       +
                 packages.ghc8107BinaryMinimal

     

       107
       107
        
               # aarch64 ghc8102Binary exceeds max output size on hydra

     

       108
       108
        
               else if stdenv.isAarch64 || stdenv.isAarch32 then

     

       109
       109
        
                 packages.ghc8102BinaryMinimal

     
···

       113
       113
        
             buildLlvmPackages = buildPackages.llvmPackages_10;

     

       114
       114
        
             llvmPackages = pkgs.llvmPackages_10;

     

       115
       115
        
           };

     

       116
       116
       +
           ghc921 = callPackage ../development/compilers/ghc/9.2.1.nix {

     

       117
       117
       +
             # aarch64 ghc8102Binary exceeds max output size on hydra

     

       118
       118
       +
             bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 then

     

       119
       119
       +
                 packages.ghc8102BinaryMinimal

     

       120
       120
       +
               else

     

       121
       121
       +
                 packages.ghc8102Binary;

     

       122
       122
       +
             inherit (buildPackages.python3Packages) sphinx;

     

       123
       123
       +
             # Need to use apple's patched xattr until

     

       124
       124
       +
             # https://github.com/xattr/xattr/issues/44 and

     

       125
       125
       +
             # https://github.com/xattr/xattr/issues/55 are solved.

     

       126
       126
       +
             inherit (buildPackages.darwin) xattr;

     

       127
       127
       +
             buildLlvmPackages = buildPackages.llvmPackages_10;

     

       128
       128
       +
             llvmPackages = pkgs.llvmPackages_10;

     

       129
       129
       +
           };

     

       116
       130
        
           ghcHEAD = callPackage ../development/compilers/ghc/head.nix {

     

       117
       131
        
             bootPkgs = packages.ghc901; # no binary yet

     

       118
       132
        
             inherit (buildPackages.python3Packages) sphinx;

     

       133
       133
       +
             # Need to use apple's patched xattr until

     

       134
       134
       +
             # https://github.com/xattr/xattr/issues/44 and

     

       135
       135
       +
             # https://github.com/xattr/xattr/issues/55 are solved.

     

       136
       136
       +
             inherit (buildPackages.darwin) xattr;

     

       119
       137
        
             buildLlvmPackages = buildPackages.llvmPackages_10;

     

       120
       138
        
             llvmPackages = pkgs.llvmPackages_10;

     

       121
       139
        
             libffi = pkgs.libffi;

     
···

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

     

       167
       185
        
             packageSetConfig = bootstrapPackageSet;

     

       168
       186
        
           };

     

       169
       169
       -
           ghc8105Binary = callPackage ../development/haskell-modules {

     

       170
       170
       -
             buildHaskellPackages = bh.packages.ghc8105Binary;

     

       171
       171
       -
             ghc = bh.compiler.ghc8105Binary;

     

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

     

       188
       188
       +
             buildHaskellPackages = bh.packages.ghc8107Binary;

     

       189
       189
       +
             ghc = bh.compiler.ghc8107Binary;

     

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

     

       173
       191
        
             packageSetConfig = bootstrapPackageSet;

     

       174
       192
        
           };

     

       175
       175
       -
           ghc8105BinaryMinimal = callPackage ../development/haskell-modules {

     

       176
       176
       -
             buildHaskellPackages = bh.packages.ghc8105BinaryMinimal;

     

       177
       177
       -
             ghc = bh.compiler.ghc8105BinaryMinimal;

     

       193
       193
       +
           ghc8107BinaryMinimal = callPackage ../development/haskell-modules {

     

       194
       194
       +
             buildHaskellPackages = bh.packages.ghc8107BinaryMinimal;

     

       195
       195
       +
             ghc = bh.compiler.ghc8107BinaryMinimal;

     

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

     

       179
       197
        
             packageSetConfig = bootstrapPackageSet;

     

       180
       198
        
           };

     
···

       183
       201
        
             ghc = bh.compiler.ghc884;

     

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

     

       185
       203
        
           };

     

       186
       186
       -
           ghc8106 = callPackage ../development/haskell-modules {

     

       187
       187
       -
             buildHaskellPackages = bh.packages.ghc8106;

     

       188
       188
       -
             ghc = bh.compiler.ghc8106;

     

       204
       204
       +
           ghc8107 = callPackage ../development/haskell-modules {

     

       205
       205
       +
             buildHaskellPackages = bh.packages.ghc8107;

     

       206
       206
       +
             ghc = bh.compiler.ghc8107;

     

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

     

       190
       208
        
           };

     

       191
       209
        
           ghc901 = callPackage ../development/haskell-modules {

     

       192
       210
        
             buildHaskellPackages = bh.packages.ghc901;

     

       193
       211
        
             ghc = bh.compiler.ghc901;

     

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

     

       213
       213
       +
           };

     

       214
       214
       +
           ghc921 = callPackage ../development/haskell-modules {

     

       215
       215
       +
             buildHaskellPackages = bh.packages.ghc921;

     

       216
       216
       +
             ghc = bh.compiler.ghc921;

     

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

     

       195
       218
        
           };

     

       196
       219
        
           ghcHEAD = callPackage ../development/haskell-modules {

     

       197
       220
        
             buildHaskellPackages = bh.packages.ghcHEAD;

pkgs/top-level/python-packages.nix

···

       5696
       5696
        
       

     

       5697
       5697
        
         protobuf3-to-dict = callPackage ../development/python-modules/protobuf3-to-dict { };

     

       5698
       5698
        
       

     

       5699
       5699
       +
         protonup = callPackage ../development/python-modules/protonup { };

     

       5700
       5700
       +
       

     

       5699
       5701
        
         prov = callPackage ../development/python-modules/prov { };

     

       5700
       5702
        
       

     

       5701
       5703
        
         prox-tv = callPackage ../development/python-modules/prox-tv { };

+9 -9

pkgs/top-level/release-haskell.nix

···

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

     

       51
       51
        
         all = with compilerNames; [

     

       52
       52
        
           ghc884

     

       53
       53
       -
           ghc8106

     

       53
       53
       +
           ghc8107

     

       54
       54
        
           ghc901

     

       55
       55
        
         ];

     

       56
       56
        
       

     
···

       278
       278
        
             # Test some statically linked packages to catch regressions

     

       279
       279
        
             # and get some cache going for static compilation with GHC.

     

       280
       280
        
             # Use integer-simple to avoid GMP linking problems (LGPL)

     

       281
       281
       -
             pkgsStatic.haskell.packages.integer-simple.ghc8106 =

     

       281
       281
       +
             pkgsStatic.haskell.packages.integer-simple.ghc8107 =

     

       282
       282
        
               removePlatforms

     

       283
       283
        
                 [

     

       284
       284
        
                   "aarch64-linux" # times out on Hydra

     

       285
       285
        
                   "x86_64-darwin" # TODO: reenable when static libiconv works on darwin

     

       286
       286
        
                 ]

     

       287
       287
        
                 {

     

       288
       288
       -
                   inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.integer-simple.ghc8106)

     

       288
       288
       +
                   inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.integer-simple.ghc8107)

     

       289
       289
        
                     hello

     

       290
       290
        
                     lens

     

       291
       291
        
                     random

     
···

       300
       300
        
             # package sets (like Cabal, jailbreak-cabal) are

     

       301
       301
        
             # working as expected.

     

       302
       302
        
             cabal-install = all;

     

       303
       303
       -
             Cabal_3_6_0_0 = with compilerNames; [ ghc884 ghc8106 ];

     

       303
       303
       +
             Cabal_3_6_0_0 = with compilerNames; [ ghc884 ghc8107 ];

     

       304
       304
        
             cabal2nix-unstable = all;

     

       305
       305
        
             funcmp = all;

     

       306
       306
        
             # Doesn't currently work on ghc-9.0:

     

       307
       307
        
             # https://github.com/haskell/haskell-language-server/issues/297

     

       308
       308
       -
             haskell-language-server = with compilerNames; [ ghc884 ghc8106 ];

     

       308
       308
       +
             haskell-language-server = with compilerNames; [ ghc884 ghc8107 ];

     

       309
       309
        
             hoogle = all;

     

       310
       310
        
             hsdns = all;

     

       311
       311
        
             jailbreak-cabal = all;

     
···

       379
       379
        
               constituents = accumulateDerivations [

     

       380
       380
        
                 jobs.pkgsMusl.haskell.compiler.ghc8102Binary

     

       381
       381
        
                 jobs.pkgsMusl.haskell.compiler.ghc884

     

       382
       382
       -
                 jobs.pkgsMusl.haskell.compiler.ghc8106

     

       382
       382
       +
                 jobs.pkgsMusl.haskell.compiler.ghc8107

     

       383
       383
        
                 jobs.pkgsMusl.haskell.compiler.ghc901

     

       384
       384
        
               ];

     

       385
       385
        
             };

     
···

       394
       394
        
                 ];

     

       395
       395
        
               };

     

       396
       396
        
               constituents = accumulateDerivations [

     

       397
       397
       -
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8106.hello

     

       398
       398
       -
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8106.lens

     

       399
       399
       -
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8106.random

     

       397
       397
       +
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8107.hello

     

       398
       398
       +
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8107.lens

     

       399
       399
       +
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8107.random

     

       400
       400
        
               ];

     

       401
       401
        
             };

     

       402
       402
        
           }