commit 0c98bf3e85e5aa8137d9a7ae40468a3db53f0cdd · pyrox.dev/nixpkgs

+16 -1

nixos/modules/services/monitoring/apcupsd.nix

···

       62
        
       

     

       63
        
         );

     

       64
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       65
        
       in

     

       66
        
       

     

       67
        
       {

     
···

       138
        
           } ];

     

       139
        
       

     

       140
        
           # Give users access to the "apcaccess" tool

     

       141
       -
           environment.systemPackages = [ pkgs.apcupsd ];

     

       142
        
       

     

       143
        
           # NOTE 1: apcupsd runs as root because it needs permission to run

     

       144
        
           # "shutdown"

···

       62
        
       

     

       63
        
         );

     

       64
        
       

     

       65
       +
         # Ensure the CLI uses our generated configFile

     

       66
       +
         wrappedBinaries = pkgs.runCommandLocal "apcupsd-wrapped-binaries"

     

       67
       +
           { nativeBuildInputs = [ pkgs.makeWrapper ]; }

     

       68
       +
           ''

     

       69
       +
             for p in "${lib.getBin pkgs.apcupsd}/bin/"*; do

     

       70
       +
                 bname=$(basename "$p")

     

       71
       +
                 makeWrapper "$p" "$out/bin/$bname" --add-flags "-f ${configFile}"

     

       72
       +
             done

     

       73
       +
           '';

     

       74
       +
       

     

       75
       +
         apcupsdWrapped = pkgs.symlinkJoin {

     

       76
       +
           name = "apcupsd-wrapped";

     

       77
       +
           # Put wrappers first so they "win"

     

       78
       +
           paths = [ wrappedBinaries pkgs.apcupsd ];

     

       79
       +
         };

     

       80
        
       in

     

       81
        
       

     

       82
        
       {

     
···

       153
        
           } ];

     

       154
        
       

     

       155
        
           # Give users access to the "apcaccess" tool

     

       156
       +
           environment.systemPackages = [ apcupsdWrapped ];

     

       157
        
       

     

       158
        
           # NOTE 1: apcupsd runs as root because it needs permission to run

     

       159
        
           # "shutdown"

nixos/tests/all-tests.nix

···

       78
        
         allTerminfo = handleTest ./all-terminfo.nix {};

     

       79
        
         alps = handleTest ./alps.nix {};

     

       80
        
         amazon-init-shell = handleTest ./amazon-init-shell.nix {};

     

       0
        
       
     

       81
        
         apfs = handleTest ./apfs.nix {};

     

       82
        
         apparmor = handleTest ./apparmor.nix {};

     

       83
        
         atd = handleTest ./atd.nix {};

···

       78
        
         allTerminfo = handleTest ./all-terminfo.nix {};

     

       79
        
         alps = handleTest ./alps.nix {};

     

       80
        
         amazon-init-shell = handleTest ./amazon-init-shell.nix {};

     

       81
       +
         apcupsd = handleTest ./apcupsd.nix {};

     

       82
        
         apfs = handleTest ./apfs.nix {};

     

       83
        
         apparmor = handleTest ./apparmor.nix {};

     

       84
        
         atd = handleTest ./atd.nix {};

+41

nixos/tests/apcupsd.nix

···

       1
       +
       let

     

       2
       +
         # arbitrary address

     

       3
       +
         ipAddr = "192.168.42.42";

     

       4
       +
       in

     

       5
       +
       import ./make-test-python.nix ({ lib, pkgs, ... }: {

     

       6
       +
         name = "apcupsd";

     

       7
       +
         meta.maintainers = with lib.maintainers; [ bjornfor ];

     

       8
       +
       

     

       9
       +
         nodes = {

     

       10
       +
           machine = {

     

       11
       +
             services.apcupsd = {

     

       12
       +
               enable = true;

     

       13
       +
               configText = ''

     

       14
       +
                 UPSTYPE usb

     

       15
       +
                 BATTERYLEVEL 42

     

       16
       +
                 # Configure NISIP so that the only way apcaccess can work is to read

     

       17
       +
                 # this config.

     

       18
       +
                 NISIP ${ipAddr}

     

       19
       +
               '';

     

       20
       +
             };

     

       21
       +
             networking.interfaces.eth1 = {

     

       22
       +
               ipv4.addresses = [{

     

       23
       +
                 address = ipAddr;

     

       24
       +
                 prefixLength = 24;

     

       25
       +
               }];

     

       26
       +
             };

     

       27
       +
           };

     

       28
       +
         };

     

       29
       +
       

     

       30
       +
         # Check that the service starts, that the CLI (apcaccess) works and that it

     

       31
       +
         # uses the config (ipAddr) defined in the service config.

     

       32
       +
         testScript = ''

     

       33
       +
           start_all()

     

       34
       +
           machine.wait_for_unit("apcupsd.service")

     

       35
       +
           machine.wait_for_open_port(3551, "${ipAddr}")

     

       36
       +
           res = machine.succeed("apcaccess")

     

       37
       +
           expect_line="MBATTCHG : 42 Percent"

     

       38
       +
           assert "MBATTCHG : 42 Percent" in res, f"expected apcaccess output to contain '{expect_line}' but got '{res}'"

     

       39
       +
           machine.shutdown()

     

       40
       +
         '';

     

       41
       +
       })

+37

pkgs/applications/editors/vim/plugins/generated.nix

···

       4665
        
           meta.homepage = "https://github.com/chentoast/marks.nvim/";

     

       4666
        
         };

     

       4667
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4668
        
         matchit-zip = buildVimPluginFrom2Nix {

     

       4669
        
           pname = "matchit.zip";

     

       4670
        
           version = "2010-10-18";

···

       4665
        
           meta.homepage = "https://github.com/chentoast/marks.nvim/";

     

       4666
        
         };

     

       4667
        
       

     

       4668
       +
         mason-lspconfig-nvim = buildVimPluginFrom2Nix {

     

       4669
       +
           pname = "mason-lspconfig.nvim";

     

       4670
       +
           version = "2022-07-25";

     

       4671
       +
           src = fetchFromGitHub {

     

       4672
       +
             owner = "williamboman";

     

       4673
       +
             repo = "mason-lspconfig.nvim";

     

       4674
       +
             rev = "ad3b109cff22af979ab3d15564cd63dc3ae2f0f0";

     

       4675
       +
             sha256 = "0jvnc9zlr5cazdrhjm1v0bjkrz5lb2z8dzlkq59b433f52qv9zrf";

     

       4676
       +
           };

     

       4677
       +
           meta.homepage = "https://github.com/williamboman/mason-lspconfig.nvim/";

     

       4678
       +
         };

     

       4679
       +
       

     

       4680
       +
         mason-tool-installer-nvim = buildVimPluginFrom2Nix {

     

       4681
       +
           pname = "mason-tool-installer.nvim";

     

       4682
       +
           version = "2022-07-26";

     

       4683
       +
           src = fetchFromGitHub {

     

       4684
       +
             owner = "WhoIsSethDaniel";

     

       4685
       +
             repo = "mason-tool-installer.nvim";

     

       4686
       +
             rev = "6d9276655c09ef2358ddb105cac4a34cfa8853c0";

     

       4687
       +
             sha256 = "0j5k9fhjffkx3b5asnwxzj22fvncs69vs0rkx13ii3gdvwczbc5w";

     

       4688
       +
           };

     

       4689
       +
           meta.homepage = "https://github.com/WhoIsSethDaniel/mason-tool-installer.nvim/";

     

       4690
       +
         };

     

       4691
       +
       

     

       4692
       +
       

     

       4693
       +
         mason-nvim = buildVimPluginFrom2Nix {

     

       4694
       +
           pname = "mason.nvim";

     

       4695
       +
           version = "2022-07-27";

     

       4696
       +
           src = fetchFromGitHub {

     

       4697
       +
             owner = "williamboman";

     

       4698
       +
             repo = "mason.nvim";

     

       4699
       +
             rev = "269ee222f76e705619da2c0130c0a06e76419b88";

     

       4700
       +
             sha256 = "1bngr68gfv33p989dqhz6xmhips7i2yjni96qgnqwhdjczfw865v";

     

       4701
       +
           };

     

       4702
       +
           meta.homepage = "https://github.com/williamboman/mason.nvim/";

     

       4703
       +
         };

     

       4704
       +
       

     

       4705
        
         matchit-zip = buildVimPluginFrom2Nix {

     

       4706
        
           pname = "matchit.zip";

     

       4707
        
           version = "2010-10-18";

pkgs/applications/editors/vim/plugins/overrides.nix

···

       598
        
           '';

     

       599
        
         });

     

       600
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       601
        
         meson = buildVimPluginFrom2Nix {

     

       602
        
           inherit (meson) pname version src;

     

       603
        
           preInstall = "cd data/syntax-highlighting/vim";

···

       598
        
           '';

     

       599
        
         });

     

       600
        
       

     

       601
       +
         mason-lspconfig-nvim = super.mason-lspconfig-nvim.overrideAttrs (old: {

     

       602
       +
           dependencies = with self; [ mason-nvim nvim-lspconfig ];

     

       603
       +
         });

     

       604
       +
       

     

       605
       +
         mason-tool-installer-nvim = super.mason-tool-installer-nvim.overrideAttrs (old: {

     

       606
       +
           dependencies = with self; [ mason-nvim ];

     

       607
       +
         });

     

       608
       +
       

     

       609
        
         meson = buildVimPluginFrom2Nix {

     

       610
        
           inherit (meson) pname version src;

     

       611
        
           preInstall = "cd data/syntax-highlighting/vim";

pkgs/applications/editors/vim/plugins/vim-plugin-names

···

       391
        
       https://github.com/mkasa/lushtags/,,

     

       392
        
       https://github.com/iamcco/markdown-preview.nvim/,,

     

       393
        
       https://github.com/chentoast/marks.nvim/,,

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       394
        
       https://github.com/vim-scripts/matchit.zip/,,

     

       395
        
       https://github.com/marko-cerovac/material.nvim/,,

     

       396
        
       https://github.com/kaicataldo/material.vim/,HEAD,

···

       391
        
       https://github.com/mkasa/lushtags/,,

     

       392
        
       https://github.com/iamcco/markdown-preview.nvim/,,

     

       393
        
       https://github.com/chentoast/marks.nvim/,,

     

       394
       +
       https://github.com/williamboman/mason-lspconfig.nvim/,HEAD,

     

       395
       +
       https://github.com/WhoIsSethDaniel/mason-tool-installer.nvim/,HEAD,

     

       396
       +
       https://github.com/williamboman/mason.nvim/,HEAD,

     

       397
        
       https://github.com/vim-scripts/matchit.zip/,,

     

       398
        
       https://github.com/marko-cerovac/material.nvim/,,

     

       399
        
       https://github.com/kaicataldo/material.vim/,HEAD,

+3 -3

pkgs/applications/misc/limesctl/default.nix

···

       2
        
       

     

       3
        
       buildGoModule rec {

     

       4
        
         pname = "limesctl";

     

       5
       -
         version = "3.1.1";

     

       6
        
       

     

       7
        
         src = fetchFromGitHub {

     

       8
        
           owner = "sapcc";

     

       9
        
           repo = pname;

     

       10
        
           rev = "v${version}";

     

       11
       -
           sha256 = "sha256-/CYZMuW5/YoZszTOaQZLRhJdZAGGMY+s7vMK01hyMvg=";

     

       12
        
         };

     

       13
        
       

     

       14
       -
         vendorSha256 = "sha256-BwhbvCUOOp5ZeY/22kIZ58e+iPH0pVgiNOyoD6O2zPo=";

     

       15
        
       

     

       16
        
         subPackages = [ "." ];

     

       17

···

       2
        
       

     

       3
        
       buildGoModule rec {

     

       4
        
         pname = "limesctl";

     

       5
       +
         version = "3.1.3";

     

       6
        
       

     

       7
        
         src = fetchFromGitHub {

     

       8
        
           owner = "sapcc";

     

       9
        
           repo = pname;

     

       10
        
           rev = "v${version}";

     

       11
       +
           sha256 = "sha256-fi36jsQr/Mn1FyOlle/WSpREQgZU6+h4IJzd3ZfItvI=";

     

       12
        
         };

     

       13
        
       

     

       14
       +
         vendorSha256 = "sha256-gcIPASIk4Zq8y+KppYNRkf/9guCsYv9XskFANrqOCts=";

     

       15
        
       

     

       16
        
         subPackages = [ "." ];

     

       17

+3 -3

pkgs/applications/networking/browsers/chromium/upstream-info.json

···

       19
        
           }

     

       20
        
         },

     

       21
        
         "beta": {

     

       22
       -
           "version": "109.0.5414.61",

     

       23
       -
           "sha256": "1dk832ishjhba0rnf57w7vqrr8dyqga6zsgw9945i7zz997fpjyi",

     

       24
       -
           "sha256bin64": "1s1d7h9ygzpa5b39pdivn5vvpm7fpnhw5p3lz8blrgn61m8h6jg6",

     

       25
        
           "deps": {

     

       26
        
             "gn": {

     

       27
        
               "version": "2022-11-10",

···

       19
        
           }

     

       20
        
         },

     

       21
        
         "beta": {

     

       22
       +
           "version": "109.0.5414.74",

     

       23
       +
           "sha256": "0pcfaj3n3rjk4va9g0ajlsv1719kdhqcnjdd4piinqxb4qy27vgd",

     

       24
       +
           "sha256bin64": "1ihjjf8x5080p9bizhqrrr0rcjf0l1nps9xq9naa2f48y5zfshkd",

     

       25
        
           "deps": {

     

       26
        
             "gn": {

     

       27
        
               "version": "2022-11-10",

+2 -2

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

···

       168
        
         mkTerraform = attrs: pluggable (generic attrs);

     

       169
        
       

     

       170
        
         terraform_1 = mkTerraform {

     

       171
       -
           version = "1.3.6";

     

       172
       -
           sha256 = "sha256-aETsvcHoHSwqWCAdn9JPJLcX1Wi1umUghSjkq37OYDU=";

     

       173
        
           vendorSha256 = "sha256-fviukVGBkbxFs2fJpEp/tFMymXex7NRQdcGIIA9W88k=";

     

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

     

       175
        
           passthru = {

···

       168
        
         mkTerraform = attrs: pluggable (generic attrs);

     

       169
        
       

     

       170
        
         terraform_1 = mkTerraform {

     

       171
       +
           version = "1.3.7";

     

       172
       +
           sha256 = "sha256-z49DXJ9oYObJQWHPeuKvQ6jJtAheYuy0+QmvZ74ZbTQ";

     

       173
        
           vendorSha256 = "sha256-fviukVGBkbxFs2fJpEp/tFMymXex7NRQdcGIIA9W88k=";

     

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

     

       175
        
           passthru = {

+32

pkgs/applications/networking/instant-messengers/keet/default.nix

···

       1
       +
       { lib, appimageTools, fetchurl }:

     

       2
       +
       

     

       3
       +
       let

     

       4
       +
         pname = "keet";

     

       5
       +
         version = "1.2.1";

     

       6
       +
       

     

       7
       +
         src = fetchurl {

     

       8
       +
           url = "https://keet.io/downloads/${version}/Keet.AppImage";

     

       9
       +
           sha256 = "1f76ccfa16719a24f6d84b88e5ca49fab1c372de309ce74393461903c5c49d98";

     

       10
       +
         };

     

       11
       +
       

     

       12
       +
         appimageContents = appimageTools.extract { inherit pname version src; };

     

       13
       +
       in appimageTools.wrapType2 {

     

       14
       +
         inherit src pname version;

     

       15
       +
       

     

       16
       +
         extraInstallCommands = ''

     

       17
       +
           mv $out/bin/${pname}-${version} $out/bin/${pname}

     

       18
       +
       

     

       19
       +
           install -m 444 -D ${appimageContents}/${pname}.desktop -t $out/share/applications

     

       20
       +
           substituteInPlace $out/share/applications/${pname}.desktop \

     

       21
       +
             --replace 'Exec=AppRun' 'Exec=${pname}'

     

       22
       +
           cp -r ${appimageContents}/usr/share/icons $out/share

     

       23
       +
         '';

     

       24
       +
       

     

       25
       +
         meta = with lib; {

     

       26
       +
           description = "Peer-to-Peer Chat";

     

       27
       +
           homepage = "https://keet.io";

     

       28
       +
           license = licenses.unfree;

     

       29
       +
           maintainers = with maintainers; [ extends ];

     

       30
       +
           platforms = [ "x86_64-linux" ];

     

       31
       +
         };

     

       32
       +
       }

+5 -5

pkgs/applications/networking/seaweedfs/default.nix

···

       7
        
       

     

       8
        
       buildGoModule rec {

     

       9
        
         pname = "seaweedfs";

     

       10
       -
         version = "3.34";

     

       11
        
       

     

       12
        
         src = fetchFromGitHub {

     

       13
       -
           owner = "chrislusf";

     

       14
        
           repo = "seaweedfs";

     

       15
        
           rev = version;

     

       16
       -
           hash = "sha256-lOCZHkLJCDvaT3CcHUBbsybdy0H6BfKKGpd/73cxcWA=";

     

       17
        
         };

     

       18
        
       

     

       19
       -
         vendorHash = "sha256-1RUWONkXArXYg8gQogKUhMSGdIYyT3lq5qWuUQBsFig=";

     

       20
        
       

     

       21
        
         subPackages = [ "weed" ];

     

       22
        
       

     
···

       49
        
         meta = with lib; {

     

       50
        
           description = "Simple and highly scalable distributed file system";

     

       51
        
           homepage = "https://github.com/chrislusf/seaweedfs";

     

       52
       -
           maintainers = with maintainers; [ azahi cmacrae ];

     

       53
        
           mainProgram = "weed";

     

       54
        
           license = licenses.asl20;

     

       55
        
         };

···

       7
        
       

     

       8
        
       buildGoModule rec {

     

       9
        
         pname = "seaweedfs";

     

       10
       +
         version = "3.38";

     

       11
        
       

     

       12
        
         src = fetchFromGitHub {

     

       13
       +
           owner = "seaweedfs";

     

       14
        
           repo = "seaweedfs";

     

       15
        
           rev = version;

     

       16
       +
           hash = "sha256-LYMGkv1rgUtA/TwulBhgw0w+8kbICtEgr7/K6exalxM=";

     

       17
        
         };

     

       18
        
       

     

       19
       +
         vendorHash = "sha256-mwfs/tdq1Qq2auEwz24emf7pjpIJAncI78oxhAn2WkI=";

     

       20
        
       

     

       21
        
         subPackages = [ "weed" ];

     

       22
        
       

     
···

       49
        
         meta = with lib; {

     

       50
        
           description = "Simple and highly scalable distributed file system";

     

       51
        
           homepage = "https://github.com/chrislusf/seaweedfs";

     

       52
       +
           maintainers = with maintainers; [ azahi cmacrae wozeparrot ];

     

       53
        
           mainProgram = "weed";

     

       54
        
           license = licenses.asl20;

     

       55
        
         };

+4 -4

pkgs/data/misc/hackage/pin.json

···

       1
        
       {

     

       2
       -
         "commit": "208dc93f04d6fb2dbc01e11434c7dcea50a8a9e6",

     

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

     

       4
       -
         "sha256": "19pgh69fj3p1glqyjikpsvn5j4bax6yw5qxf9qaaap19hksgn85p",

     

       5
       -
         "msg": "Update from Hackage at 2022-12-28T16:35:05Z"

     

       6
        
       }

···

       1
        
       {

     

       2
       +
         "commit": "78541d36393ac3dd0ffa32b4a9af15fecdefb5d1",

     

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

     

       4
       +
         "sha256": "1qwjkjlz9sw1jnsarin6803vj68bfm3iyysfwxaifga5w4dsrqcs",

     

       5
       +
         "msg": "Update from Hackage at 2022-12-30T22:03:31Z"

     

       6
        
       }

+14 -19

pkgs/development/compilers/blueprint/default.nix

···

       1
       -
       { gtk4

     

       2
       -
       , python3

     

       3
       -
       , stdenv

     

       4
       -
       , fetchFromGitLab

     

       5
        
       , gobject-introspection

     

       0
        
       
     

       6
        
       , lib

     

       7
        
       , meson

     

       8
        
       , ninja

     

       0
        
       
     

       0
        
       
     

       9
        
       , testers

     

       10
        
       }:

     

       11
       -
       

     

       12
        
       stdenv.mkDerivation (finalAttrs: {

     

       13
        
         pname = "blueprint-compiler";

     

       14
        
         version = "0.6.0";

     
···

       21
        
           hash = "sha256-L6EGterkZ8EB6xSnJDZ3IMuOumpTpEGnU74X3UgC7k0=";

     

       22
        
         };

     

       23
        
       

     

       24
       -
         doCheck = true;

     

       25
       -
       

     

       26
        
         nativeBuildInputs = [

     

       27
        
           meson

     

       28
        
           ninja

     

       29
        
         ];

     

       30
        
       

     

       31
        
         buildInputs = [

     

       32
       -
           python3

     

       33
       -
           gtk4

     

       34
       -
         ] ++ (with python3.pkgs; [

     

       35
       -
           pygobject3

     

       36
       -
           wrapPython

     

       37
       -
         ]);

     

       38
        
       

     

       39
        
         propagatedBuildInputs = [

     

       0
        
       
     

       40
        
           gobject-introspection

     

       41
        
         ];

     

       42
        
       

     

       43
       -
         postFixup = ''

     

       44
       -
           makeWrapperArgs="\

     

       45
       -
             --prefix GI_TYPELIB_PATH : $GI_TYPELIB_PATH \

     

       46
       -
             --prefix PYTHONPATH : \"$(toPythonPath $out):$(toPythonPath ${python3.pkgs.pygobject3})\""

     

       47
       -
           wrapPythonPrograms

     

       48
       -
         '';

     

       49
        
       

     

       50
        
         passthru.tests.version = testers.testVersion {

     

       51
        
           package = finalAttrs.finalPackage;

···

       1
       +
       { fetchFromGitLab

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       , gobject-introspection

     

       3
       +
       , gtk4

     

       4
        
       , lib

     

       5
        
       , meson

     

       6
        
       , ninja

     

       7
       +
       , python3

     

       8
       +
       , stdenv

     

       9
        
       , testers

     

       10
        
       }:

     

       0
        
       
     

       11
        
       stdenv.mkDerivation (finalAttrs: {

     

       12
        
         pname = "blueprint-compiler";

     

       13
        
         version = "0.6.0";

     
···

       20
        
           hash = "sha256-L6EGterkZ8EB6xSnJDZ3IMuOumpTpEGnU74X3UgC7k0=";

     

       21
        
         };

     

       22
        
       

     

       0
        
       
     

       0
        
       
     

       23
        
         nativeBuildInputs = [

     

       24
        
           meson

     

       25
        
           ninja

     

       26
        
         ];

     

       27
        
       

     

       28
        
         buildInputs = [

     

       29
       +
           (python3.withPackages (ps: with ps; [

     

       30
       +
             pygobject3

     

       31
       +
           ]))

     

       32
       +
         ];

     

       0
        
       
     

       0
        
       
     

       33
        
       

     

       34
        
         propagatedBuildInputs = [

     

       35
       +
           # For setup hook, so that the compiler can find typelib files

     

       36
        
           gobject-introspection

     

       37
        
         ];

     

       38
        
       

     

       39
       +
         doCheck = true;

     

       40
       +
       

     

       41
       +
         checkInputs = [

     

       42
       +
           gtk4

     

       43
       +
         ];

     

       0
        
       
     

       44
        
       

     

       45
        
         passthru.tests.version = testers.testVersion {

     

       46
        
           package = finalAttrs.finalPackage;

pkgs/development/compilers/emscripten/default.nix

···

       3
        
       , llvmPackages

     

       4
        
       , symlinkJoin, makeWrapper, substituteAll

     

       5
        
       , mkYarnModules

     

       0
        
       
     

       6
        
       }:

     

       7
        
       

     

       8
        
       stdenv.mkDerivation rec {

     
···

       115
        
       

     

       116
        
           runHook postInstall

     

       117
        
         '';

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       118
        
       

     

       119
        
         meta = with lib; {

     

       120
        
           homepage = "https://github.com/emscripten-core/emscripten";

···

       3
        
       , llvmPackages

     

       4
        
       , symlinkJoin, makeWrapper, substituteAll

     

       5
        
       , mkYarnModules

     

       6
       +
       , emscripten

     

       7
        
       }:

     

       8
        
       

     

       9
        
       stdenv.mkDerivation rec {

     
···

       116
        
       

     

       117
        
           runHook postInstall

     

       118
        
         '';

     

       119
       +
       

     

       120
       +
         passthru = {

     

       121
       +
           # HACK: Make emscripten look more like a cc-wrapper to GHC

     

       122
       +
           # when building the javascript backend.

     

       123
       +
           targetPrefix = "em";

     

       124
       +
           bintools = emscripten;

     

       125
       +
         };

     

       126
        
       

     

       127
        
         meta = with lib; {

     

       128
        
           homepage = "https://github.com/emscripten-core/emscripten";

+3 -1

pkgs/development/compilers/ghc/8.10.7.nix

···

       21
        
       

     

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

     

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

     

       24
       -
         enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp), gmp

     

       0
        
       
     

       0
        
       
     

       25
        
       

     

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

     

       27
        
         enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform

···

       21
        
       

     

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

     

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

     

       24
       +
         enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp

     

       25
       +
                                 && lib.meta.availableOn stdenv.targetPlatform gmp)

     

       26
       +
       , gmp

     

       27
        
       

     

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

     

       29
        
         enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform

+3 -1

pkgs/development/compilers/ghc/8.8.4.nix

···

       20
        
       

     

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

     

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

     

       23
       -
         enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp), gmp

     

       0
        
       
     

       0
        
       
     

       24
        
       

     

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

     

       26
        
         enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform

···

       20
        
       

     

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

     

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

     

       23
       +
         enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp

     

       24
       +
                                 && lib.meta.availableOn stdenv.targetPlatform gmp)

     

       25
       +
       , gmp

     

       26
        
       

     

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

     

       28
        
         enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform

+2 -1

pkgs/development/compilers/ghc/9.0.2.nix

···

       23
        
       

     

       24
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       25
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       26
       -
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)

     

       0
        
       
     

       27
        
       , gmp

     

       28
        
       

     

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

···

       23
        
       

     

       24
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       25
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       26
       +
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp

     

       27
       +
                                && lib.meta.availableOn stdenv.targetPlatform gmp)

     

       28
        
       , gmp

     

       29
        
       

     

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

+2 -1

pkgs/development/compilers/ghc/9.2.4.nix

···

       23
        
       

     

       24
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       25
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       26
       -
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)

     

       0
        
       
     

       27
        
       , gmp

     

       28
        
       

     

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

···

       23
        
       

     

       24
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       25
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       26
       +
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp

     

       27
       +
                                && lib.meta.availableOn stdenv.targetPlatform gmp)

     

       28
        
       , gmp

     

       29
        
       

     

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

+2 -1

pkgs/development/compilers/ghc/9.2.5.nix

···

       23
        
       

     

       24
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       25
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       26
       -
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)

     

       0
        
       
     

       27
        
       , gmp

     

       28
        
       

     

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

···

       23
        
       

     

       24
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       25
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       26
       +
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp

     

       27
       +
                                && lib.meta.availableOn stdenv.targetPlatform gmp)

     

       28
        
       , gmp

     

       29
        
       

     

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

+2 -1

pkgs/development/compilers/ghc/9.4.2.nix

···

       25
        
       

     

       26
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       27
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       28
       -
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)

     

       0
        
       
     

       29
        
       , gmp

     

       30
        
       

     

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

···

       25
        
       

     

       26
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       27
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       28
       +
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp

     

       29
       +
                                && lib.meta.availableOn stdenv.targetPlatform gmp)

     

       30
        
       , gmp

     

       31
        
       

     

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

+2 -1

pkgs/development/compilers/ghc/9.4.3.nix

···

       25
        
       

     

       26
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       27
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       28
       -
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)

     

       0
        
       
     

       29
        
       , gmp

     

       30
        
       

     

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

···

       25
        
       

     

       26
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       27
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       28
       +
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp

     

       29
       +
                                && lib.meta.availableOn stdenv.targetPlatform gmp)

     

       30
        
       , gmp

     

       31
        
       

     

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

+2 -1

pkgs/development/compilers/ghc/9.4.4.nix

···

       25
        
       

     

       26
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       27
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       28
       -
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)

     

       0
        
       
     

       29
        
       , gmp

     

       30
        
       

     

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

···

       25
        
       

     

       26
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       27
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       28
       +
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp

     

       29
       +
                                && lib.meta.availableOn stdenv.targetPlatform gmp)

     

       30
        
       , gmp

     

       31
        
       

     

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

+27 -15

pkgs/development/compilers/ghc/common-hadrian.nix

···

       39
        
       , useLLVM ? !(stdenv.targetPlatform.isx86

     

       40
        
                     || stdenv.targetPlatform.isPower

     

       41
        
                     || stdenv.targetPlatform.isSparc

     

       42
       -
                     || (stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin))

     

       0
        
       
     

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

     

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

     

       45
        
         # build-time dependency too.

     
···

       48
        
       

     

       49
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       50
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       51
       -
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)

     

       0
        
       
     

       0
        
       
     

       52
        
       , gmp

     

       53
        
       

     

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

     
···

       62
        
         enableShared ? with stdenv.targetPlatform; !isWindows && !useiOSPrebuilt && !isStatic

     

       63
        
       

     

       64
        
       , # Whether to build terminfo.

     

       65
       -
         enableTerminfo ? !stdenv.targetPlatform.isWindows

     

       0
        
       
     

       66
        
       

     

       67
        
       , # Libdw.c only supports x86_64, i686 and s390x as of 2022-08-04

     

       68
        
         enableDwarf ? (stdenv.targetPlatform.isx86 ||

     
···

       156
        
       

     

       157
        
       assert !enableNativeBignum -> gmp != null;

     

       158
        
       

     

       159
       -
       assert stdenv.hostPlatform == stdenv.targetPlatform || throw ''

     

       160
       -
         hadrian doesn't support building an installable GHC cross-compiler at the moment.

     

       161
       -
         Consider using GHC 9.4 or lower which support this via the make build system.

     

       162
       -
         See also: https://gitlab.haskell.org/ghc/ghc/-/issues/22090

     

       163
       -
       '';

     

       164
       -
       

     

       165
        
       let

     

       166
        
         src = (if rev != null then fetchgit else fetchurl) ({

     

       167
        
           inherit url sha256;

     
···

       201
        
       

     

       202
        
         # Splicer will pull out correct variations

     

       203
        
         libDeps = platform: lib.optional enableTerminfo ncurses

     

       204
       -
           ++ [libffi]

     

       205
        
           # Bindist configure script fails w/o elfutils in linker search path

     

       206
        
           # https://gitlab.haskell.org/ghc/ghc/-/issues/22081

     

       207
        
           ++ lib.optional enableDwarf elfutils

     

       208
        
           ++ lib.optional (!enableNativeBignum) gmp

     

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

     

       210
        
       

     

       211
        
         # TODO(@sternenseemann): is buildTarget LLVM unnecessary?

     

       212
        
         # GHC doesn't seem to have {LLC,OPT}_HOST

     

       213
        
         toolsForTarget = [

     

       214
       -
           pkgsBuildTarget.targetPackages.stdenv.cc

     

       0
        
       
     

       0
        
       
     

       215
        
         ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm;

     

       216
        
       

     

       217
        
         targetCC = builtins.head toolsForTarget;

     
···

       251
        
       # C compiler, bintools and LLVM are used at build time, but will also leak into

     

       252
        
       # the resulting GHC's settings file and used at runtime. This means that we are

     

       253
        
       # currently only able to build GHC if hostPlatform == buildPlatform.

     

       254
       -
       assert targetCC == pkgsHostTarget.targetPackages.stdenv.cc;

     

       255
        
       assert buildTargetLlvmPackages.llvm == llvmPackages.llvm;

     

       256
        
       assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang;

     

       257
        
       

     
···

       334
        
                           '*-android*|*-gnueabi*|*-musleabi*)'

     

       335
        
             done

     

       336
        
         ''

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       337
        
         # Create bash array hadrianFlagsArray for use in buildPhase. Do it in

     

       338
        
         # preConfigure, so overrideAttrs can be used to modify it effectively.

     

       339
        
         # hadrianSettings are passed via the command line so they are more visible

     
···

       344
        
             ${lib.escapeShellArgs hadrianSettings}

     

       345
        
           )

     

       346
        
         '';

     

       0
        
       
     

       0
        
       
     

       347
        
       

     

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

     

       349
        
         configurePlatforms = [ "build" "host" ]

     
···

       353
        
         configureFlags = [

     

       354
        
           "--datadir=$doc/share/doc/ghc"

     

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

     

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

     

       357
        
           "--with-system-libffi"

     

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

     

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

     
···

       392
        
           autoSignDarwinBinariesHook

     

       393
        
         ] ++ lib.optionals enableDocs [

     

       394
        
           sphinx

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       395
        
         ];

     

       396
        
       

     

       397
        
         # For building runtime libs

     
···

       450
        
         preInstall = ''

     

       451
        
           pushd _build/bindist/*

     

       452
        
       

     

       453
       -
           ./configure $configureFlags "''${configureFlagsArray[@]}"

     

       454
        
         '';

     

       455
        
       

     

       456
        
         postInstall = ''

···

       39
        
       , useLLVM ? !(stdenv.targetPlatform.isx86

     

       40
        
                     || stdenv.targetPlatform.isPower

     

       41
        
                     || stdenv.targetPlatform.isSparc

     

       42
       +
                     || (stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin)

     

       43
       +
                     || stdenv.targetPlatform.isGhcjs)

     

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

     

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

     

       46
        
         # build-time dependency too.

     
···

       49
        
       

     

       50
        
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       51
        
         # bignum backend instead of the faster but GPLed gmp backend.

     

       52
       +
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp

     

       53
       +
                                && lib.meta.availableOn stdenv.targetPlatform gmp)

     

       54
       +
                              || stdenv.targetPlatform.isGhcjs

     

       55
        
       , gmp

     

       56
        
       

     

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

     
···

       65
        
         enableShared ? with stdenv.targetPlatform; !isWindows && !useiOSPrebuilt && !isStatic

     

       66
        
       

     

       67
        
       , # Whether to build terminfo.

     

       68
       +
         enableTerminfo ? !(stdenv.targetPlatform.isWindows

     

       69
       +
                            || stdenv.targetPlatform.isGhcjs)

     

       70
        
       

     

       71
        
       , # Libdw.c only supports x86_64, i686 and s390x as of 2022-08-04

     

       72
        
         enableDwarf ? (stdenv.targetPlatform.isx86 ||

     
···

       160
        
       

     

       161
        
       assert !enableNativeBignum -> gmp != null;

     

       162
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       163
        
       let

     

       164
        
         src = (if rev != null then fetchgit else fetchurl) ({

     

       165
        
           inherit url sha256;

     
···

       199
        
       

     

       200
        
         # Splicer will pull out correct variations

     

       201
        
         libDeps = platform: lib.optional enableTerminfo ncurses

     

       202
       +
           ++ lib.optionals (!targetPlatform.isGhcjs) [libffi]

     

       203
        
           # Bindist configure script fails w/o elfutils in linker search path

     

       204
        
           # https://gitlab.haskell.org/ghc/ghc/-/issues/22081

     

       205
        
           ++ lib.optional enableDwarf elfutils

     

       206
        
           ++ lib.optional (!enableNativeBignum) gmp

     

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

     

       208
        
       

     

       209
        
         # TODO(@sternenseemann): is buildTarget LLVM unnecessary?

     

       210
        
         # GHC doesn't seem to have {LLC,OPT}_HOST

     

       211
        
         toolsForTarget = [

     

       212
       +
           (if targetPlatform.isGhcjs

     

       213
       +
            then pkgsBuildTarget.emscripten

     

       214
       +
            else pkgsBuildTarget.targetPackages.stdenv.cc)

     

       215
        
         ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm;

     

       216
        
       

     

       217
        
         targetCC = builtins.head toolsForTarget;

     
···

       251
        
       # C compiler, bintools and LLVM are used at build time, but will also leak into

     

       252
        
       # the resulting GHC's settings file and used at runtime. This means that we are

     

       253
        
       # currently only able to build GHC if hostPlatform == buildPlatform.

     

       254
       +
       assert !targetPlatform.isGhcjs -> targetCC == pkgsHostTarget.targetPackages.stdenv.cc;

     

       255
        
       assert buildTargetLlvmPackages.llvm == llvmPackages.llvm;

     

       256
        
       assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang;

     

       257
        
       

     
···

       334
        
                           '*-android*|*-gnueabi*|*-musleabi*)'

     

       335
        
             done

     

       336
        
         ''

     

       337
       +
         # Need to make writable EM_CACHE for emscripten

     

       338
       +
         # https://gitlab.haskell.org/ghc/ghc/-/wikis/javascript-backend#configure-fails-with-sub-word-sized-atomic-operations-not-available

     

       339
       +
         + lib.optionalString targetPlatform.isGhcjs ''

     

       340
       +
           export EM_CACHE="$(mktemp -d emcache.XXXXXXXXXX)"

     

       341
       +
           cp -Lr ${targetCC /* == emscripten */}/share/emscripten/cache/* "$EM_CACHE/"

     

       342
       +
           chmod u+rwX -R "$EM_CACHE"

     

       343
       +
         ''

     

       344
        
         # Create bash array hadrianFlagsArray for use in buildPhase. Do it in

     

       345
        
         # preConfigure, so overrideAttrs can be used to modify it effectively.

     

       346
        
         # hadrianSettings are passed via the command line so they are more visible

     
···

       351
        
             ${lib.escapeShellArgs hadrianSettings}

     

       352
        
           )

     

       353
        
         '';

     

       354
       +
       

     

       355
       +
         ${if targetPlatform.isGhcjs then "configureScript" else null} = "emconfigure ./configure";

     

       356
        
       

     

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

     

       358
        
         configurePlatforms = [ "build" "host" ]

     
···

       362
        
         configureFlags = [

     

       363
        
           "--datadir=$doc/share/doc/ghc"

     

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

     

       365
       +
         ] ++ lib.optionals (libffi != null && !targetPlatform.isGhcjs) [

     

       366
        
           "--with-system-libffi"

     

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

     

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

     
···

       401
        
           autoSignDarwinBinariesHook

     

       402
        
         ] ++ lib.optionals enableDocs [

     

       403
        
           sphinx

     

       404
       +
         ] ++ lib.optionals targetPlatform.isGhcjs [

     

       405
       +
           # emscripten itself is added via depBuildTarget / targetCC

     

       406
       +
           python3

     

       407
        
         ];

     

       408
        
       

     

       409
        
         # For building runtime libs

     
···

       462
        
         preInstall = ''

     

       463
        
           pushd _build/bindist/*

     

       464
        
       

     

       465
       +
           $configureScript $configureFlags "''${configureFlagsArray[@]}"

     

       466
        
         '';

     

       467
        
       

     

       468
        
         postInstall = ''

+3 -3

pkgs/development/compilers/ghc/head.nix

···

       1
        
       import ./common-hadrian.nix {

     

       2
       -
         version = "9.5.20220921";

     

       3
       -
         rev = "2463df2fe21b5b37ecada3df8c6726c534d24590";

     

       4
       -
         sha256 = "1k2h4myqbs31fdzw5n4iw0qn44mp7d33kjwrr15ix4r54r8yskzs";

     

       5
        
       }

···

       1
        
       import ./common-hadrian.nix {

     

       2
       +
         version = "9.7.20221224";

     

       3
       +
         rev = "a5bd0eb8dd1d03c54e1b0b476ebbc4cc886d6f19";

     

       4
       +
         sha256 = "1rrds9alzpy4vyh2isan32h1zmf44nsr8552wbsn1y3fg6bnpbxi";

     

       5
        
       }

+3 -1

pkgs/development/compilers/openjdk/19.nix

···

       4
        
       , libXi, libXinerama, libXcursor, libXrandr, fontconfig, openjdk19-bootstrap

     

       5
        
       , ensureNewerSourcesForZipFilesHook

     

       6
        
       , setJavaClassPath

     

       7
       -
       , headless ? false

     

       0
        
       
     

       0
        
       
     

       8
        
       , enableJavaFX ? openjfx.meta.available, openjfx

     

       9
        
       , enableGnome2 ? true, gtk3, gnome_vfs, glib, GConf

     

       10
        
       }:

···

       4
        
       , libXi, libXinerama, libXcursor, libXrandr, fontconfig, openjdk19-bootstrap

     

       5
        
       , ensureNewerSourcesForZipFilesHook

     

       6
        
       , setJavaClassPath

     

       7
       +
       # TODO(@sternenseemann): gtk3 fails to evaluate in pkgsCross.ghcjs.buildPackages

     

       8
       +
       # which should be fixable, this is a no-rebuild workaround for GHC.

     

       9
       +
       , headless ? stdenv.targetPlatform.isGhcjs

     

       10
        
       , enableJavaFX ? openjfx.meta.available, openjfx

     

       11
        
       , enableGnome2 ? true, gtk3, gnome_vfs, glib, GConf

     

       12
        
       }:

+3 -1

pkgs/development/compilers/temurin-bin/jdk-linux-base.nix

···

       20
        
       # runtime dependencies

     

       21
        
       , cups

     

       22
        
       # runtime dependencies for GTK+ Look and Feel

     

       23
       -
       , gtkSupport ? true

     

       0
        
       
     

       0
        
       
     

       24
        
       , cairo

     

       25
        
       , glib

     

       26
        
       , gtk3

···

       20
        
       # runtime dependencies

     

       21
        
       , cups

     

       22
        
       # runtime dependencies for GTK+ Look and Feel

     

       23
       +
       # TODO(@sternenseemann): gtk3 fails to evaluate in pkgsCross.ghcjs.buildPackages

     

       24
       +
       # which should be fixable, this is a no-rebuild workaround for GHC.

     

       25
       +
       , gtkSupport ? !stdenv.targetPlatform.isGhcjs

     

       26
        
       , cairo

     

       27
        
       , glib

     

       28
        
       , gtk3

+12 -38

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

···

       216
        
         # https://github.com/haskell-nix/hnix-store/issues/180

     

       217
        
         hnix-store-core = doJailbreak super.hnix-store-core;

     

       218
        
       

     

       219
       -
         # Too strict upper bound on bytestring

     

       220
       -
         # https://github.com/wangbj/hashing/issues/3

     

       221
       -
         hashing = doJailbreak super.hashing;

     

       222
       -
       

     

       223
        
         # Fails for non-obvious reasons while attempting to use doctest.

     

       224
        
         focuslist = dontCheck super.focuslist;

     

       225
        
         search = dontCheck super.search;

     
···

       1460
        
         servant-swagger-ui-core = doJailbreak super.servant-swagger-ui-core;

     

       1461
        
       

     

       1462
        
         hercules-ci-agent = lib.pipe super.hercules-ci-agent [

     

       1463
       -
           (appendPatches [

     

       1464
       -
             # haskell-updates branch, will be merged in 0.9.10

     

       1465
       -
             (fetchpatch2 {

     

       1466
       -
               name = "hercules-ci-agent-cachix-1.1";

     

       1467
       -
               url = "https://github.com/hercules-ci/hercules-ci-agent/commit/b76d888548da37a96ae47f1be871de6605d38edd.patch";

     

       1468
       -
               sha256 = "sha256-kqEkDHbatcYS8LuQlGV/1j/6LXWviQoDQAHDr6DBbDU=";

     

       1469
       -
               stripLen = 1;

     

       1470
       -
               includes = [ "*.hs" ];

     

       1471
       -
             })

     

       1472
       -
           ])

     

       1473
        
           (self.generateOptparseApplicativeCompletions [ "hercules-ci-agent" ])

     

       1474
        
         ];

     

       1475
        
       

     
···

       1913
        
         # 2022-12-30: Restrictive upper bound on optparse-applicative

     

       1914
        
         retrie = doJailbreak super.retrie;

     

       1915
        
       

     

       1916
       -
         # Fixes https://github.com/NixOS/nixpkgs/issues/140613

     

       1917
       -
         # https://github.com/recursion-schemes/recursion-schemes/issues/128

     

       1918
       -
         recursion-schemes = overrideCabal (drv: {

     

       1919
       -
           patches = drv.patches or [] ++ [

     

       1920
       -
             ./patches/recursion-schemes-128.patch

     

       1921
       -
           ];

     

       1922
       -
           # make sure line endings don't break the patch

     

       1923
       -
           prePatch = drv.prePatch or "" + ''

     

       1924
       -
             "${pkgs.buildPackages.dos2unix}/bin/dos2unix" *.cabal

     

       1925
       -
           '';

     

       1926
       -
         }) super.recursion-schemes;

     

       1927
       -
       

     

       1928
        
         # 2022-08-30 Too strict bounds on finite-typelits

     

       1929
        
         # https://github.com/jumper149/blucontrol/issues/1

     

       1930
        
         blucontrol = doJailbreak super.blucontrol;

     
···

       2003
        
             "--skip" "/toJsonSerializer/should generate valid JSON/"

     

       2004
        
           ] ++ drv.testFlags or [];

     

       2005
        
         }) super.hschema-aeson;

     

       2006
       -
         # https://gitlab.com/k0001/xmlbf/-/issues/32

     

       2007
       -
         xmlbf = overrideCabal (drv: {

     

       2008
       -
           testFlags = [

     

       2009
       -
             "-p" "!/xml: <x b=\"\" a=\"y\"><\\/x>/&&!/xml: <x b=\"z\" a=\"y\"><\\/x>/"

     

       2010
       -
           ] ++ drv.testFlags or [];

     

       2011
       -
         }) super.xmlbf;

     

       2012
        
         # https://github.com/ssadler/aeson-quick/issues/3

     

       2013
        
         aeson-quick = overrideCabal (drv: {

     

       2014
        
           testFlags = [

     
···

       2141
        
         # Test suite doesn't support hspec 2.8

     

       2142
        
         # https://github.com/zellige/hs-geojson/issues/29

     

       2143
        
         geojson = dontCheck super.geojson;

     

       2144
       -
       

     

       2145
       -
         # Doesn't support aeson >= 2.0

     

       2146
       -
         # https://github.com/channable/vaultenv/issues/118

     

       2147
       -
         vaultenv = super.vaultenv.overrideScope (self: super: {

     

       2148
       -
           aeson = self.aeson_1_5_6_0;

     

       2149
       -
         });

     

       2150
        
       

     

       2151
        
         # Support network >= 3.1.2

     

       2152
        
         # https://github.com/erebe/wstunnel/pull/107

     
···

       2363
        
         } super.postgrest));

     

       2364
        
       

     

       2365
        
         html-charset = dontCheck super.html-charset;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

···

       216
        
         # https://github.com/haskell-nix/hnix-store/issues/180

     

       217
        
         hnix-store-core = doJailbreak super.hnix-store-core;

     

       218
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       219
        
         # Fails for non-obvious reasons while attempting to use doctest.

     

       220
        
         focuslist = dontCheck super.focuslist;

     

       221
        
         search = dontCheck super.search;

     
···

       1456
        
         servant-swagger-ui-core = doJailbreak super.servant-swagger-ui-core;

     

       1457
        
       

     

       1458
        
         hercules-ci-agent = lib.pipe super.hercules-ci-agent [

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1459
        
           (self.generateOptparseApplicativeCompletions [ "hercules-ci-agent" ])

     

       1460
        
         ];

     

       1461
        
       

     
···

       1899
        
         # 2022-12-30: Restrictive upper bound on optparse-applicative

     

       1900
        
         retrie = doJailbreak super.retrie;

     

       1901
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1902
        
         # 2022-08-30 Too strict bounds on finite-typelits

     

       1903
        
         # https://github.com/jumper149/blucontrol/issues/1

     

       1904
        
         blucontrol = doJailbreak super.blucontrol;

     
···

       1977
        
             "--skip" "/toJsonSerializer/should generate valid JSON/"

     

       1978
        
           ] ++ drv.testFlags or [];

     

       1979
        
         }) super.hschema-aeson;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1980
        
         # https://github.com/ssadler/aeson-quick/issues/3

     

       1981
        
         aeson-quick = overrideCabal (drv: {

     

       1982
        
           testFlags = [

     
···

       2109
        
         # Test suite doesn't support hspec 2.8

     

       2110
        
         # https://github.com/zellige/hs-geojson/issues/29

     

       2111
        
         geojson = dontCheck super.geojson;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2112
        
       

     

       2113
        
         # Support network >= 3.1.2

     

       2114
        
         # https://github.com/erebe/wstunnel/pull/107

     
···

       2325
        
         } super.postgrest));

     

       2326
        
       

     

       2327
        
         html-charset = dontCheck super.html-charset;

     

       2328
       +
       

     

       2329
       +
         # true-name-0.1.0.4 has been tagged, but has not been released to Hackage.

     

       2330
       +
         # Also, beyond 0.1.0.4 an additional patch is required to make true-name

     

       2331
       +
         # compatible with current versions of template-haskell

     

       2332
       +
         # https://github.com/liyang/true-name/pull/4

     

       2333
       +
         true-name = appendPatch (fetchpatch {

     

       2334
       +
           url = "https://github.com/liyang/true-name/compare/0.1.0.3...nuttycom:true-name:update_template_haskell.patch";

     

       2335
       +
           hash = "sha256-ZMBXGGc2X5AKXYbqgkLXkg5BhEwyj022E37sUEWahtc=";

     

       2336
       +
         }) (overrideCabal (drv: {

     

       2337
       +
           revision = null;

     

       2338
       +
           editedCabalFile = null;

     

       2339
       +
         }) super.true-name);

     

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

-2

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

···

       60
        
       

     

       61
        
         # consequences of doctest breakage follow:

     

       62
        
       

     

       63
       -
         double-conversion = markBroken super.double-conversion;

     

       64
       -
         blaze-textual = checkAgainAfter super.double-conversion "2.0.4.1" "double-conversion fails to build; required for testsuite" (dontCheck super.blaze-textual);

     

       65
        
         ghc-source-gen = checkAgainAfter super.ghc-source-gen "0.4.3.0" "fails to build" (markBroken super.ghc-source-gen);

     

       66
        
       

     

       67
        
         lucid = jailbreakForCurrentVersion super.lucid "2.11.1";

···

       60
        
       

     

       61
        
         # consequences of doctest breakage follow:

     

       62
        
       

     

       0
        
       
     

       0
        
       
     

       63
        
         ghc-source-gen = checkAgainAfter super.ghc-source-gen "0.4.3.0" "fails to build" (markBroken super.ghc-source-gen);

     

       64
        
       

     

       65
        
         lucid = jailbreakForCurrentVersion super.lucid "2.11.1";

+8 -2

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

···

       1485
        
         - Feval

     

       1486
        
         - fez-conf

     

       1487
        
         - ffeed

     

       0
        
       
     

       1488
        
         - ffunctor

     

       1489
        
         - fgl-extras-decompositions

     

       1490
        
         - fib

     
···

       2217
        
         - heterogeneous-list-literals

     

       2218
        
         - hetris

     

       2219
        
         - heukarya

     

       2220
       -
         - hevm

     

       2221
        
         - HExcel

     

       2222
        
         - hexchat

     

       2223
        
         - hexif

     
···

       2323
        
         - HLogger

     

       2324
        
         - hlongurl

     

       2325
        
         - hls-brittany-plugin

     

       0
        
       
     

       2326
        
         - hls-haddock-comments-plugin

     

       2327
        
         - hls-selection-range-plugin

     

       2328
        
         - hls-stan-plugin

     
···

       3667
        
         - OddWord

     

       3668
        
         - oden-go-packages

     

       3669
        
         - oeis2

     

       0
        
       
     

       3670
        
         - OGL

     

       3671
        
         - ogma-language-c

     

       3672
        
         - ogma-language-cocospec

     
···

       3702
        
         - open-adt

     

       3703
        
         - OpenAFP

     

       3704
        
         - openai-hs

     

       0
        
       
     

       3705
        
         - openapi3-code-generator

     

       3706
        
         - openapi-petstore

     

       3707
        
         - openapi-typed

     
···

       4269
        
         - QuickAnnotate

     

       4270
        
         - quickbooks

     

       4271
        
         - quickcheck-arbitrary-template

     

       0
        
       
     

       4272
        
         - quickcheck-property-comb

     

       4273
        
         - quickcheck-property-monad

     

       4274
        
         - quickcheck-rematch

     
···

       4895
        
         - SNet

     

       4896
        
         - snipcheck

     

       4897
        
         - snorkels

     

       0
        
       
     

       4898
        
         - snowtify

     

       4899
        
         - socket-activation

     

       4900
        
         - socketed

     
···

       5009
        
         - stm-firehose

     

       5010
        
         - stm-incremental

     

       5011
        
         - stm-promise

     

       0
        
       
     

       5012
        
         - stm-stats

     

       5013
        
         - stochastic

     

       5014
        
         - Stomp

     
···

       5426
        
         - trivia

     

       5427
        
         - tropical

     

       5428
        
         - tropical-geometry

     

       5429
       -
         - true-name

     

       5430
        
         - tsession

     

       5431
        
         - tslib

     

       5432
        
         - tsparse

     
···

       5547
        
         - unix-recursive

     

       5548
        
         - unlift

     

       5549
        
         - unlifted-list

     

       0
        
       
     

       5550
        
         - unlift-stm

     

       5551
        
         - unm-hip

     

       5552
        
         - unordered-containers-rematch

···

       1485
        
         - Feval

     

       1486
        
         - fez-conf

     

       1487
        
         - ffeed

     

       1488
       +
         - fft

     

       1489
        
         - ffunctor

     

       1490
        
         - fgl-extras-decompositions

     

       1491
        
         - fib

     
···

       2218
        
         - heterogeneous-list-literals

     

       2219
        
         - hetris

     

       2220
        
         - heukarya

     

       0
        
       
     

       2221
        
         - HExcel

     

       2222
        
         - hexchat

     

       2223
        
         - hexif

     
···

       2323
        
         - HLogger

     

       2324
        
         - hlongurl

     

       2325
        
         - hls-brittany-plugin

     

       2326
       +
         - hls-call-hierarchy-plugin

     

       2327
        
         - hls-haddock-comments-plugin

     

       2328
        
         - hls-selection-range-plugin

     

       2329
        
         - hls-stan-plugin

     
···

       3668
        
         - OddWord

     

       3669
        
         - oden-go-packages

     

       3670
        
         - oeis2

     

       3671
       +
         - OGDF

     

       3672
        
         - OGL

     

       3673
        
         - ogma-language-c

     

       3674
        
         - ogma-language-cocospec

     
···

       3704
        
         - open-adt

     

       3705
        
         - OpenAFP

     

       3706
        
         - openai-hs

     

       3707
       +
         - openapi3

     

       3708
        
         - openapi3-code-generator

     

       3709
        
         - openapi-petstore

     

       3710
        
         - openapi-typed

     
···

       4272
        
         - QuickAnnotate

     

       4273
        
         - quickbooks

     

       4274
        
         - quickcheck-arbitrary-template

     

       4275
       +
         - quickcheck-monoid-subclasses

     

       4276
        
         - quickcheck-property-comb

     

       4277
        
         - quickcheck-property-monad

     

       4278
        
         - quickcheck-rematch

     
···

       4899
        
         - SNet

     

       4900
        
         - snipcheck

     

       4901
        
         - snorkels

     

       4902
       +
         - snowchecked

     

       4903
        
         - snowtify

     

       4904
        
         - socket-activation

     

       4905
        
         - socketed

     
···

       5014
        
         - stm-firehose

     

       5015
        
         - stm-incremental

     

       5016
        
         - stm-promise

     

       5017
       +
         - stm-queue

     

       5018
        
         - stm-stats

     

       5019
        
         - stochastic

     

       5020
        
         - Stomp

     
···

       5432
        
         - trivia

     

       5433
        
         - tropical

     

       5434
        
         - tropical-geometry

     

       0
        
       
     

       5435
        
         - tsession

     

       5436
        
         - tslib

     

       5437
        
         - tsparse

     
···

       5552
        
         - unix-recursive

     

       5553
        
         - unlift

     

       5554
        
         - unlifted-list

     

       5555
       +
         - unliftio-messagebox

     

       5556
        
         - unlift-stm

     

       5557
        
         - unm-hip

     

       5558
        
         - unordered-containers-rematch

+62 -61

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

···

       1
       -
       # Stackage LTS 20.4

     

       2
        
       # This file is auto-generated by

     

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

     

       4
        
       default-package-overrides:

     
···

       15
        
         - ad-delcont ==0.3.0.0

     

       16
        
         - adjunctions ==4.4.2

     

       17
        
         - adler32 ==0.1.2.0

     

       18
       -
         - advent-of-code-api ==0.2.8.2

     

       19
        
         - aern2-mp ==0.2.11.0

     

       20
        
         - aern2-real ==0.2.11.0

     

       21
        
         - aeson ==2.0.3.0

     
···

       61
        
         - annotated-exception ==0.2.0.4

     

       62
        
         - annotated-wl-pprint ==0.7.0

     

       63
        
         - ansi-terminal ==0.11.4

     

       64
       -
         - ansi-terminal-game ==1.8.0.1

     

       65
        
         - ansi-wl-pprint ==0.6.9

     

       66
        
         - ANum ==0.2.0.2

     

       67
        
         - aos-signature ==0.1.1

     
···

       86
        
         - array-memoize ==0.6.0

     

       87
        
         - arrow-extras ==0.1.0.1

     

       88
        
         - arrows ==0.4.4.2

     

       89
       -
         - ascii ==1.2.3.0

     

       90
       -
         - ascii-case ==1.0.0.11

     

       91
       -
         - ascii-char ==1.0.0.15

     

       92
        
         - asciidiagram ==1.3.3.3

     

       93
       -
         - ascii-group ==1.0.0.13

     

       94
        
         - ascii-numbers ==1.1.0.0

     

       95
        
         - ascii-predicates ==1.0.1.0

     

       96
        
         - ascii-progress ==0.3.3.0

     
···

       136
        
         - aws-xray-client-wai ==0.1.0.2

     

       137
        
         - backtracking ==0.1.0

     

       138
        
         - bank-holidays-england ==0.2.0.8

     

       139
       -
         - barbies ==2.0.3.1

     

       140
        
         - base16 ==0.3.2.1

     

       141
        
         - base16-bytestring ==1.0.2.0

     

       142
        
         - base32 ==0.2.2.0

     
···

       171
        
         - bench-show ==0.3.2

     

       172
        
         - bencode ==0.6.1.1

     

       173
        
         - bencoding ==0.4.5.4

     

       174
       -
         - benri-hspec ==0.1.0.0

     

       175
        
         - between ==0.11.0.0

     

       176
        
         - bhoogle ==0.1.4.2

     

       177
        
         - bibtex ==0.1.0.6

     
···

       221
        
         - bm ==0.1.0.2

     

       222
        
         - bmp ==1.2.6.3

     

       223
        
         - bnb-staking-csvs ==0.2.1.0

     

       224
       -
         - BNFC ==2.9.4

     

       225
        
         - BNFC-meta ==0.6.1

     

       226
        
         - bodhi ==0.1.0

     

       227
        
         - boltzmann-samplers ==0.1.1.0

     

       228
        
         - bookkeeping ==0.4.0.1

     

       229
        
         - Boolean ==0.2.4

     

       230
        
         - boolsimplifier ==0.1.8

     

       231
       -
         - boomerang ==1.4.8

     

       232
        
         - boots ==0.2.0.1

     

       233
        
         - bordacount ==0.1.0.0

     

       234
        
         - boring ==0.2

     
···

       267
        
         - bytes ==0.17.2

     

       268
        
         - byteset ==0.1.1.0

     

       269
        
         - byteslice ==0.2.7.0

     

       270
       -
         - bytesmith ==0.3.9.0

     

       271
        
         - bytestring-builder ==0.10.8.2.0

     

       272
        
         - bytestring-conversion ==0.3.2

     

       273
        
         - bytestring-lexing ==0.5.0.9

     
···

       341
        
         - check-email ==1.0.2

     

       342
        
         - checkers ==0.6.0

     

       343
        
         - checksum ==0.0

     

       344
       -
         - chimera ==0.3.2.0

     

       345
        
         - choice ==0.2.2

     

       346
        
         - chronologique ==0.3.1.3

     

       347
        
         - chunked-data ==0.3.1

     
···

       372
        
         - code-page ==0.2.1

     

       373
        
         - cointracking-imports ==0.1.0.2

     

       374
        
         - collect-errors ==0.1.5.0

     

       0
        
       
     

       375
        
         - Color ==0.3.3

     

       376
        
         - colorful-monoids ==0.2.1.3

     

       377
        
         - colorize-haskell ==1.0.1

     
···

       394
        
         - componentm ==0.0.0.2

     

       395
        
         - componentm-devel ==0.0.0.2

     

       396
        
         - composable-associations ==0.1.0.0

     

       397
       -
         - composite-base ==0.8.2.0

     

       398
       -
         - composite-binary ==0.8.2.0

     

       399
       -
         - composite-ekg ==0.8.2.0

     

       400
        
         - composite-tuple ==0.1.2.0

     

       401
        
         - composite-xstep ==0.1.0.0

     

       402
        
         - composition ==1.0.2.2

     
···

       529
        
         - data-dword ==0.3.2.1

     

       530
        
         - data-endian ==0.1.1

     

       531
        
         - data-fix ==0.3.2

     

       532
       -
         - data-forest ==0.1.0.9

     

       533
        
         - data-functor-logistic ==0.0

     

       534
        
         - data-has ==0.4.0.0

     

       535
        
         - data-hash ==0.2.0.1

     
···

       567
        
         - dejafu ==2.4.0.4

     

       568
        
         - dense-linear-algebra ==0.1.0.0

     

       569
        
         - dependent-map ==0.4.0.0

     

       570
       -
         - dependent-sum ==0.7.1.0

     

       571
        
         - dependent-sum-template ==0.1.1.1

     

       572
        
         - depq ==0.4.2

     

       573
        
         - deque ==0.4.4

     
···

       597
        
         - dictionary-sharing ==0.1.0.0

     

       598
        
         - di-df1 ==1.2.1

     

       599
        
         - Diff ==0.4.1

     

       600
       -
         - digest ==0.0.1.3

     

       601
        
         - digits ==0.3.1

     

       602
        
         - di-handle ==1.0.1

     

       603
        
         - dimensional ==1.5

     
···

       616
        
         - dl-fedora ==0.9.3

     

       617
        
         - dlist ==1.0

     

       618
        
         - dlist-instances ==0.1.1.1

     

       619
       -
         - dlist-nonempty ==0.1.1

     

       620
        
         - dns ==4.1.0

     

       621
        
         - docker ==0.7.0.1

     

       622
        
         - dockerfile ==0.2.0

     
···

       624
        
         - doctemplates ==0.10.0.2

     

       625
        
         - doctest ==0.20.1

     

       626
        
         - doctest-discover ==0.2.0.0

     

       627
       -
         - doctest-driver-gen ==0.3.0.5

     

       628
        
         - doctest-exitcode-stdio ==0.0

     

       629
        
         - doctest-lib ==0.1

     

       630
       -
         - doctest-parallel ==0.2.5

     

       631
        
         - doldol ==0.4.1.2

     

       632
        
         - do-list ==1.0.1

     

       633
        
         - domain ==0.1.1.4

     
···

       637
        
         - domain-optics ==0.1.0.3

     

       638
        
         - do-notation ==0.1.0.2

     

       639
        
         - dot ==0.3

     

       640
       -
         - dotenv ==0.9.0.3

     

       641
        
         - dotgen ==0.4.3

     

       642
        
         - dotnet-timespan ==0.0.1.0

     

       643
       -
         - double-conversion ==2.0.4.1

     

       644
        
         - download ==0.3.2.7

     

       645
        
         - download-curl ==0.1.4

     

       646
        
         - DPutils ==0.1.1.0

     
···

       651
        
         - dual ==0.1.1.1

     

       652
        
         - dual-tree ==0.2.3.1

     

       653
        
         - dublincore-xml-conduit ==0.1.0.2

     

       654
       -
         - dunai ==0.9.1

     

       655
        
         - duration ==0.2.0.0

     

       656
        
         - dvorak ==0.1.0.0

     

       657
        
         - dynamic-state ==0.3.1

     
···

       714
        
         - errors-ext ==0.4.2

     

       715
        
         - ersatz ==0.4.13

     

       716
        
         - esqueleto ==3.5.8.1

     

       717
       -
         - essence-of-live-coding ==0.2.6

     

       718
       -
         - essence-of-live-coding-gloss ==0.2.6

     

       719
       -
         - essence-of-live-coding-pulse ==0.2.6

     

       720
       -
         - essence-of-live-coding-quickcheck ==0.2.6

     

       721
       -
         - essence-of-live-coding-warp ==0.2.6

     

       722
        
         - event-list ==0.1.2

     

       723
        
         - eventstore ==1.4.2

     

       724
        
         - every ==0.0.1

     

       725
        
         - evm-opcodes ==0.1.2

     

       726
        
         - exact-combinatorics ==0.2.0.11

     

       727
        
         - exact-pi ==0.5.0.2

     

       728
       -
         - exception-hierarchy ==0.1.0.7

     

       729
        
         - exception-mtl ==0.4.0.1

     

       730
        
         - exception-transformers ==0.4.0.11

     

       731
        
         - executable-hash ==0.2.0.4

     
···

       789
        
         - fitspec ==0.4.10

     

       790
        
         - fixed ==0.3

     

       791
        
         - fixed-length ==0.2.3.1

     

       792
       -
         - fixed-vector ==1.2.1.0

     

       793
        
         - fixed-vector-hetero ==0.6.1.1

     

       794
       -
         - fix-whitespace ==0.0.10

     

       795
        
         - flac ==0.2.0

     

       796
        
         - flac-picture ==0.1.2

     

       797
        
         - flags-applicative ==0.1.0.3

     
···

       1031
        
         - haskell-gi ==0.26.2

     

       1032
        
         - haskell-gi-base ==0.26.3

     

       1033
        
         - haskell-gi-overloading ==1.0

     

       1034
       -
         - haskell-lexer ==1.1

     

       1035
        
         - HaskellNet ==0.6.0.1

     

       1036
        
         - HaskellNet-SSL ==0.3.4.4

     

       1037
        
         - haskell-src ==1.0.4

     
···

       1069
        
         - heatshrink ==0.1.0.0

     

       1070
        
         - hebrew-time ==0.1.2

     

       1071
        
         - hedgehog ==1.1.2

     

       1072
       -
         - hedgehog-classes ==0.2.5.3

     

       1073
        
         - hedgehog-corpus ==0.2.0

     

       1074
        
         - hedgehog-fakedata ==0.0.1.5

     

       1075
        
         - hedgehog-fn ==1.0

     
···

       1131
        
         - hourglass ==0.2.12

     

       1132
        
         - hourglass-orphans ==0.1.0.0

     

       1133
        
         - hp2pretty ==0.10

     

       1134
       -
         - hpack ==0.35.0

     

       1135
        
         - hpack-dhall ==0.5.7

     

       1136
        
         - hpc-codecov ==0.3.0.0

     

       1137
        
         - hpc-lcov ==1.1.0

     
···

       1169
        
         - hslua-packaging ==2.2.1

     

       1170
        
         - hsndfile ==0.8.0

     

       1171
        
         - hsndfile-vector ==0.5.2

     

       1172
       -
         - HsOpenSSL ==0.11.7.2

     

       1173
        
         - HsOpenSSL-x509-system ==0.1.0.4

     

       1174
        
         - hsp ==0.10.0

     

       1175
        
         - hspec ==2.9.7

     
···

       1258
        
         - hw-int ==0.0.2.0

     

       1259
        
         - hw-ip ==2.4.2.1

     

       1260
        
         - hw-json ==1.3.2.3

     

       1261
       -
         - hw-json-simd ==0.1.1.1

     

       1262
        
         - hw-json-simple-cursor ==0.1.1.1

     

       1263
        
         - hw-json-standard-cursor ==0.2.3.2

     

       1264
        
         - hwk ==0.6

     
···

       1270
        
         - hw-prim ==0.6.3.2

     

       1271
        
         - hw-rankselect ==0.13.4.1

     

       1272
        
         - hw-rankselect-base ==0.3.4.1

     

       1273
       -
         - hw-simd ==0.1.2.1

     

       1274
        
         - hw-streams ==0.0.1.0

     

       1275
        
         - hw-string-parse ==0.0.0.5

     

       1276
        
         - hw-succinct ==0.1.0.1

     
···

       1531
        
         - markov-chain ==0.0.3.4

     

       1532
        
         - markov-chain-usage-model ==0.0.0

     

       1533
        
         - mason ==0.2.5

     

       1534
       -
         - massiv ==1.0.2.0

     

       1535
        
         - massiv-io ==1.0.0.1

     

       1536
        
         - massiv-persist ==1.0.0.3

     

       1537
        
         - massiv-serialise ==1.0.0.2

     
···

       1571
        
         - microaeson ==0.1.0.1

     

       1572
        
         - microlens ==0.4.12.0

     

       1573
        
         - microlens-aeson ==2.5.0

     

       1574
       -
         - microlens-contra ==0.1.0.2

     

       1575
        
         - microlens-ghc ==0.4.13.2

     

       1576
       -
         - microlens-mtl ==0.2.0.2

     

       1577
        
         - microlens-platform ==0.4.2.1

     

       1578
        
         - microlens-process ==0.2.0.2

     

       1579
       -
         - microlens-th ==0.4.3.10

     

       1580
        
         - microspec ==0.2.1.3

     

       1581
        
         - microstache ==1.0.2.2

     

       1582
        
         - midair ==0.2.0.1

     
···

       1644
        
         - monad-time ==0.3.1.0

     

       1645
        
         - mongoDB ==2.7.1.2

     

       1646
        
         - monoidal-containers ==0.6.3.0

     

       1647
       -
         - monoid-extras ==0.6.1

     

       1648
        
         - monoid-subclasses ==1.1.3

     

       1649
        
         - monoid-transformer ==0.0.4

     

       1650
        
         - monomer ==1.5.0.0

     
···

       1726
        
         - network-simple ==0.4.5

     

       1727
        
         - network-simple-tls ==0.4

     

       1728
        
         - network-transport ==0.5.6

     

       1729
       -
         - network-uri ==2.6.4.1

     

       1730
        
         - network-wait ==0.2.0.0

     

       1731
        
         - newtype ==0.2.2.0

     

       1732
        
         - newtype-generics ==0.6.2

     
···

       1762
        
         - NumInstances ==1.4

     

       1763
        
         - numtype-dk ==0.5.0.3

     

       1764
        
         - nuxeo ==0.3.2

     

       1765
       -
         - nvim-hs ==2.3.1.0

     

       1766
        
         - nvim-hs-contrib ==2.0.0.1

     

       1767
       -
         - nvim-hs-ghcid ==2.0.0.0

     

       1768
        
         - oauthenticated ==0.3.0.0

     

       1769
        
         - ObjectName ==1.1.0.2

     

       1770
        
         - oblivious-transfer ==0.1.0

     
···

       1781
        
         - oo-prototypes ==0.1.0.0

     

       1782
        
         - opaleye ==0.9.6.1

     

       1783
        
         - OpenAL ==1.7.0.5

     

       1784
       -
         - openapi3 ==3.2.2

     

       1785
        
         - open-browser ==0.2.1.0

     

       1786
        
         - openexr-write ==0.1.0.2

     

       1787
        
         - OpenGL ==3.0.3.0

     
···

       1939
        
         - polysemy-fs ==0.1.0.0

     

       1940
        
         - polysemy-kvstore ==0.1.3.0

     

       1941
        
         - polysemy-methodology ==0.2.2.0

     

       1942
       -
         - polysemy-plugin ==0.4.3.1

     

       1943
        
         - polysemy-several ==0.1.1.0

     

       1944
        
         - polysemy-webserver ==0.2.1.1

     

       1945
        
         - polysemy-zoo ==0.8.1.0

     
···

       2098
        
         - record-dot-preprocessor ==0.2.15

     

       2099
        
         - record-hasfield ==1.0

     

       2100
        
         - rec-smallarray ==0.1.0.0

     

       2101
       -
         - recursion-schemes ==5.2.2.2

     

       2102
        
         - recv ==0.0.0

     

       2103
        
         - redact ==0.4.0.0

     

       2104
        
         - reddit-scrape ==0.0.1

     
···

       2279
        
         - servant-multipart ==0.12.1

     

       2280
        
         - servant-multipart-api ==0.12.1

     

       2281
        
         - servant-multipart-client ==0.12.1

     

       2282
       -
         - servant-openapi3 ==2.0.1.5

     

       2283
        
         - servant-pipes ==0.15.3

     

       2284
        
         - servant-rate-limit ==0.2.0.0

     

       2285
        
         - servant-rawm ==1.0.0.0

     
···

       2352
        
         - skein ==1.0.9.4

     

       2353
        
         - skews ==0.1.0.3

     

       2354
        
         - skip-var ==0.1.1.0

     

       2355
       -
         - skylighting ==0.13.1.2

     

       2356
       -
         - skylighting-core ==0.13.1.2

     

       2357
        
         - skylighting-format-ansi ==0.1

     

       2358
        
         - skylighting-format-blaze-html ==0.1.1

     

       0
        
       
     

       2359
        
         - skylighting-format-latex ==0.1

     

       2360
        
         - slack-progressbar ==0.1.0.1

     

       2361
        
         - slave-thread ==1.1.0.2

     
···

       2366
        
         - socket ==0.8.3.0

     

       2367
        
         - socks ==0.6.1

     

       2368
        
         - solana-staking-csvs ==0.1.2.0

     

       2369
       -
         - some ==1.0.3

     

       2370
        
         - some-dict-of ==0.1.0.2

     

       2371
        
         - sop-core ==0.5.0.2

     

       2372
        
         - sort ==1.0.0.0

     
···

       2459
        
         - string-combinators ==0.6.0.5

     

       2460
        
         - string-conv ==0.2.0

     

       2461
        
         - string-conversions ==0.4.0.1

     

       2462
       -
         - string-interpolate ==0.3.1.2

     

       2463
        
         - stringprep ==1.0.0

     

       2464
        
         - string-qq ==0.0.4

     

       2465
        
         - string-random ==0.1.4.3

     
···

       2526
        
         - tar ==0.5.1.1

     

       2527
        
         - tar-conduit ==0.3.2

     

       2528
        
         - tardis ==0.4.4.0

     

       2529
       -
         - tasty ==1.4.2.3

     

       2530
        
         - tasty-ant-xml ==1.1.8

     

       2531
        
         - tasty-autocollect ==0.3.2.0

     

       2532
        
         - tasty-bench ==0.3.2

     
···

       2559
        
         - tcp-streams ==1.0.1.1

     

       2560
        
         - tdigest ==0.2.1.1

     

       2561
        
         - teardown ==0.5.0.1

     

       2562
       -
         - telegram-bot-simple ==0.6

     

       2563
        
         - template ==0.2.0.10

     

       2564
        
         - template-haskell-compat-v0208 ==0.1.9.1

     

       2565
        
         - temporary ==1.3

     
···

       2587
        
         - text-ansi ==0.2.1

     

       2588
        
         - text-binary ==0.2.1.1

     

       2589
        
         - text-builder ==0.6.7

     

       2590
       -
         - text-builder-dev ==0.3.3

     

       2591
        
         - text-conversions ==0.3.1.1

     

       2592
        
         - text-icu ==0.8.0.2

     

       2593
        
         - text-latin1 ==0.3.1

     
···

       2601
        
         - text-rope ==0.2

     

       2602
        
         - text-short ==0.1.5

     

       2603
        
         - text-show ==3.10

     

       2604
       -
         - text-show-instances ==3.9.2

     

       2605
        
         - text-zipper ==0.12

     

       2606
        
         - tfp ==1.0.2

     

       2607
        
         - tf-random ==0.5

     
···

       2822
        
         - vector-builder ==0.3.8.4

     

       2823
        
         - vector-bytes-instances ==0.1.1

     

       2824
        
         - vector-circular ==0.1.4

     

       2825
       -
         - vector-extras ==0.2.7.1

     

       2826
        
         - vector-instances ==3.4

     

       2827
        
         - vector-mmap ==0.0.3

     

       2828
        
         - vector-rotcev ==0.1.0.1

     
···

       2895
        
         - webrtc-vad ==0.1.0.3

     

       2896
        
         - websockets ==0.12.7.3

     

       2897
        
         - weigh ==0.0.16

     

       2898
       -
         - wide-word ==0.1.3.0

     

       2899
        
         - Win32 ==2.12.0.1

     

       2900
        
         - Win32-notify ==0.3.0.3

     

       2901
        
         - windns ==0.1.0.1

···

       1
       +
       # Stackage LTS 20.5

     

       2
        
       # This file is auto-generated by

     

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

     

       4
        
       default-package-overrides:

     
···

       15
        
         - ad-delcont ==0.3.0.0

     

       16
        
         - adjunctions ==4.4.2

     

       17
        
         - adler32 ==0.1.2.0

     

       18
       +
         - advent-of-code-api ==0.2.8.4

     

       19
        
         - aern2-mp ==0.2.11.0

     

       20
        
         - aern2-real ==0.2.11.0

     

       21
        
         - aeson ==2.0.3.0

     
···

       61
        
         - annotated-exception ==0.2.0.4

     

       62
        
         - annotated-wl-pprint ==0.7.0

     

       63
        
         - ansi-terminal ==0.11.4

     

       64
       +
         - ansi-terminal-game ==1.8.1.0

     

       65
        
         - ansi-wl-pprint ==0.6.9

     

       66
        
         - ANum ==0.2.0.2

     

       67
        
         - aos-signature ==0.1.1

     
···

       86
        
         - array-memoize ==0.6.0

     

       87
        
         - arrow-extras ==0.1.0.1

     

       88
        
         - arrows ==0.4.4.2

     

       89
       +
         - ascii ==1.2.4.0

     

       90
       +
         - ascii-case ==1.0.1.1

     

       91
       +
         - ascii-char ==1.0.0.16

     

       92
        
         - asciidiagram ==1.3.3.3

     

       93
       +
         - ascii-group ==1.0.0.14

     

       94
        
         - ascii-numbers ==1.1.0.0

     

       95
        
         - ascii-predicates ==1.0.1.0

     

       96
        
         - ascii-progress ==0.3.3.0

     
···

       136
        
         - aws-xray-client-wai ==0.1.0.2

     

       137
        
         - backtracking ==0.1.0

     

       138
        
         - bank-holidays-england ==0.2.0.8

     

       139
       +
         - barbies ==2.0.4.0

     

       140
        
         - base16 ==0.3.2.1

     

       141
        
         - base16-bytestring ==1.0.2.0

     

       142
        
         - base32 ==0.2.2.0

     
···

       171
        
         - bench-show ==0.3.2

     

       172
        
         - bencode ==0.6.1.1

     

       173
        
         - bencoding ==0.4.5.4

     

       174
       +
         - benri-hspec ==0.1.0.1

     

       175
        
         - between ==0.11.0.0

     

       176
        
         - bhoogle ==0.1.4.2

     

       177
        
         - bibtex ==0.1.0.6

     
···

       221
        
         - bm ==0.1.0.2

     

       222
        
         - bmp ==1.2.6.3

     

       223
        
         - bnb-staking-csvs ==0.2.1.0

     

       224
       +
         - BNFC ==2.9.4.1

     

       225
        
         - BNFC-meta ==0.6.1

     

       226
        
         - bodhi ==0.1.0

     

       227
        
         - boltzmann-samplers ==0.1.1.0

     

       228
        
         - bookkeeping ==0.4.0.1

     

       229
        
         - Boolean ==0.2.4

     

       230
        
         - boolsimplifier ==0.1.8

     

       231
       +
         - boomerang ==1.4.8.1

     

       232
        
         - boots ==0.2.0.1

     

       233
        
         - bordacount ==0.1.0.0

     

       234
        
         - boring ==0.2

     
···

       267
        
         - bytes ==0.17.2

     

       268
        
         - byteset ==0.1.1.0

     

       269
        
         - byteslice ==0.2.7.0

     

       270
       +
         - bytesmith ==0.3.9.1

     

       271
        
         - bytestring-builder ==0.10.8.2.0

     

       272
        
         - bytestring-conversion ==0.3.2

     

       273
        
         - bytestring-lexing ==0.5.0.9

     
···

       341
        
         - check-email ==1.0.2

     

       342
        
         - checkers ==0.6.0

     

       343
        
         - checksum ==0.0

     

       344
       +
         - chimera ==0.3.3.0

     

       345
        
         - choice ==0.2.2

     

       346
        
         - chronologique ==0.3.1.3

     

       347
        
         - chunked-data ==0.3.1

     
···

       372
        
         - code-page ==0.2.1

     

       373
        
         - cointracking-imports ==0.1.0.2

     

       374
        
         - collect-errors ==0.1.5.0

     

       375
       +
         - co-log-core ==0.3.2.0

     

       376
        
         - Color ==0.3.3

     

       377
        
         - colorful-monoids ==0.2.1.3

     

       378
        
         - colorize-haskell ==1.0.1

     
···

       395
        
         - componentm ==0.0.0.2

     

       396
        
         - componentm-devel ==0.0.0.2

     

       397
        
         - composable-associations ==0.1.0.0

     

       398
       +
         - composite-base ==0.8.2.1

     

       399
       +
         - composite-binary ==0.8.2.1

     

       400
       +
         - composite-ekg ==0.8.2.1

     

       401
        
         - composite-tuple ==0.1.2.0

     

       402
        
         - composite-xstep ==0.1.0.0

     

       403
        
         - composition ==1.0.2.2

     
···

       530
        
         - data-dword ==0.3.2.1

     

       531
        
         - data-endian ==0.1.1

     

       532
        
         - data-fix ==0.3.2

     

       533
       +
         - data-forest ==0.1.0.10

     

       534
        
         - data-functor-logistic ==0.0

     

       535
        
         - data-has ==0.4.0.0

     

       536
        
         - data-hash ==0.2.0.1

     
···

       568
        
         - dejafu ==2.4.0.4

     

       569
        
         - dense-linear-algebra ==0.1.0.0

     

       570
        
         - dependent-map ==0.4.0.0

     

       571
       +
         - dependent-sum ==0.7.2.0

     

       572
        
         - dependent-sum-template ==0.1.1.1

     

       573
        
         - depq ==0.4.2

     

       574
        
         - deque ==0.4.4

     
···

       598
        
         - dictionary-sharing ==0.1.0.0

     

       599
        
         - di-df1 ==1.2.1

     

       600
        
         - Diff ==0.4.1

     

       601
       +
         - digest ==0.0.1.4

     

       602
        
         - digits ==0.3.1

     

       603
        
         - di-handle ==1.0.1

     

       604
        
         - dimensional ==1.5

     
···

       617
        
         - dl-fedora ==0.9.3

     

       618
        
         - dlist ==1.0

     

       619
        
         - dlist-instances ==0.1.1.1

     

       620
       +
         - dlist-nonempty ==0.1.2

     

       621
        
         - dns ==4.1.0

     

       622
        
         - docker ==0.7.0.1

     

       623
        
         - dockerfile ==0.2.0

     
···

       625
        
         - doctemplates ==0.10.0.2

     

       626
        
         - doctest ==0.20.1

     

       627
        
         - doctest-discover ==0.2.0.0

     

       628
       +
         - doctest-driver-gen ==0.3.0.6

     

       629
        
         - doctest-exitcode-stdio ==0.0

     

       630
        
         - doctest-lib ==0.1

     

       631
       +
         - doctest-parallel ==0.2.6

     

       632
        
         - doldol ==0.4.1.2

     

       633
        
         - do-list ==1.0.1

     

       634
        
         - domain ==0.1.1.4

     
···

       638
        
         - domain-optics ==0.1.0.3

     

       639
        
         - do-notation ==0.1.0.2

     

       640
        
         - dot ==0.3

     

       0
        
       
     

       641
        
         - dotgen ==0.4.3

     

       642
        
         - dotnet-timespan ==0.0.1.0

     

       643
       +
         - double-conversion ==2.0.4.2

     

       644
        
         - download ==0.3.2.7

     

       645
        
         - download-curl ==0.1.4

     

       646
        
         - DPutils ==0.1.1.0

     
···

       651
        
         - dual ==0.1.1.1

     

       652
        
         - dual-tree ==0.2.3.1

     

       653
        
         - dublincore-xml-conduit ==0.1.0.2

     

       654
       +
         - dunai ==0.9.2

     

       655
        
         - duration ==0.2.0.0

     

       656
        
         - dvorak ==0.1.0.0

     

       657
        
         - dynamic-state ==0.3.1

     
···

       714
        
         - errors-ext ==0.4.2

     

       715
        
         - ersatz ==0.4.13

     

       716
        
         - esqueleto ==3.5.8.1

     

       717
       +
         - essence-of-live-coding ==0.2.7

     

       718
       +
         - essence-of-live-coding-gloss ==0.2.7

     

       719
       +
         - essence-of-live-coding-pulse ==0.2.7

     

       720
       +
         - essence-of-live-coding-quickcheck ==0.2.7

     

       721
       +
         - essence-of-live-coding-warp ==0.2.7

     

       722
        
         - event-list ==0.1.2

     

       723
        
         - eventstore ==1.4.2

     

       724
        
         - every ==0.0.1

     

       725
        
         - evm-opcodes ==0.1.2

     

       726
        
         - exact-combinatorics ==0.2.0.11

     

       727
        
         - exact-pi ==0.5.0.2

     

       728
       +
         - exception-hierarchy ==0.1.0.8

     

       729
        
         - exception-mtl ==0.4.0.1

     

       730
        
         - exception-transformers ==0.4.0.11

     

       731
        
         - executable-hash ==0.2.0.4

     
···

       789
        
         - fitspec ==0.4.10

     

       790
        
         - fixed ==0.3

     

       791
        
         - fixed-length ==0.2.3.1

     

       792
       +
         - fixed-vector ==1.2.2.1

     

       793
        
         - fixed-vector-hetero ==0.6.1.1

     

       794
       +
         - fix-whitespace ==0.0.11

     

       795
        
         - flac ==0.2.0

     

       796
        
         - flac-picture ==0.1.2

     

       797
        
         - flags-applicative ==0.1.0.3

     
···

       1031
        
         - haskell-gi ==0.26.2

     

       1032
        
         - haskell-gi-base ==0.26.3

     

       1033
        
         - haskell-gi-overloading ==1.0

     

       1034
       +
         - haskell-lexer ==1.1.1

     

       1035
        
         - HaskellNet ==0.6.0.1

     

       1036
        
         - HaskellNet-SSL ==0.3.4.4

     

       1037
        
         - haskell-src ==1.0.4

     
···

       1069
        
         - heatshrink ==0.1.0.0

     

       1070
        
         - hebrew-time ==0.1.2

     

       1071
        
         - hedgehog ==1.1.2

     

       1072
       +
         - hedgehog-classes ==0.2.5.4

     

       1073
        
         - hedgehog-corpus ==0.2.0

     

       1074
        
         - hedgehog-fakedata ==0.0.1.5

     

       1075
        
         - hedgehog-fn ==1.0

     
···

       1131
        
         - hourglass ==0.2.12

     

       1132
        
         - hourglass-orphans ==0.1.0.0

     

       1133
        
         - hp2pretty ==0.10

     

       1134
       +
         - hpack ==0.35.1

     

       1135
        
         - hpack-dhall ==0.5.7

     

       1136
        
         - hpc-codecov ==0.3.0.0

     

       1137
        
         - hpc-lcov ==1.1.0

     
···

       1169
        
         - hslua-packaging ==2.2.1

     

       1170
        
         - hsndfile ==0.8.0

     

       1171
        
         - hsndfile-vector ==0.5.2

     

       1172
       +
         - HsOpenSSL ==0.11.7.4

     

       1173
        
         - HsOpenSSL-x509-system ==0.1.0.4

     

       1174
        
         - hsp ==0.10.0

     

       1175
        
         - hspec ==2.9.7

     
···

       1258
        
         - hw-int ==0.0.2.0

     

       1259
        
         - hw-ip ==2.4.2.1

     

       1260
        
         - hw-json ==1.3.2.3

     

       1261
       +
         - hw-json-simd ==0.1.1.2

     

       1262
        
         - hw-json-simple-cursor ==0.1.1.1

     

       1263
        
         - hw-json-standard-cursor ==0.2.3.2

     

       1264
        
         - hwk ==0.6

     
···

       1270
        
         - hw-prim ==0.6.3.2

     

       1271
        
         - hw-rankselect ==0.13.4.1

     

       1272
        
         - hw-rankselect-base ==0.3.4.1

     

       1273
       +
         - hw-simd ==0.1.2.2

     

       1274
        
         - hw-streams ==0.0.1.0

     

       1275
        
         - hw-string-parse ==0.0.0.5

     

       1276
        
         - hw-succinct ==0.1.0.1

     
···

       1531
        
         - markov-chain ==0.0.3.4

     

       1532
        
         - markov-chain-usage-model ==0.0.0

     

       1533
        
         - mason ==0.2.5

     

       1534
       +
         - massiv ==1.0.3.0

     

       1535
        
         - massiv-io ==1.0.0.1

     

       1536
        
         - massiv-persist ==1.0.0.3

     

       1537
        
         - massiv-serialise ==1.0.0.2

     
···

       1571
        
         - microaeson ==0.1.0.1

     

       1572
        
         - microlens ==0.4.12.0

     

       1573
        
         - microlens-aeson ==2.5.0

     

       1574
       +
         - microlens-contra ==0.1.0.3

     

       1575
        
         - microlens-ghc ==0.4.13.2

     

       1576
       +
         - microlens-mtl ==0.2.0.3

     

       1577
        
         - microlens-platform ==0.4.2.1

     

       1578
        
         - microlens-process ==0.2.0.2

     

       1579
       +
         - microlens-th ==0.4.3.11

     

       1580
        
         - microspec ==0.2.1.3

     

       1581
        
         - microstache ==1.0.2.2

     

       1582
        
         - midair ==0.2.0.1

     
···

       1644
        
         - monad-time ==0.3.1.0

     

       1645
        
         - mongoDB ==2.7.1.2

     

       1646
        
         - monoidal-containers ==0.6.3.0

     

       1647
       +
         - monoid-extras ==0.6.2

     

       1648
        
         - monoid-subclasses ==1.1.3

     

       1649
        
         - monoid-transformer ==0.0.4

     

       1650
        
         - monomer ==1.5.0.0

     
···

       1726
        
         - network-simple ==0.4.5

     

       1727
        
         - network-simple-tls ==0.4

     

       1728
        
         - network-transport ==0.5.6

     

       1729
       +
         - network-uri ==2.6.4.2

     

       1730
        
         - network-wait ==0.2.0.0

     

       1731
        
         - newtype ==0.2.2.0

     

       1732
        
         - newtype-generics ==0.6.2

     
···

       1762
        
         - NumInstances ==1.4

     

       1763
        
         - numtype-dk ==0.5.0.3

     

       1764
        
         - nuxeo ==0.3.2

     

       1765
       +
         - nvim-hs ==2.3.2.0

     

       1766
        
         - nvim-hs-contrib ==2.0.0.1

     

       1767
       +
         - nvim-hs-ghcid ==2.0.1.0

     

       1768
        
         - oauthenticated ==0.3.0.0

     

       1769
        
         - ObjectName ==1.1.0.2

     

       1770
        
         - oblivious-transfer ==0.1.0

     
···

       1781
        
         - oo-prototypes ==0.1.0.0

     

       1782
        
         - opaleye ==0.9.6.1

     

       1783
        
         - OpenAL ==1.7.0.5

     

       1784
       +
         - openapi3 ==3.2.3

     

       1785
        
         - open-browser ==0.2.1.0

     

       1786
        
         - openexr-write ==0.1.0.2

     

       1787
        
         - OpenGL ==3.0.3.0

     
···

       1939
        
         - polysemy-fs ==0.1.0.0

     

       1940
        
         - polysemy-kvstore ==0.1.3.0

     

       1941
        
         - polysemy-methodology ==0.2.2.0

     

       1942
       +
         - polysemy-plugin ==0.4.4.0

     

       1943
        
         - polysemy-several ==0.1.1.0

     

       1944
        
         - polysemy-webserver ==0.2.1.1

     

       1945
        
         - polysemy-zoo ==0.8.1.0

     
···

       2098
        
         - record-dot-preprocessor ==0.2.15

     

       2099
        
         - record-hasfield ==1.0

     

       2100
        
         - rec-smallarray ==0.1.0.0

     

       2101
       +
         - recursion-schemes ==5.2.2.3

     

       2102
        
         - recv ==0.0.0

     

       2103
        
         - redact ==0.4.0.0

     

       2104
        
         - reddit-scrape ==0.0.1

     
···

       2279
        
         - servant-multipart ==0.12.1

     

       2280
        
         - servant-multipart-api ==0.12.1

     

       2281
        
         - servant-multipart-client ==0.12.1

     

       2282
       +
         - servant-openapi3 ==2.0.1.6

     

       2283
        
         - servant-pipes ==0.15.3

     

       2284
        
         - servant-rate-limit ==0.2.0.0

     

       2285
        
         - servant-rawm ==1.0.0.0

     
···

       2352
        
         - skein ==1.0.9.4

     

       2353
        
         - skews ==0.1.0.3

     

       2354
        
         - skip-var ==0.1.1.0

     

       2355
       +
         - skylighting ==0.13.2

     

       2356
       +
         - skylighting-core ==0.13.2

     

       2357
        
         - skylighting-format-ansi ==0.1

     

       2358
        
         - skylighting-format-blaze-html ==0.1.1

     

       2359
       +
         - skylighting-format-context ==0.1.0.1

     

       2360
        
         - skylighting-format-latex ==0.1

     

       2361
        
         - slack-progressbar ==0.1.0.1

     

       2362
        
         - slave-thread ==1.1.0.2

     
···

       2367
        
         - socket ==0.8.3.0

     

       2368
        
         - socks ==0.6.1

     

       2369
        
         - solana-staking-csvs ==0.1.2.0

     

       2370
       +
         - some ==1.0.4.1

     

       2371
        
         - some-dict-of ==0.1.0.2

     

       2372
        
         - sop-core ==0.5.0.2

     

       2373
        
         - sort ==1.0.0.0

     
···

       2460
        
         - string-combinators ==0.6.0.5

     

       2461
        
         - string-conv ==0.2.0

     

       2462
        
         - string-conversions ==0.4.0.1

     

       2463
       +
         - string-interpolate ==0.3.2.0

     

       2464
        
         - stringprep ==1.0.0

     

       2465
        
         - string-qq ==0.0.4

     

       2466
        
         - string-random ==0.1.4.3

     
···

       2527
        
         - tar ==0.5.1.1

     

       2528
        
         - tar-conduit ==0.3.2

     

       2529
        
         - tardis ==0.4.4.0

     

       2530
       +
         - tasty ==1.4.3

     

       2531
        
         - tasty-ant-xml ==1.1.8

     

       2532
        
         - tasty-autocollect ==0.3.2.0

     

       2533
        
         - tasty-bench ==0.3.2

     
···

       2560
        
         - tcp-streams ==1.0.1.1

     

       2561
        
         - tdigest ==0.2.1.1

     

       2562
        
         - teardown ==0.5.0.1

     

       2563
       +
         - telegram-bot-simple ==0.6.1

     

       2564
        
         - template ==0.2.0.10

     

       2565
        
         - template-haskell-compat-v0208 ==0.1.9.1

     

       2566
        
         - temporary ==1.3

     
···

       2588
        
         - text-ansi ==0.2.1

     

       2589
        
         - text-binary ==0.2.1.1

     

       2590
        
         - text-builder ==0.6.7

     

       2591
       +
         - text-builder-dev ==0.3.3.2

     

       2592
        
         - text-conversions ==0.3.1.1

     

       2593
        
         - text-icu ==0.8.0.2

     

       2594
        
         - text-latin1 ==0.3.1

     
···

       2602
        
         - text-rope ==0.2

     

       2603
        
         - text-short ==0.1.5

     

       2604
        
         - text-show ==3.10

     

       2605
       +
         - text-show-instances ==3.9.3

     

       2606
        
         - text-zipper ==0.12

     

       2607
        
         - tfp ==1.0.2

     

       2608
        
         - tf-random ==0.5

     
···

       2823
        
         - vector-builder ==0.3.8.4

     

       2824
        
         - vector-bytes-instances ==0.1.1

     

       2825
        
         - vector-circular ==0.1.4

     

       2826
       +
         - vector-extras ==0.2.8

     

       2827
        
         - vector-instances ==3.4

     

       2828
        
         - vector-mmap ==0.0.3

     

       2829
        
         - vector-rotcev ==0.1.0.1

     
···

       2896
        
         - webrtc-vad ==0.1.0.3

     

       2897
        
         - websockets ==0.12.7.3

     

       2898
        
         - weigh ==0.0.16

     

       2899
       +
         - wide-word ==0.1.4.0

     

       2900
        
         - Win32 ==2.12.0.1

     

       2901
        
         - Win32-notify ==0.3.0.3

     

       2902
        
         - windns ==0.1.0.1

+12 -5

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

···

       239
        
        - JsContracts

     

       240
        
        - JsonGrammar

     

       241
        
        - JuPyTer-notebook

     

       0
        
       
     

       242
        
        - JunkDB-driver-gdbm

     

       243
        
        - JunkDB-driver-hashtables

     

       244
        
        - KiCS

     
···

       694
        
        - audiovisual

     

       695
        
        - aura

     

       696
        
        - authoring

     

       0
        
       
     

       697
        
        - automata

     

       698
        
        - autonix-deps-kf5

     

       699
        
        - avers

     
···

       1357
        
        - essence-of-live-coding-PortMidi

     

       1358
        
        - essence-of-live-coding-gloss

     

       1359
        
        - essence-of-live-coding-gloss-example

     

       1360
       -
        - essence-of-live-coding-gloss_0_2_7

     

       1361
        
        - essence-of-live-coding-pulse

     

       1362
        
        - essence-of-live-coding-pulse-example

     

       1363
       -
        - essence-of-live-coding-pulse_0_2_7

     

       1364
        
        - essence-of-live-coding-quickcheck

     

       1365
       -
        - essence-of-live-coding-quickcheck_0_2_7

     

       1366
        
        - essence-of-live-coding-vivid

     

       1367
        
        - essence-of-live-coding-warp

     

       1368
       -
        - essence-of-live-coding-warp_0_2_7

     

       1369
        
        - estimators

     

       1370
        
        - estreps

     

       1371
        
        - eternity

     
···

       1404
        
        - exinst-serialise

     

       1405
        
        - exist

     

       1406
        
        - exist-instances

     

       1407
       -
        - exon

     

       1408
        
        - expand

     

       1409
        
        - expat-enumerator

     

       1410
        
        - expiring-containers

     
···

       2427
        
        - jmacro-rpc-happstack

     

       2428
        
        - jmacro-rpc-snap

     

       2429
        
        - join

     

       0
        
       
     

       0
        
       
     

       2430
        
        - jot

     

       2431
        
        - jsaddle-hello

     

       2432
        
        - jsc

     
···

       2875
        
        - nakadi-client

     

       2876
        
        - named-servant-client

     

       2877
        
        - named-servant-server

     

       0
        
       
     

       2878
        
        - nats-queue

     

       2879
        
        - natural-number

     

       2880
        
        - nemesis-titan

     
···

       3349
        
        - remotion

     

       3350
        
        - repa-array

     

       3351
        
        - repa-convert

     

       0
        
       
     

       3352
        
        - repa-flow

     

       3353
        
        - repa-plugin

     

       3354
        
        - repa-stream

     
···

       3394
        
        - ribosome-root

     

       3395
        
        - ribosome-test

     

       3396
        
        - ridley-extras

     

       0
        
       
     

       3397
        
        - riot

     

       3398
        
        - ripple

     

       3399
        
        - ripple-federation

     
···

       3535
        
        - servant-matrix-param

     

       3536
        
        - servant-oauth2

     

       3537
        
        - servant-oauth2-examples

     

       0
        
       
     

       3538
        
        - servant-postgresql

     

       3539
        
        - servant-pushbullet-client

     

       3540
        
        - servant-rate-limit

     
···

       3547
        
        - servant-streamly

     

       3548
        
        - servant-swagger-tags

     

       3549
        
        - servant-to-elm

     

       0
        
       
     

       0
        
       
     

       3550
        
        - servant-waargonaut

     

       3551
        
        - servant-zeppelin-client

     

       3552
        
        - servant-zeppelin-server

     
···

       3721
        
        - statsd-client

     

       3722
        
        - statsdi

     

       3723
        
        - stern-brocot

     

       0
        
       
     

       3724
        
        - stm-supply

     

       3725
        
        - stmcontrol

     

       3726
        
        - storablevector-carray

     
···

       4133
        
        - webcloud

     

       4134
        
        - webcrank-wai

     

       4135
        
        - webdriver-w3c

     

       0
        
       
     

       4136
        
        - webify

     

       4137
        
        - webserver

     

       4138
        
        - websockets-rpc

···

       239
        
        - JsContracts

     

       240
        
        - JsonGrammar

     

       241
        
        - JuPyTer-notebook

     

       242
       +
        - JuicyPixels-scale-dct

     

       243
        
        - JunkDB-driver-gdbm

     

       244
        
        - JunkDB-driver-hashtables

     

       245
        
        - KiCS

     
···

       695
        
        - audiovisual

     

       696
        
        - aura

     

       697
        
        - authoring

     

       698
       +
        - autodocodec-openapi3

     

       699
        
        - automata

     

       700
        
        - autonix-deps-kf5

     

       701
        
        - avers

     
···

       1359
        
        - essence-of-live-coding-PortMidi

     

       1360
        
        - essence-of-live-coding-gloss

     

       1361
        
        - essence-of-live-coding-gloss-example

     

       0
        
       
     

       1362
        
        - essence-of-live-coding-pulse

     

       1363
        
        - essence-of-live-coding-pulse-example

     

       0
        
       
     

       1364
        
        - essence-of-live-coding-quickcheck

     

       0
        
       
     

       1365
        
        - essence-of-live-coding-vivid

     

       1366
        
        - essence-of-live-coding-warp

     

       0
        
       
     

       1367
        
        - estimators

     

       1368
        
        - estreps

     

       1369
        
        - eternity

     
···

       1402
        
        - exinst-serialise

     

       1403
        
        - exist

     

       1404
        
        - exist-instances

     

       0
        
       
     

       1405
        
        - expand

     

       1406
        
        - expat-enumerator

     

       1407
        
        - expiring-containers

     
···

       2424
        
        - jmacro-rpc-happstack

     

       2425
        
        - jmacro-rpc-snap

     

       2426
        
        - join

     

       2427
       +
        - jordan-openapi

     

       2428
       +
        - jordan-servant-openapi

     

       2429
        
        - jot

     

       2430
        
        - jsaddle-hello

     

       2431
        
        - jsc

     
···

       2874
        
        - nakadi-client

     

       2875
        
        - named-servant-client

     

       2876
        
        - named-servant-server

     

       2877
       +
        - named-text

     

       2878
        
        - nats-queue

     

       2879
        
        - natural-number

     

       2880
        
        - nemesis-titan

     
···

       3349
        
        - remotion

     

       3350
        
        - repa-array

     

       3351
        
        - repa-convert

     

       3352
       +
        - repa-fftw

     

       3353
        
        - repa-flow

     

       3354
        
        - repa-plugin

     

       3355
        
        - repa-stream

     
···

       3395
        
        - ribosome-root

     

       3396
        
        - ribosome-test

     

       3397
        
        - ridley-extras

     

       3398
       +
        - rio-process-pool

     

       3399
        
        - riot

     

       3400
        
        - ripple

     

       3401
        
        - ripple-federation

     
···

       3537
        
        - servant-matrix-param

     

       3538
        
        - servant-oauth2

     

       3539
        
        - servant-oauth2-examples

     

       3540
       +
        - servant-openapi3

     

       3541
        
        - servant-postgresql

     

       3542
        
        - servant-pushbullet-client

     

       3543
        
        - servant-rate-limit

     
···

       3550
        
        - servant-streamly

     

       3551
        
        - servant-swagger-tags

     

       3552
        
        - servant-to-elm

     

       3553
       +
        - servant-util

     

       3554
       +
        - servant-util-beam-pg

     

       3555
        
        - servant-waargonaut

     

       3556
        
        - servant-zeppelin-client

     

       3557
        
        - servant-zeppelin-server

     
···

       3726
        
        - statsd-client

     

       3727
        
        - statsdi

     

       3728
        
        - stern-brocot

     

       3729
       +
        - stm-actor

     

       3730
        
        - stm-supply

     

       3731
        
        - stmcontrol

     

       3732
        
        - storablevector-carray

     
···

       4139
        
        - webcloud

     

       4140
        
        - webcrank-wai

     

       4141
        
        - webdriver-w3c

     

       4142
       +
        - webgear-openapi

     

       4143
        
        - webify

     

       4144
        
        - webserver

     

       4145
        
        - websockets-rpc

+2 -4

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

···

       723
        
           '';

     

       724
        
         }) super.haskell-language-server;

     

       725
        
       

     

       726
       -
         # NOTE: this patch updates the hevm code to work with the latest packages that broke the build

     

       727
       -
         # it's temporary until hevm version 0.50.0 is released - https://github.com/ethereum/hevm/milestone/1

     

       728
       -
         # tests depend on a specific version of solc

     

       729
       -
         hevm = dontCheck (appendPatch ./patches/hevm-update-deps.patch super.hevm);

     

       730
        
       

     

       731
        
         # hadolint enables static linking by default in the cabal file, so we have to explicitly disable it.

     

       732
        
         # https://github.com/hadolint/hadolint/commit/e1305042c62d52c2af4d77cdce5d62f6a0a3ce7b

···

       723
        
           '';

     

       724
        
         }) super.haskell-language-server;

     

       725
        
       

     

       726
       +
         # there are three very heavy test suites that need external repos, one requires network access

     

       727
       +
         hevm = dontCheck super.hevm;

     

       0
        
       
     

       0
        
       
     

       728
        
       

     

       729
        
         # hadolint enables static linking by default in the cabal file, so we have to explicitly disable it.

     

       730
        
         # https://github.com/hadolint/hadolint/commit/e1305042c62d52c2af4d77cdce5d62f6a0a3ce7b

+331 -1313

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

···

       1305
        
            }) {};

     

       1306
        
       

     

       1307
        
         "BNFC" = callPackage

     

       1308
       -
           ({ mkDerivation, alex, array, base, Cabal, cabal-doctest

     

       1309
       -
            , containers, deepseq, directory, doctest, filepath, happy, hspec

     

       1310
       -
            , hspec-discover, HUnit, mtl, pretty, process, QuickCheck

     

       1311
       -
            , string-qq, temporary, time

     

       1312
       -
            }:

     

       1313
       -
            mkDerivation {

     

       1314
       -
              pname = "BNFC";

     

       1315
       -
              version = "2.9.4";

     

       1316
       -
              sha256 = "1gy7ggrf2zikyfi8anlj2zavs5b99z7rzs1lmyflrjd82a31bmzp";

     

       1317
       -
              isLibrary = true;

     

       1318
       -
              isExecutable = true;

     

       1319
       -
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       1320
       -
              libraryHaskellDepends = [

     

       1321
       -
                array base containers deepseq directory filepath mtl pretty process

     

       1322
       -
                string-qq time

     

       1323
       -
              ];

     

       1324
       -
              libraryToolDepends = [ alex happy ];

     

       1325
       -
              executableHaskellDepends = [ base ];

     

       1326
       -
              testHaskellDepends = [

     

       1327
       -
                array base containers deepseq directory doctest filepath hspec

     

       1328
       -
                HUnit mtl pretty process QuickCheck string-qq temporary time

     

       1329
       -
              ];

     

       1330
       -
              testToolDepends = [ alex happy hspec-discover ];

     

       1331
       -
              description = "A compiler front-end generator";

     

       1332
       -
              license = lib.licenses.bsd3;

     

       1333
       -
              mainProgram = "bnfc";

     

       1334
       -
            }) {};

     

       1335
       -
       

     

       1336
       -
         "BNFC_2_9_4_1" = callPackage

     

       1337
        
           ({ mkDerivation, alex, array, base, containers, deepseq, directory

     

       1338
        
            , filepath, happy, hspec, hspec-discover, HUnit, mtl, pretty

     

       1339
        
            , process, QuickCheck, string-qq, temporary, time, transformers

     
···

       1357
        
              testToolDepends = [ alex happy hspec-discover ];

     

       1358
        
              description = "A compiler front-end generator";

     

       1359
        
              license = lib.licenses.bsd3;

     

       1360
       -
              hydraPlatforms = lib.platforms.none;

     

       1361
        
              mainProgram = "bnfc";

     

       1362
        
            }) {};

     

       1363
        
       

     
···

       2997
        
              pname = "Cabal-syntax";

     

       2998
        
              version = "3.8.1.0";

     

       2999
        
              sha256 = "03yfk3b2sjmqpxmvx3mj185nifiaqapvc8hmbx4825z0kyqxvs07";

     

       3000
       -
              revision = "1";

     

       3001
       -
              editedCabalFile = "0rmrcjpm169acfranqq04ach5g3jv7v6g45yzpwcp3ksk9g7cdj9";

     

       3002
        
              libraryHaskellDepends = [

     

       3003
        
                array base binary bytestring containers deepseq directory filepath

     

       3004
        
                mtl parsec pretty text time transformers unix

     
···

       9641
        
              pname = "HStringTemplate";

     

       9642
        
              version = "0.8.8";

     

       9643
        
              sha256 = "1n8ci0kzjcgnqh4dfpqwlh7mnlzyiqiqc6hc0zr65p0balbg8zbi";

     

       9644
       -
              revision = "3";

     

       9645
       -
              editedCabalFile = "0316jr5npssxxxj85x74vasvm2ib09mjv2jy7abwjs7cfqbpnr8w";

     

       9646
        
              libraryHaskellDepends = [

     

       9647
        
                array base blaze-builder bytestring containers deepseq directory

     

       9648
        
                filepath mtl old-locale parsec pretty semigroups syb

     
···

       11128
        
           ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }:

     

       11129
        
            mkDerivation {

     

       11130
        
              pname = "HsOpenSSL";

     

       11131
       -
              version = "0.11.7.2";

     

       11132
       -
              sha256 = "0ysdfl8ck3nzhx597fa13dqf31jq5gzwajlak6r91jajks9w0dl5";

     

       11133
       -
              revision = "3";

     

       11134
       -
              editedCabalFile = "0nsqxym87s48029laqba4nzwpk7nrk35x7wmpjqfnbrj82ddcshd";

     

       11135
       -
              setupHaskellDepends = [ base Cabal ];

     

       11136
       -
              libraryHaskellDepends = [ base bytestring network time ];

     

       11137
       -
              librarySystemDepends = [ openssl ];

     

       11138
       -
              testHaskellDepends = [ base bytestring ];

     

       11139
       -
              description = "Partial OpenSSL binding for Haskell";

     

       11140
       -
              license = lib.licenses.publicDomain;

     

       11141
       -
            }) {inherit (pkgs) openssl;};

     

       11142
       -
       

     

       11143
       -
         "HsOpenSSL_0_11_7_4" = callPackage

     

       11144
       -
           ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }:

     

       11145
       -
            mkDerivation {

     

       11146
       -
              pname = "HsOpenSSL";

     

       11147
        
              version = "0.11.7.4";

     

       11148
        
              sha256 = "0zxcfa8b0ng97v53vb8fvg2gss89b28xiz83rx38a0h4lsxpn2xf";

     

       11149
        
              setupHaskellDepends = [ base Cabal ];

     
···

       11152
        
              testHaskellDepends = [ base bytestring ];

     

       11153
        
              description = "Partial OpenSSL binding for Haskell";

     

       11154
        
              license = lib.licenses.publicDomain;

     

       11155
       -
              hydraPlatforms = lib.platforms.none;

     

       11156
        
            }) {inherit (pkgs) openssl;};

     

       11157
        
       

     

       11158
        
         "HsOpenSSL-x509-system" = callPackage

     
···

       12219
        
              ];

     

       12220
        
              description = "Scale JuicyPixels images with DCT";

     

       12221
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       12222
        
            }) {};

     

       12223
        
       

     

       12224
        
         "JuicyPixels-stbir" = callPackage

     
···

       15343
        
              hydraPlatforms = lib.platforms.none;

     

       15344
        
              broken = true;

     

       15345
        
            }) {};

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15346
        
       

     

       15347
        
         "OGL" = callPackage

     

       15348
        
           ({ mkDerivation, base, mtl }:

     
···

       25205
        
            }:

     

       25206
        
            mkDerivation {

     

       25207
        
              pname = "advent-of-code-api";

     

       25208
       -
              version = "0.2.8.2";

     

       25209
       -
              sha256 = "1z4y8bssmaappc7hamdzynjxd1mamn7vzyc0nymldxb8ly7fvpwy";

     

       25210
       -
              libraryHaskellDepends = [

     

       25211
       -
                aeson base bytestring containers deepseq directory filepath

     

       25212
       -
                finite-typelits http-api-data http-client http-client-tls

     

       25213
       -
                http-media megaparsec mtl profunctors servant servant-client

     

       25214
       -
                servant-client-core stm tagsoup text time time-compat

     

       25215
       -
              ];

     

       25216
       -
              testHaskellDepends = [ base directory filepath HUnit text ];

     

       25217
       -
              description = "Advent of Code REST API bindings and servant API";

     

       25218
       -
              license = lib.licenses.bsd3;

     

       25219
       -
            }) {};

     

       25220
       -
       

     

       25221
       -
         "advent-of-code-api_0_2_8_4" = callPackage

     

       25222
       -
           ({ mkDerivation, aeson, base, bytestring, containers, deepseq

     

       25223
       -
            , directory, filepath, finite-typelits, http-api-data, http-client

     

       25224
       -
            , http-client-tls, http-media, HUnit, megaparsec, mtl, profunctors

     

       25225
       -
            , servant, servant-client, servant-client-core, stm, tagsoup, text

     

       25226
       -
            , time, time-compat

     

       25227
       -
            }:

     

       25228
       -
            mkDerivation {

     

       25229
       -
              pname = "advent-of-code-api";

     

       25230
        
              version = "0.2.8.4";

     

       25231
        
              sha256 = "1l7bl0aqn5d6ph730jpwb5h0lwhvrkcw4vla0l73sxrm52j9ma58";

     

       25232
        
              libraryHaskellDepends = [

     
···

       25238
        
              testHaskellDepends = [ base directory filepath HUnit text ];

     

       25239
        
              description = "Advent of Code REST API bindings and servant API";

     

       25240
        
              license = lib.licenses.bsd3;

     

       25241
       -
              hydraPlatforms = lib.platforms.none;

     

       25242
        
            }) {};

     

       25243
        
       

     

       25244
        
         "advent-of-code-ocr" = callPackage

     
···

       31782
        
       

     

       31783
        
         "ansi-terminal-game" = callPackage

     

       31784
        
           ({ mkDerivation, ansi-terminal, array, base, bytestring, cereal

     

       31785
       -
            , clock, containers, exceptions, hspec, hspec-discover, linebreak

     

       31786
       -
            , mintty, mtl, QuickCheck, random, split, terminal-size

     

       31787
       -
            , timers-tick, unidecode

     

       31788
       -
            }:

     

       31789
       -
            mkDerivation {

     

       31790
       -
              pname = "ansi-terminal-game";

     

       31791
       -
              version = "1.8.0.1";

     

       31792
       -
              sha256 = "1fic8wjkbpfd076shfrq8pxlnpsrm59yilbhiinynlgr4vhjncz5";

     

       31793
       -
              isLibrary = true;

     

       31794
       -
              isExecutable = true;

     

       31795
       -
              libraryHaskellDepends = [

     

       31796
       -
                ansi-terminal array base bytestring cereal clock containers

     

       31797
       -
                exceptions linebreak mintty mtl QuickCheck random split

     

       31798
       -
                terminal-size timers-tick unidecode

     

       31799
       -
              ];

     

       31800
       -
              testHaskellDepends = [

     

       31801
       -
                ansi-terminal array base bytestring cereal clock containers

     

       31802
       -
                exceptions hspec linebreak mintty mtl QuickCheck random split

     

       31803
       -
                terminal-size timers-tick unidecode

     

       31804
       -
              ];

     

       31805
       -
              testToolDepends = [ hspec-discover ];

     

       31806
       -
              description = "sdl-like functions for terminal applications, based on ansi-terminal";

     

       31807
       -
              license = lib.licenses.gpl3Only;

     

       31808
       -
            }) {};

     

       31809
       -
       

     

       31810
       -
         "ansi-terminal-game_1_8_1_0" = callPackage

     

       31811
       -
           ({ mkDerivation, ansi-terminal, array, base, bytestring, cereal

     

       31812
        
            , clock, colour, containers, exceptions, hspec, hspec-discover

     

       31813
        
            , linebreak, mintty, mtl, QuickCheck, random, split, terminal-size

     

       31814
        
            , timers-tick, unidecode

     
···

       31832
        
              testToolDepends = [ hspec-discover ];

     

       31833
        
              description = "sdl-like functions for terminal applications, based on ansi-terminal";

     

       31834
        
              license = lib.licenses.gpl3Only;

     

       31835
       -
              hydraPlatforms = lib.platforms.none;

     

       31836
        
            }) {};

     

       31837
        
       

     

       31838
        
         "ansi-wl-pprint" = callPackage

     
···

       35127
        
            }:

     

       35128
        
            mkDerivation {

     

       35129
        
              pname = "ascii";

     

       35130
       -
              version = "1.2.3.0";

     

       35131
       -
              sha256 = "0s6w1wv6hjx1abz038cw7fyl8ilbs3cxmcs989c3hh9659l82p2j";

     

       35132
       -
              revision = "2";

     

       35133
       -
              editedCabalFile = "16b1dmjl0p2zdn05h2iwm1ymhrvgr19c1gzankrn0i7jj89nf979";

     

       35134
       -
              libraryHaskellDepends = [

     

       35135
       -
                ascii-case ascii-char ascii-group ascii-numbers ascii-predicates

     

       35136
       -
                ascii-superset ascii-th base bytestring text

     

       35137
       -
              ];

     

       35138
       -
              testHaskellDepends = [ base hedgehog text ];

     

       35139
       -
              description = "The ASCII character set and encoding";

     

       35140
       -
              license = lib.licenses.asl20;

     

       35141
       -
            }) {};

     

       35142
       -
       

     

       35143
       -
         "ascii_1_2_4_0" = callPackage

     

       35144
       -
           ({ mkDerivation, ascii-case, ascii-char, ascii-group, ascii-numbers

     

       35145
       -
            , ascii-predicates, ascii-superset, ascii-th, base, bytestring

     

       35146
       -
            , hedgehog, text

     

       35147
       -
            }:

     

       35148
       -
            mkDerivation {

     

       35149
       -
              pname = "ascii";

     

       35150
        
              version = "1.2.4.0";

     

       35151
        
              sha256 = "1rsv9ah0jvf66w3k4smh67wpbm03xl4pdyj8svmdy49hbpihimwi";

     

       35152
        
              libraryHaskellDepends = [

     
···

       35156
        
              testHaskellDepends = [ base hedgehog text ];

     

       35157
        
              description = "The ASCII character set and encoding";

     

       35158
        
              license = lib.licenses.asl20;

     

       35159
       -
              hydraPlatforms = lib.platforms.none;

     

       35160
        
            }) {};

     

       35161
        
       

     

       35162
        
         "ascii-art-to-unicode" = callPackage

     
···

       35176
        
            }) {};

     

       35177
        
       

     

       35178
        
         "ascii-case" = callPackage

     

       35179
       -
           ({ mkDerivation, ascii-char, base, hashable }:

     

       35180
       -
            mkDerivation {

     

       35181
       -
              pname = "ascii-case";

     

       35182
       -
              version = "1.0.0.11";

     

       35183
       -
              sha256 = "03rhq303igzvx9yil5qli2ga9iz47psrlnbb494785w9whwayxq1";

     

       35184
       -
              revision = "1";

     

       35185
       -
              editedCabalFile = "0a4nz34a5034lkq42q2l7xqdkjpakcy44syqy0gvx8p6h83ccrb1";

     

       35186
       -
              libraryHaskellDepends = [ ascii-char base hashable ];

     

       35187
       -
              testHaskellDepends = [ ascii-char base ];

     

       35188
       -
              description = "ASCII letter case";

     

       35189
       -
              license = lib.licenses.asl20;

     

       35190
       -
            }) {};

     

       35191
       -
       

     

       35192
       -
         "ascii-case_1_0_1_1" = callPackage

     

       35193
        
           ({ mkDerivation, ascii-char, base, hashable, hspec }:

     

       35194
        
            mkDerivation {

     

       35195
        
              pname = "ascii-case";

     
···

       35199
        
              testHaskellDepends = [ ascii-char base hspec ];

     

       35200
        
              description = "ASCII letter case";

     

       35201
        
              license = lib.licenses.asl20;

     

       35202
       -
              hydraPlatforms = lib.platforms.none;

     

       35203
        
            }) {};

     

       35204
        
       

     

       35205
        
         "ascii-caseless" = callPackage

     
···

       35217
        
            }) {};

     

       35218
        
       

     

       35219
        
         "ascii-char" = callPackage

     

       35220
       -
           ({ mkDerivation, base, hashable }:

     

       35221
        
            mkDerivation {

     

       35222
        
              pname = "ascii-char";

     

       35223
       -
              version = "1.0.0.15";

     

       35224
       -
              sha256 = "10vvhpl7y1gpw7gw2hpcckl0pmx7rkn35zy6yl6c9mx0hib0745a";

     

       35225
       -
              revision = "1";

     

       35226
       -
              editedCabalFile = "0b73pm9z5k3xbpn49fz4m8jwzw3r4z0l2v4alinf5l7n6vx4wvj0";

     

       35227
        
              libraryHaskellDepends = [ base hashable ];

     

       35228
       -
              testHaskellDepends = [ base ];

     

       35229
        
              description = "A Char type representing an ASCII character";

     

       35230
        
              license = lib.licenses.asl20;

     

       35231
        
            }) {};

     

       35232
        
       

     

       35233
       -
         "ascii-char_1_0_0_16" = callPackage

     

       35234
        
           ({ mkDerivation, base, hashable, hspec }:

     

       35235
        
            mkDerivation {

     

       35236
        
              pname = "ascii-char";

     

       35237
       -
              version = "1.0.0.16";

     

       35238
       -
              sha256 = "06iig5p15ip0wpg330dq8kclq7g7j2xkrkk0dbl3z509d44mg049";

     

       35239
        
              libraryHaskellDepends = [ base hashable ];

     

       35240
        
              testHaskellDepends = [ base hspec ];

     

       35241
        
              description = "A Char type representing an ASCII character";

     
···

       35276
        
           ({ mkDerivation, ascii-char, base, hashable, hedgehog }:

     

       35277
        
            mkDerivation {

     

       35278
        
              pname = "ascii-group";

     

       35279
       -
              version = "1.0.0.13";

     

       35280
       -
              sha256 = "1xynfvrr8lwmrxqww2c2bwp6r3162mqgmx7hljwmbvdmnc0na30d";

     

       35281
       -
              revision = "1";

     

       35282
       -
              editedCabalFile = "0snp4qfj20jjchhhf7v8lyssjydv57sd2wy88fbc0aaba4c5lq7y";

     

       35283
       -
              libraryHaskellDepends = [ ascii-char base hashable ];

     

       35284
       -
              testHaskellDepends = [ ascii-char base hedgehog ];

     

       35285
       -
              description = "ASCII character groups";

     

       35286
       -
              license = lib.licenses.asl20;

     

       35287
       -
            }) {};

     

       35288
       -
       

     

       35289
       -
         "ascii-group_1_0_0_14" = callPackage

     

       35290
       -
           ({ mkDerivation, ascii-char, base, hashable, hedgehog }:

     

       35291
       -
            mkDerivation {

     

       35292
       -
              pname = "ascii-group";

     

       35293
        
              version = "1.0.0.14";

     

       35294
        
              sha256 = "0rk3lvs4b6d4cfzb5zc87f42wdmziprpfd4fww5r68ry3ccyn1ps";

     

       0
        
       
     

       0
        
       
     

       35295
        
              libraryHaskellDepends = [ ascii-char base hashable ];

     

       35296
        
              testHaskellDepends = [ ascii-char base hedgehog ];

     

       35297
        
              description = "ASCII character groups";

     

       35298
        
              license = lib.licenses.asl20;

     

       35299
       -
              hydraPlatforms = lib.platforms.none;

     

       35300
        
            }) {};

     

       35301
        
       

     

       35302
        
         "ascii-holidays" = callPackage

     
···

       35336
        
              license = lib.licenses.asl20;

     

       35337
        
            }) {};

     

       35338
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35339
        
         "ascii-predicates" = callPackage

     

       35340
        
           ({ mkDerivation, ascii-char, base, hedgehog }:

     

       35341
        
            mkDerivation {

     
···

       35348
        
              testHaskellDepends = [ ascii-char base hedgehog ];

     

       35349
        
              description = "Various categorizations of ASCII characters";

     

       35350
        
              license = lib.licenses.asl20;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35351
        
            }) {};

     

       35352
        
       

     

       35353
        
         "ascii-progress" = callPackage

     
···

       35412
        
              license = lib.licenses.asl20;

     

       35413
        
            }) {};

     

       35414
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35415
        
         "ascii-table" = callPackage

     

       35416
        
           ({ mkDerivation, aeson, base, containers, dlist, hashable, text

     

       35417
        
            , unordered-containers, vector, wl-pprint-extras

     
···

       35449
        
              license = lib.licenses.asl20;

     

       35450
        
            }) {};

     

       35451
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35452
        
         "ascii-vector-avc" = callPackage

     

       35453
        
           ({ mkDerivation, attoparsec, base, binary, bytestring, deepseq

     

       35454
        
            , deepseq-generics, HUnit, split, zlib

     
···

       36591
        
              hydraPlatforms = lib.platforms.none;

     

       36592
        
            }) {};

     

       36593
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       36594
        
         "atomic-file-ops" = callPackage

     

       36595
        
           ({ mkDerivation, base, directory, filelock, filepath

     

       36596
        
            , io-string-like

     
···

       37708
        
              ];

     

       37709
        
              description = "Autodocodec interpreters for openapi3";

     

       37710
        
              license = lib.licenses.mit;

     

       0
        
       
     

       37711
        
            }) {};

     

       37712
        
       

     

       37713
        
         "autodocodec-schema" = callPackage

     
···

       39998
        
            }:

     

       39999
        
            mkDerivation {

     

       40000
        
              pname = "barbies";

     

       40001
       -
              version = "2.0.3.1";

     

       40002
       -
              sha256 = "0gfzb52k3py1qnr2b6gshdg7c9aj1j9y2xsdhz86n01ybv81yg51";

     

       40003
       -
              libraryHaskellDepends = [ base distributive transformers ];

     

       40004
       -
              testHaskellDepends = [

     

       40005
       -
                base distributive QuickCheck tasty tasty-hunit tasty-quickcheck

     

       40006
       -
              ];

     

       40007
       -
              description = "Classes for working with types that can change clothes";

     

       40008
       -
              license = lib.licenses.bsd3;

     

       40009
       -
            }) {};

     

       40010
       -
       

     

       40011
       -
         "barbies_2_0_4_0" = callPackage

     

       40012
       -
           ({ mkDerivation, base, distributive, QuickCheck, tasty, tasty-hunit

     

       40013
       -
            , tasty-quickcheck, transformers

     

       40014
       -
            }:

     

       40015
       -
            mkDerivation {

     

       40016
       -
              pname = "barbies";

     

       40017
        
              version = "2.0.4.0";

     

       40018
        
              sha256 = "0v8bckxi58fkqgf1i1xd3100wp792pzd319xlfvmmw8z0ii1g872";

     

       40019
        
              libraryHaskellDepends = [ base distributive transformers ];

     
···

       40022
        
              ];

     

       40023
        
              description = "Classes for working with types that can change clothes";

     

       40024
        
              license = lib.licenses.bsd3;

     

       40025
       -
              hydraPlatforms = lib.platforms.none;

     

       40026
        
            }) {};

     

       40027
        
       

     

       40028
        
         "barbies-layered" = callPackage

     
···

       42103
        
           ({ mkDerivation, base, hspec }:

     

       42104
        
            mkDerivation {

     

       42105
        
              pname = "benri-hspec";

     

       42106
       -
              version = "0.1.0.0";

     

       42107
       -
              sha256 = "0vvc7fw52c9flmdjmgrc9cca9yrl4r7yvh2l5ixc23gvvmlhdycy";

     

       42108
       -
              libraryHaskellDepends = [ base hspec ];

     

       42109
       -
              description = "Simplify tests where Either or Maybe types are returned from monadic code";

     

       42110
       -
              license = lib.licenses.bsd3;

     

       42111
       -
            }) {};

     

       42112
       -
       

     

       42113
       -
         "benri-hspec_0_1_0_1" = callPackage

     

       42114
       -
           ({ mkDerivation, base, hspec }:

     

       42115
       -
            mkDerivation {

     

       42116
       -
              pname = "benri-hspec";

     

       42117
        
              version = "0.1.0.1";

     

       42118
        
              sha256 = "11x7dsp6hmz1an1nm8076lgdvgd8r67hl54p81jprpi8m0lh6mqa";

     

       42119
        
              libraryHaskellDepends = [ base hspec ];

     

       42120
        
              description = "Simplify tests where Either or Maybe types are returned from monadic code";

     

       42121
        
              license = lib.licenses.bsd3;

     

       42122
       -
              hydraPlatforms = lib.platforms.none;

     

       42123
        
            }) {};

     

       42124
        
       

     

       42125
        
         "bento" = callPackage

     
···

       47656
        
            }:

     

       47657
        
            mkDerivation {

     

       47658
        
              pname = "boomerang";

     

       47659
       -
              version = "1.4.8";

     

       47660
       -
              sha256 = "141rs9q8i89118ldplm90zqzkjff3jwqhsdld4vp4ipc26f9gjdl";

     

       47661
       -
              libraryHaskellDepends = [

     

       47662
       -
                base mtl semigroups template-haskell text th-abstraction

     

       47663
       -
              ];

     

       47664
       -
              description = "Library for invertible parsing and printing";

     

       47665
       -
              license = lib.licenses.bsd3;

     

       47666
       -
            }) {};

     

       47667
       -
       

     

       47668
       -
         "boomerang_1_4_8_1" = callPackage

     

       47669
       -
           ({ mkDerivation, base, mtl, semigroups, template-haskell, text

     

       47670
       -
            , th-abstraction

     

       47671
       -
            }:

     

       47672
       -
            mkDerivation {

     

       47673
       -
              pname = "boomerang";

     

       47674
        
              version = "1.4.8.1";

     

       47675
        
              sha256 = "1hal4z1c1skqjq7vvjql0gm2rhfgrrlj29rgchjwlr2hm22zgnjp";

     

       47676
        
              libraryHaskellDepends = [

     
···

       47678
        
              ];

     

       47679
        
              description = "Library for invertible parsing and printing";

     

       47680
        
              license = lib.licenses.bsd3;

     

       47681
       -
              hydraPlatforms = lib.platforms.none;

     

       47682
        
            }) {};

     

       47683
        
       

     

       47684
        
         "boomslang" = callPackage

     
···

       50714
        
            }:

     

       50715
        
            mkDerivation {

     

       50716
        
              pname = "bytesmith";

     

       50717
       -
              version = "0.3.9.0";

     

       50718
       -
              sha256 = "0jmx4flf3j5a4gyrw79cxiybp6f7y0rm9ifmrxypxpwrwc220zjg";

     

       50719
       -
              revision = "1";

     

       50720
       -
              editedCabalFile = "0ly247yj2ay0fpj5v3dqp0hava1wrllqhphf7k3hcifpi5zfr8i0";

     

       50721
       -
              libraryHaskellDepends = [

     

       50722
       -
                base byteslice bytestring contiguous primitive run-st text-short

     

       50723
       -
                wide-word

     

       50724
       -
              ];

     

       50725
       -
              testHaskellDepends = [

     

       50726
       -
                base byte-order byteslice primitive tasty tasty-hunit

     

       50727
       -
                tasty-quickcheck text-short wide-word

     

       50728
       -
              ];

     

       50729
       -
              benchmarkHaskellDepends = [

     

       50730
       -
                base byteslice bytestring gauge primitive

     

       50731
       -
              ];

     

       50732
       -
              description = "Nonresumable byte parser";

     

       50733
       -
              license = lib.licenses.bsd3;

     

       50734
       -
            }) {};

     

       50735
       -
       

     

       50736
       -
         "bytesmith_0_3_9_1" = callPackage

     

       50737
       -
           ({ mkDerivation, base, byte-order, byteslice, bytestring

     

       50738
       -
            , contiguous, gauge, primitive, run-st, tasty, tasty-hunit

     

       50739
       -
            , tasty-quickcheck, text-short, wide-word

     

       50740
       -
            }:

     

       50741
       -
            mkDerivation {

     

       50742
       -
              pname = "bytesmith";

     

       50743
        
              version = "0.3.9.1";

     

       50744
        
              sha256 = "10d0wzinc30b2xc26cfadvpn29gf30gnppysyl3n35ym3p9lnhm2";

     

       50745
        
              libraryHaskellDepends = [

     
···

       50755
        
              ];

     

       50756
        
              description = "Nonresumable byte parser";

     

       50757
        
              license = lib.licenses.bsd3;

     

       50758
       -
              hydraPlatforms = lib.platforms.none;

     

       50759
        
            }) {};

     

       50760
        
       

     

       50761
        
         "bytestring_0_11_3_1" = callPackage

     
···

       51834
        
            }:

     

       51835
        
            mkDerivation {

     

       51836
        
              pname = "cabal-cache";

     

       51837
       -
              version = "1.0.5.4";

     

       51838
       -
              sha256 = "15jg140ly7rska7v8ihvd383q9lj4i5c18rzjad4yi8f78jjciqb";

     

       51839
        
              isLibrary = true;

     

       51840
        
              isExecutable = true;

     

       51841
        
              libraryHaskellDepends = [

     
···

       57905
        
            }) {};

     

       57906
        
       

     

       57907
        
         "chimera" = callPackage

     

       57908
       -
           ({ mkDerivation, adjunctions, base, distributive, mtl, QuickCheck

     

       57909
       -
            , random, tasty, tasty-bench, tasty-hunit, tasty-quickcheck

     

       57910
       -
            , tasty-smallcheck, vector

     

       57911
        
            }:

     

       57912
        
            mkDerivation {

     

       57913
        
              pname = "chimera";

     

       57914
       -
              version = "0.3.2.0";

     

       57915
       -
              sha256 = "1p8in1a37hrb0qwvabwi4a9ahzydkd8j3v402cn2i3xmkzcr0kh9";

     

       57916
        
              libraryHaskellDepends = [

     

       57917
       -
                adjunctions base distributive mtl vector

     

       57918
        
              ];

     

       57919
        
              testHaskellDepends = [

     

       57920
        
                base QuickCheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck

     

       57921
        
                vector

     

       57922
        
              ];

     

       57923
       -
              benchmarkHaskellDepends = [ base mtl random tasty-bench ];

     

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

     

       57925
        
              license = lib.licenses.bsd3;

     

       57926
        
            }) {};

     
···

       59498
        
              pname = "clash-prelude";

     

       59499
        
              version = "1.6.4";

     

       59500
        
              sha256 = "12ic8jcgz3jr4zrgrx06dzd6whlypyyxilrgbja27dcdv02fs6yr";

     

       0
        
       
     

       0
        
       
     

       59501
        
              libraryHaskellDepends = [

     

       59502
        
                array arrows base binary bytestring constraints containers

     

       59503
        
                data-binary-ieee754 data-default-class deepseq extra ghc-bignum

     
···

       64505
        
            }:

     

       64506
        
            mkDerivation {

     

       64507
        
              pname = "composite-base";

     

       64508
       -
              version = "0.8.2.0";

     

       64509
       -
              sha256 = "0niw6rc9sscq73vja8pzds4r87yvckh0h5138i86wv18m34ksniw";

     

       64510
       -
              libraryHaskellDepends = [

     

       64511
       -
                base deepseq exceptions lens monad-control mtl profunctors

     

       64512
       -
                template-haskell text transformers transformers-base unliftio-core

     

       64513
       -
                vinyl

     

       64514
       -
              ];

     

       64515
       -
              testHaskellDepends = [

     

       64516
       -
                base deepseq exceptions hspec lens monad-control mtl profunctors

     

       64517
       -
                QuickCheck template-haskell text transformers transformers-base

     

       64518
       -
                unliftio-core vinyl

     

       64519
       -
              ];

     

       64520
       -
              description = "Shared utilities for composite-* packages";

     

       64521
       -
              license = lib.licenses.bsd3;

     

       64522
       -
            }) {};

     

       64523
       -
       

     

       64524
       -
         "composite-base_0_8_2_1" = callPackage

     

       64525
       -
           ({ mkDerivation, base, deepseq, exceptions, hspec, lens

     

       64526
       -
            , monad-control, mtl, profunctors, QuickCheck, template-haskell

     

       64527
       -
            , text, transformers, transformers-base, unliftio-core, vinyl

     

       64528
       -
            }:

     

       64529
       -
            mkDerivation {

     

       64530
       -
              pname = "composite-base";

     

       64531
        
              version = "0.8.2.1";

     

       64532
        
              sha256 = "0i2mamh5gz7ay1cm5nkmdbh2lnaph42pfi2aa9jb2baxi0jgxdri";

     

       64533
        
              libraryHaskellDepends = [

     
···

       64542
        
              ];

     

       64543
        
              description = "Shared utilities for composite-* packages";

     

       64544
        
              license = lib.licenses.bsd3;

     

       64545
       -
              hydraPlatforms = lib.platforms.none;

     

       64546
        
            }) {};

     

       64547
        
       

     

       64548
        
         "composite-binary" = callPackage

     

       64549
        
           ({ mkDerivation, base, binary, composite-base }:

     

       64550
        
            mkDerivation {

     

       64551
        
              pname = "composite-binary";

     

       64552
       -
              version = "0.8.2.0";

     

       64553
       -
              sha256 = "1ijlrwyji9179hc5wcmdzzf3g79xkz6k1kjxq0l7iqyvfjh2zrkh";

     

       64554
       -
              libraryHaskellDepends = [ base binary composite-base ];

     

       64555
       -
              description = "Orphan binary instances";

     

       64556
       -
              license = lib.licenses.bsd3;

     

       64557
       -
            }) {};

     

       64558
       -
       

     

       64559
       -
         "composite-binary_0_8_2_1" = callPackage

     

       64560
       -
           ({ mkDerivation, base, binary, composite-base }:

     

       64561
       -
            mkDerivation {

     

       64562
       -
              pname = "composite-binary";

     

       64563
        
              version = "0.8.2.1";

     

       64564
        
              sha256 = "0bxnzxvw5mjhz3kh6x265l70hp1z3z1y9fbdwhrgv6bhhinxb3hq";

     

       64565
        
              libraryHaskellDepends = [ base binary composite-base ];

     

       64566
        
              description = "Orphan binary instances";

     

       64567
        
              license = lib.licenses.bsd3;

     

       64568
       -
              hydraPlatforms = lib.platforms.none;

     

       64569
        
            }) {};

     

       64570
        
       

     

       64571
        
         "composite-cassava" = callPackage

     
···

       64610
        
            }:

     

       64611
        
            mkDerivation {

     

       64612
        
              pname = "composite-ekg";

     

       64613
       -
              version = "0.8.2.0";

     

       64614
       -
              sha256 = "0kcyscjs8qsydhj7labm8v62xcm9vc39rcw13xlvwmxz3lwi5jl3";

     

       64615
       -
              libraryHaskellDepends = [

     

       64616
       -
                base composite-base ekg-core lens text vinyl

     

       64617
       -
              ];

     

       64618
       -
              description = "EKG Metrics for Vinyl records";

     

       64619
       -
              license = lib.licenses.bsd3;

     

       64620
       -
            }) {};

     

       64621
       -
       

     

       64622
       -
         "composite-ekg_0_8_2_1" = callPackage

     

       64623
       -
           ({ mkDerivation, base, composite-base, ekg-core, lens, text, vinyl

     

       64624
       -
            }:

     

       64625
       -
            mkDerivation {

     

       64626
       -
              pname = "composite-ekg";

     

       64627
        
              version = "0.8.2.1";

     

       64628
        
              sha256 = "0c0rxa30r19wcvqrw20xk96652mxknbs1lqpnzdj9kz77al3k1kl";

     

       64629
        
              libraryHaskellDepends = [

     
···

       64631
        
              ];

     

       64632
        
              description = "EKG Metrics for Vinyl records";

     

       64633
        
              license = lib.licenses.bsd3;

     

       64634
       -
              hydraPlatforms = lib.platforms.none;

     

       64635
        
            }) {};

     

       64636
        
       

     

       64637
        
         "composite-hashable" = callPackage

     
···

       74748
        
           ({ mkDerivation, base }:

     

       74749
        
            mkDerivation {

     

       74750
        
              pname = "data-forest";

     

       74751
       -
              version = "0.1.0.9";

     

       74752
       -
              sha256 = "1l16hg1pfzrbi2ih6najcam18p2b5lvmmkl6fxvk7izynvcc79jc";

     

       74753
       -
              revision = "1";

     

       74754
       -
              editedCabalFile = "0m0fp8fx21257z5k1g575wjcmavd29qav4cgjcwg5nxkxwrfldg8";

     

       74755
        
              libraryHaskellDepends = [ base ];

     

       74756
        
              testHaskellDepends = [ base ];

     

       74757
        
              description = "A simple multi-way tree data structure";

     
···

       78338
        
           ({ mkDerivation, base, constraints-extras, some }:

     

       78339
        
            mkDerivation {

     

       78340
        
              pname = "dependent-sum";

     

       78341
       -
              version = "0.7.1.0";

     

       78342
       -
              sha256 = "0aj63gvak0y4mgxndykqfg5w958hf7lp5blml2z647rjgy85bjw1";

     

       78343
       -
              revision = "2";

     

       78344
       -
              editedCabalFile = "0d7wb1ag60mcm56axcrx9pd6hgrsxmqynyplbcfl01ms2i60fhr9";

     

       78345
       -
              libraryHaskellDepends = [ base constraints-extras some ];

     

       78346
       -
              description = "Dependent sum type";

     

       78347
       -
              license = lib.licenses.publicDomain;

     

       78348
       -
            }) {};

     

       78349
       -
       

     

       78350
       -
         "dependent-sum_0_7_2_0" = callPackage

     

       78351
       -
           ({ mkDerivation, base, constraints-extras, some }:

     

       78352
       -
            mkDerivation {

     

       78353
       -
              pname = "dependent-sum";

     

       78354
        
              version = "0.7.2.0";

     

       78355
        
              sha256 = "1frw5965v8i6xqdgs95gg8asgdqcqnmfahz0pmbwiaw5ybn62rc2";

     

       78356
        
              libraryHaskellDepends = [ base constraints-extras some ];

     

       78357
        
              description = "Dependent sum type";

     

       78358
        
              license = lib.licenses.publicDomain;

     

       78359
       -
              hydraPlatforms = lib.platforms.none;

     

       78360
        
            }) {};

     

       78361
        
       

     

       78362
        
         "dependent-sum-aeson-orphans" = callPackage

     
···

       81252
        
           ({ mkDerivation, base, bytestring, zlib }:

     

       81253
        
            mkDerivation {

     

       81254
        
              pname = "digest";

     

       81255
       -
              version = "0.0.1.3";

     

       81256
       -
              sha256 = "1l5383l5pvp018rj3vabrppnzcqrr2g0dvgvmsrbjdn02wzab5jm";

     

       81257
       -
              libraryHaskellDepends = [ base bytestring ];

     

       81258
       -
              librarySystemDepends = [ zlib ];

     

       81259
       -
              description = "Various cryptographic hashes for bytestrings; CRC32 and Adler32 for now";

     

       81260
       -
              license = lib.licenses.bsd3;

     

       81261
       -
            }) {inherit (pkgs) zlib;};

     

       81262
       -
       

     

       81263
       -
         "digest_0_0_1_4" = callPackage

     

       81264
       -
           ({ mkDerivation, base, bytestring, zlib }:

     

       81265
       -
            mkDerivation {

     

       81266
       -
              pname = "digest";

     

       81267
        
              version = "0.0.1.4";

     

       81268
        
              sha256 = "05pc5l4bwddszc6vy1hazwi1dnrxg323521gdkis9cvh7zs2a4gr";

     

       81269
        
              libraryHaskellDepends = [ base bytestring ];

     

       81270
        
              libraryPkgconfigDepends = [ zlib ];

     

       81271
        
              description = "Various hashes for bytestrings; CRC32 and Adler32 for now";

     

       81272
        
              license = lib.licenses.bsd3;

     

       81273
       -
              hydraPlatforms = lib.platforms.none;

     

       81274
        
            }) {inherit (pkgs) zlib;};

     

       81275
        
       

     

       81276
        
         "digest-pure" = callPackage

     
···

       83605
        
            }:

     

       83606
        
            mkDerivation {

     

       83607
        
              pname = "dlist-nonempty";

     

       83608
       -
              version = "0.1.1";

     

       83609
       -
              sha256 = "0csbspdy43pzvasb5mhs5pz2f49ws78pi253cx7pp84wjx6ads20";

     

       83610
       -
              revision = "13";

     

       83611
       -
              editedCabalFile = "1hbd0j8yw81y4rnxqxxnvhy33ccgl5c7qcr9shzqy97fwi2vkikm";

     

       83612
       -
              libraryHaskellDepends = [

     

       83613
       -
                base base-compat deepseq dlist semigroupoids

     

       83614
       -
              ];

     

       83615
       -
              testHaskellDepends = [

     

       83616
       -
                base Cabal QuickCheck quickcheck-instances

     

       83617
       -
              ];

     

       83618
       -
              benchmarkHaskellDepends = [

     

       83619
       -
                base base-compat criterion dlist dlist-instances

     

       83620
       -
              ];

     

       83621
       -
              description = "Non-empty difference lists";

     

       83622
       -
              license = lib.licenses.bsd3;

     

       83623
       -
            }) {};

     

       83624
       -
       

     

       83625
       -
         "dlist-nonempty_0_1_2" = callPackage

     

       83626
       -
           ({ mkDerivation, base, base-compat, Cabal, criterion, deepseq

     

       83627
       -
            , dlist, dlist-instances, QuickCheck, quickcheck-instances

     

       83628
       -
            , semigroupoids

     

       83629
       -
            }:

     

       83630
       -
            mkDerivation {

     

       83631
       -
              pname = "dlist-nonempty";

     

       83632
        
              version = "0.1.2";

     

       83633
        
              sha256 = "1phdqr9fi2smscmqn7l9kfjxfnqfw6ws1v0a1lrqm5civ15gxhms";

     

       83634
        
              libraryHaskellDepends = [ base deepseq dlist semigroupoids ];

     
···

       83640
        
              ];

     

       83641
        
              description = "Non-empty difference lists";

     

       83642
        
              license = lib.licenses.bsd3;

     

       83643
       -
              hydraPlatforms = lib.platforms.none;

     

       83644
        
            }) {};

     

       83645
        
       

     

       83646
        
         "dmc" = callPackage

     
···

       84559
        
           ({ mkDerivation, base, doctest }:

     

       84560
        
            mkDerivation {

     

       84561
        
              pname = "doctest-driver-gen";

     

       84562
       -
              version = "0.3.0.5";

     

       84563
       -
              sha256 = "08zv5c1cfklknpbw974sw4rb6jiijd3q28cpjw1cncc06n2jy85b";

     

       84564
       -
              isLibrary = true;

     

       84565
       -
              isExecutable = true;

     

       84566
       -
              libraryHaskellDepends = [ base ];

     

       84567
       -
              executableHaskellDepends = [ base ];

     

       84568
       -
              testHaskellDepends = [ base doctest ];

     

       84569
       -
              description = "Generate driver file for doctest's cabal integration";

     

       84570
       -
              license = lib.licenses.bsd3;

     

       84571
       -
              mainProgram = "doctest-driver-gen";

     

       84572
       -
            }) {};

     

       84573
       -
       

     

       84574
       -
         "doctest-driver-gen_0_3_0_6" = callPackage

     

       84575
       -
           ({ mkDerivation, base, doctest }:

     

       84576
       -
            mkDerivation {

     

       84577
       -
              pname = "doctest-driver-gen";

     

       84578
        
              version = "0.3.0.6";

     

       84579
        
              sha256 = "0a4jdg4mzhdgfal7jp60yrlv63iv7d8f7nxc9aqvrl93mairny8l";

     

       84580
        
              isLibrary = true;

     
···

       84584
        
              testHaskellDepends = [ base doctest ];

     

       84585
        
              description = "Generate driver file for doctest's cabal integration";

     

       84586
        
              license = lib.licenses.bsd3;

     

       84587
       -
              hydraPlatforms = lib.platforms.none;

     

       84588
        
              mainProgram = "doctest-driver-gen";

     

       84589
        
            }) {};

     

       84590
        
       

     
···

       84648
        
            }:

     

       84649
        
            mkDerivation {

     

       84650
        
              pname = "doctest-parallel";

     

       84651
       -
              version = "0.2.5";

     

       84652
       -
              sha256 = "075y4yllpgfq0dlfd6y9nqhsdkxzb9s3jgb0v194l216kg5zsqzc";

     

       84653
       -
              revision = "1";

     

       84654
       -
              editedCabalFile = "1q81qjz9af9a57xyxz6kci28shl4r9y3lrl3rckknhqwcy1ahqz4";

     

       84655
       -
              libraryHaskellDepends = [

     

       84656
       -
                base base-compat Cabal code-page containers deepseq directory

     

       84657
       -
                exceptions extra filepath ghc ghc-paths Glob pretty process random

     

       84658
       -
                syb template-haskell transformers unordered-containers

     

       84659
       -
              ];

     

       84660
       -
              testHaskellDepends = [

     

       84661
       -
                base base-compat code-page containers deepseq directory exceptions

     

       84662
       -
                filepath ghc ghc-paths hspec hspec-core hspec-discover HUnit

     

       84663
       -
                mockery process QuickCheck setenv silently stringbuilder syb

     

       84664
       -
                transformers

     

       84665
       -
              ];

     

       84666
       -
              testToolDepends = [ hspec-discover ];

     

       84667
       -
              doHaddock = false;

     

       84668
       -
              description = "Test interactive Haskell examples";

     

       84669
       -
              license = lib.licenses.mit;

     

       84670
       -
            }) {};

     

       84671
       -
       

     

       84672
       -
         "doctest-parallel_0_2_6" = callPackage

     

       84673
       -
           ({ mkDerivation, base, base-compat, Cabal, code-page, containers

     

       84674
       -
            , deepseq, directory, exceptions, extra, filepath, ghc, ghc-paths

     

       84675
       -
            , Glob, hspec, hspec-core, hspec-discover, HUnit, mockery, pretty

     

       84676
       -
            , process, QuickCheck, random, setenv, silently, stringbuilder, syb

     

       84677
       -
            , template-haskell, transformers, unordered-containers

     

       84678
       -
            }:

     

       84679
       -
            mkDerivation {

     

       84680
       -
              pname = "doctest-parallel";

     

       84681
        
              version = "0.2.6";

     

       84682
        
              sha256 = "13hjwhdjw8jrj07zxkrrfbzr0mrk8gwyis1rbdi4ld4jbq3rr1z7";

     

       84683
        
              libraryHaskellDepends = [

     
···

       84695
        
              doHaddock = false;

     

       84696
        
              description = "Test interactive Haskell examples";

     

       84697
        
              license = lib.licenses.mit;

     

       84698
       -
              hydraPlatforms = lib.platforms.none;

     

       84699
        
            }) {};

     

       84700
        
       

     

       84701
        
         "doctest-prop" = callPackage

     
···

       85215
        
            }:

     

       85216
        
            mkDerivation {

     

       85217
        
              pname = "dotenv";

     

       85218
       -
              version = "0.9.0.3";

     

       85219
       -
              sha256 = "163w2japbcdjzmhr7afq2rss7sp7gz2j8mylcc716x63gm3ws20h";

     

       85220
       -
              isLibrary = true;

     

       85221
       -
              isExecutable = true;

     

       85222
       -
              enableSeparateDataOutput = true;

     

       85223
       -
              libraryHaskellDepends = [

     

       85224
       -
                base base-compat containers directory exceptions megaparsec process

     

       85225
       -
                shellwords text

     

       85226
       -
              ];

     

       85227
       -
              executableHaskellDepends = [

     

       85228
       -
                base base-compat megaparsec optparse-applicative process text

     

       85229
       -
              ];

     

       85230
       -
              testHaskellDepends = [

     

       85231
       -
                base base-compat containers directory exceptions hspec

     

       85232
       -
                hspec-megaparsec megaparsec process shellwords text

     

       85233
       -
              ];

     

       85234
       -
              testToolDepends = [ hspec-discover ];

     

       85235
       -
              description = "Loads environment variables from dotenv files";

     

       85236
       -
              license = lib.licenses.mit;

     

       85237
       -
              mainProgram = "dotenv";

     

       85238
       -
            }) {};

     

       85239
       -
       

     

       85240
       -
         "dotenv_0_10_0_0" = callPackage

     

       85241
       -
           ({ mkDerivation, base, base-compat, containers, directory

     

       85242
       -
            , exceptions, hspec, hspec-discover, hspec-megaparsec, megaparsec

     

       85243
       -
            , optparse-applicative, process, shellwords, text

     

       85244
       -
            }:

     

       85245
       -
            mkDerivation {

     

       85246
       -
              pname = "dotenv";

     

       85247
        
              version = "0.10.0.0";

     

       85248
        
              sha256 = "04brkjk9a17xv2qv2xbsdxbil6ncrrzxcfji9q0civmxhj4vbcfq";

     

       85249
        
              isLibrary = true;

     
···

       85263
        
              testToolDepends = [ hspec-discover ];

     

       85264
        
              description = "Loads environment variables from dotenv files";

     

       85265
        
              license = lib.licenses.mit;

     

       85266
       -
              hydraPlatforms = lib.platforms.none;

     

       85267
        
              mainProgram = "dotenv";

     

       85268
        
            }) {};

     

       85269
        
       

     
···

       85351
        
            }:

     

       85352
        
            mkDerivation {

     

       85353
        
              pname = "double-conversion";

     

       85354
       -
              version = "2.0.4.1";

     

       85355
       -
              sha256 = "1hrpqh8lbw0kkryqsya95mfnnnj0pj7zswxrn6kvfy4rf7z8v2d4";

     

       85356
       -
              revision = "2";

     

       85357
       -
              editedCabalFile = "0qya075j3kz4jq1kx4951qvi9blh6hcqfd7vpcx8l8ql143ajvqs";

     

       85358
       -
              libraryHaskellDepends = [ base bytestring ghc-prim text ];

     

       85359
       -
              testHaskellDepends = [

     

       85360
       -
                base bytestring HUnit test-framework test-framework-hunit

     

       85361
       -
                test-framework-quickcheck2 text

     

       85362
       -
              ];

     

       85363
       -
              description = "Fast conversion between single and double precision floating point and text";

     

       85364
       -
              license = lib.licenses.bsd3;

     

       85365
       -
            }) {};

     

       85366
       -
       

     

       85367
       -
         "double-conversion_2_0_4_2" = callPackage

     

       85368
       -
           ({ mkDerivation, base, bytestring, ghc-prim, HUnit, test-framework

     

       85369
       -
            , test-framework-hunit, test-framework-quickcheck2, text

     

       85370
       -
            }:

     

       85371
       -
            mkDerivation {

     

       85372
       -
              pname = "double-conversion";

     

       85373
        
              version = "2.0.4.2";

     

       85374
        
              sha256 = "0r7c1801gzdm5x1flmpx8ajxygbc9dl7sgdj0xn3bpm71wgvrf4s";

     

       85375
        
              revision = "2";

     
···

       85381
        
              ];

     

       85382
        
              description = "Fast conversion between single and double precision floating point and text";

     

       85383
        
              license = lib.licenses.bsd3;

     

       85384
       -
              hydraPlatforms = lib.platforms.none;

     

       85385
        
            }) {};

     

       85386
        
       

     

       85387
        
         "double-extra" = callPackage

     
···

       86711
        
            }:

     

       86712
        
            mkDerivation {

     

       86713
        
              pname = "dunai";

     

       86714
       -
              version = "0.9.1";

     

       86715
       -
              sha256 = "0krgbs9xqar78815xrgqbj63678jm0mjbsvnqdayh0c2awf9i8bj";

     

       86716
       -
              libraryHaskellDepends = [

     

       86717
       -
                base MonadRandom simple-affine-space transformers transformers-base

     

       86718
       -
              ];

     

       86719
       -
              testHaskellDepends = [ base tasty tasty-hunit transformers ];

     

       86720
       -
              description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";

     

       86721
       -
              license = lib.licenses.bsd3;

     

       86722
       -
              maintainers = [ lib.maintainers.turion ];

     

       86723
       -
            }) {};

     

       86724
       -
       

     

       86725
       -
         "dunai_0_9_2" = callPackage

     

       86726
       -
           ({ mkDerivation, base, MonadRandom, simple-affine-space, tasty

     

       86727
       -
            , tasty-hunit, transformers, transformers-base

     

       86728
       -
            }:

     

       86729
       -
            mkDerivation {

     

       86730
       -
              pname = "dunai";

     

       86731
        
              version = "0.9.2";

     

       86732
        
              sha256 = "08skmwkfwiyy83s764fcpa9i8zny10bdbpv9wha6fjqr1b80i80f";

     

       86733
        
              libraryHaskellDepends = [

     
···

       86736
        
              testHaskellDepends = [ base tasty tasty-hunit transformers ];

     

       86737
        
              description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";

     

       86738
        
              license = lib.licenses.bsd3;

     

       86739
       -
              hydraPlatforms = lib.platforms.none;

     

       86740
        
              maintainers = [ lib.maintainers.turion ];

     

       86741
        
            }) {};

     

       86742
        
       

     
···

       92578
        
            }:

     

       92579
        
            mkDerivation {

     

       92580
        
              pname = "essence-of-live-coding";

     

       92581
       -
              version = "0.2.6";

     

       92582
       -
              sha256 = "0bmcy6j0zw9v7z4sr0m300ckr1mdh3wxj975wbgbl8qlkwsfwv9l";

     

       92583
       -
              isLibrary = true;

     

       92584
       -
              isExecutable = true;

     

       92585
       -
              libraryHaskellDepends = [

     

       92586
       -
                base containers foreign-store mmorph syb time transformers

     

       92587
       -
                vector-sized

     

       92588
       -
              ];

     

       92589
       -
              executableHaskellDepends = [ base transformers ];

     

       92590
       -
              testHaskellDepends = [

     

       92591
       -
                base containers HUnit mtl QuickCheck syb test-framework

     

       92592
       -
                test-framework-hunit test-framework-quickcheck2 transformers

     

       92593
       -
              ];

     

       92594
       -
              description = "General purpose live coding framework";

     

       92595
       -
              license = lib.licenses.bsd3;

     

       92596
       -
              hydraPlatforms = lib.platforms.none;

     

       92597
       -
              maintainers = [ lib.maintainers.turion ];

     

       92598
       -
              broken = true;

     

       92599
       -
            }) {};

     

       92600
       -
       

     

       92601
       -
         "essence-of-live-coding_0_2_7" = callPackage

     

       92602
       -
           ({ mkDerivation, base, containers, foreign-store, HUnit, mmorph

     

       92603
       -
            , mtl, QuickCheck, syb, test-framework, test-framework-hunit

     

       92604
       -
            , test-framework-quickcheck2, time, transformers, vector-sized

     

       92605
       -
            }:

     

       92606
       -
            mkDerivation {

     

       92607
       -
              pname = "essence-of-live-coding";

     

       92608
        
              version = "0.2.7";

     

       92609
        
              sha256 = "1vg10x8radvr8ysqfzf1cngp2hnqy8g139x07pwqwycj9zwwnbl4";

     

       92610
        
              isLibrary = true;

     
···

       92648
        
            }:

     

       92649
        
            mkDerivation {

     

       92650
        
              pname = "essence-of-live-coding-gloss";

     

       92651
       -
              version = "0.2.6";

     

       92652
       -
              sha256 = "02jdi5ijkhf9jc9r5jyqvlk6idmgbjbv3x4yw6ich2m95yhf8hrl";

     

       92653
       -
              libraryHaskellDepends = [

     

       92654
       -
                base essence-of-live-coding foreign-store gloss syb transformers

     

       92655
       -
              ];

     

       92656
       -
              description = "General purpose live coding framework - Gloss backend";

     

       92657
       -
              license = lib.licenses.bsd3;

     

       92658
       -
              hydraPlatforms = lib.platforms.none;

     

       92659
       -
              maintainers = [ lib.maintainers.turion ];

     

       92660
       -
            }) {};

     

       92661
       -
       

     

       92662
       -
         "essence-of-live-coding-gloss_0_2_7" = callPackage

     

       92663
       -
           ({ mkDerivation, base, essence-of-live-coding, foreign-store, gloss

     

       92664
       -
            , syb, transformers

     

       92665
       -
            }:

     

       92666
       -
            mkDerivation {

     

       92667
       -
              pname = "essence-of-live-coding-gloss";

     

       92668
        
              version = "0.2.7";

     

       92669
        
              sha256 = "0iv5wgzfxy1k80dh6c6hrzh4jcjy3ak4l3l004jm3wpfm7fm0lmx";

     

       92670
        
              libraryHaskellDepends = [

     
···

       92702
        
            }:

     

       92703
        
            mkDerivation {

     

       92704
        
              pname = "essence-of-live-coding-pulse";

     

       92705
       -
              version = "0.2.6";

     

       92706
       -
              sha256 = "16fipxz90vlsy9hgksiw7m7r7wzrqrjdhb6fg11m6jlrk1f5bkka";

     

       92707
       -
              libraryHaskellDepends = [

     

       92708
       -
                base essence-of-live-coding foreign-store pulse-simple transformers

     

       92709
       -
              ];

     

       92710
       -
              description = "General purpose live coding framework - pulse backend";

     

       92711
       -
              license = lib.licenses.bsd3;

     

       92712
       -
              hydraPlatforms = lib.platforms.none;

     

       92713
       -
              maintainers = [ lib.maintainers.turion ];

     

       92714
       -
            }) {};

     

       92715
       -
       

     

       92716
       -
         "essence-of-live-coding-pulse_0_2_7" = callPackage

     

       92717
       -
           ({ mkDerivation, base, essence-of-live-coding, foreign-store

     

       92718
       -
            , pulse-simple, transformers

     

       92719
       -
            }:

     

       92720
       -
            mkDerivation {

     

       92721
       -
              pname = "essence-of-live-coding-pulse";

     

       92722
        
              version = "0.2.7";

     

       92723
        
              sha256 = "0bmnc7901zgak223kfm29md0w5fd9lfv4dxc8c27cdcrdqnqfc2p";

     

       92724
        
              libraryHaskellDepends = [

     
···

       92756
        
            }:

     

       92757
        
            mkDerivation {

     

       92758
        
              pname = "essence-of-live-coding-quickcheck";

     

       92759
       -
              version = "0.2.6";

     

       92760
       -
              sha256 = "1hkzp0q0xk3wa892vnjimi7m9gq56m5wx1m2i72ssl6x2jgy52hl";

     

       92761
       -
              libraryHaskellDepends = [

     

       92762
       -
                base boltzmann-samplers essence-of-live-coding QuickCheck syb

     

       92763
       -
                transformers

     

       92764
       -
              ];

     

       92765
       -
              description = "General purpose live coding framework - QuickCheck integration";

     

       92766
       -
              license = lib.licenses.bsd3;

     

       92767
       -
              hydraPlatforms = lib.platforms.none;

     

       92768
       -
              maintainers = [ lib.maintainers.turion ];

     

       92769
       -
            }) {};

     

       92770
       -
       

     

       92771
       -
         "essence-of-live-coding-quickcheck_0_2_7" = callPackage

     

       92772
       -
           ({ mkDerivation, base, boltzmann-samplers, essence-of-live-coding

     

       92773
       -
            , QuickCheck, syb, transformers

     

       92774
       -
            }:

     

       92775
       -
            mkDerivation {

     

       92776
       -
              pname = "essence-of-live-coding-quickcheck";

     

       92777
        
              version = "0.2.7";

     

       92778
        
              sha256 = "0jn5bz7xq8jmlkhrrbn5mj3ywh8288gpx43n8fkjzmzdk233kbvp";

     

       92779
        
              libraryHaskellDepends = [

     
···

       92804
        
            }:

     

       92805
        
            mkDerivation {

     

       92806
        
              pname = "essence-of-live-coding-warp";

     

       92807
       -
              version = "0.2.6";

     

       92808
       -
              sha256 = "0x18jxw0xwqvbwdalbrz4lp2lq9pyl4a5r9vnky5hc5wcwqm2f4m";

     

       92809
       -
              libraryHaskellDepends = [

     

       92810
       -
                base essence-of-live-coding http-types wai warp

     

       92811
       -
              ];

     

       92812
       -
              testHaskellDepends = [

     

       92813
       -
                base bytestring essence-of-live-coding http-client

     

       92814
       -
              ];

     

       92815
       -
              description = "General purpose live coding framework";

     

       92816
       -
              license = lib.licenses.bsd3;

     

       92817
       -
              hydraPlatforms = lib.platforms.none;

     

       92818
       -
              maintainers = [ lib.maintainers.turion ];

     

       92819
       -
            }) {};

     

       92820
       -
       

     

       92821
       -
         "essence-of-live-coding-warp_0_2_7" = callPackage

     

       92822
       -
           ({ mkDerivation, base, bytestring, essence-of-live-coding

     

       92823
       -
            , http-client, http-types, wai, warp

     

       92824
       -
            }:

     

       92825
       -
            mkDerivation {

     

       92826
       -
              pname = "essence-of-live-coding-warp";

     

       92827
        
              version = "0.2.7";

     

       92828
        
              sha256 = "1zykg5qik61xr4ri6d9r04w5rj7wm0wqmnzm6nipwpixal3gdxqa";

     

       92829
        
              libraryHaskellDepends = [

     
···

       94157
        
           ({ mkDerivation, base, template-haskell }:

     

       94158
        
            mkDerivation {

     

       94159
        
              pname = "exception-hierarchy";

     

       94160
       -
              version = "0.1.0.7";

     

       94161
       -
              sha256 = "14kk0rync05rq2adx5lk59y56h97s0yv7mqfn2grhhwqb10maqj0";

     

       94162
       -
              libraryHaskellDepends = [ base template-haskell ];

     

       94163
       -
              description = "Exception type hierarchy with TemplateHaskell";

     

       94164
       -
              license = lib.licenses.bsd3;

     

       94165
       -
            }) {};

     

       94166
       -
       

     

       94167
       -
         "exception-hierarchy_0_1_0_8" = callPackage

     

       94168
       -
           ({ mkDerivation, base, template-haskell }:

     

       94169
       -
            mkDerivation {

     

       94170
       -
              pname = "exception-hierarchy";

     

       94171
        
              version = "0.1.0.8";

     

       94172
        
              sha256 = "17wx40kic0gw5lbz1nr094ps612i0j0pbf0wfj4kgzsl6cj80hih";

     

       94173
        
              libraryHaskellDepends = [ base template-haskell ];

     

       94174
        
              description = "Exception type hierarchy with TemplateHaskell";

     

       94175
        
              license = lib.licenses.bsd3;

     

       94176
       -
              hydraPlatforms = lib.platforms.none;

     

       94177
        
            }) {};

     

       94178
        
       

     

       94179
        
         "exception-mailer" = callPackage

     
···

       94831
        
         "exon" = callPackage

     

       94832
        
           ({ mkDerivation, base, criterion, flatparse, generics-sop

     

       94833
        
            , ghc-hs-meta, hedgehog, incipit-base, tasty, tasty-hedgehog

     

       94834
       -
            , template-haskell, type-errors-pretty

     

       94835
        
            }:

     

       94836
        
            mkDerivation {

     

       94837
        
              pname = "exon";

     

       94838
       -
              version = "1.2.0.0";

     

       94839
       -
              sha256 = "1cayih5rp386cn1ig5g7flxjfh47451h095zx4av4i0c72j6q7s1";

     

       94840
        
              libraryHaskellDepends = [

     

       94841
        
                base flatparse generics-sop ghc-hs-meta incipit-base

     

       94842
       -
                template-haskell type-errors-pretty

     

       94843
        
              ];

     

       94844
        
              testHaskellDepends = [

     

       94845
        
                base hedgehog incipit-base tasty tasty-hedgehog template-haskell

     
···

       94847
        
              benchmarkHaskellDepends = [ base criterion incipit-base ];

     

       94848
        
              description = "Customizable Quasiquote Interpolation";

     

       94849
        
              license = "BSD-2-Clause-Patent";

     

       94850
       -
              hydraPlatforms = lib.platforms.none;

     

       94851
        
            }) {};

     

       94852
        
       

     

       94853
        
         "exotic-list-monads" = callPackage

     
···

       98235
        
              testHaskellDepends = [ base carray QuickCheck storable-complex ];

     

       98236
        
              description = "Bindings to the FFTW library";

     

       98237
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       98238
        
            }) {inherit (pkgs) fftw; inherit (pkgs) fftwFloat;};

     

       98239
        
       

     

       98240
        
         "fftw-ffi" = callPackage

     
···

       99734
        
            }:

     

       99735
        
            mkDerivation {

     

       99736
        
              pname = "fix-whitespace";

     

       99737
       -
              version = "0.0.10";

     

       99738
       -
              sha256 = "1jlkx0ygl315yik0f2fh4ml77c4080y0czs2mlnc84pkhximj58l";

     

       99739
       -
              isLibrary = false;

     

       99740
       -
              isExecutable = true;

     

       99741
       -
              executableHaskellDepends = [

     

       99742
       -
                base directory extra filepath filepattern text yaml

     

       99743
       -
              ];

     

       99744
       -
              description = "Fixes whitespace issues";

     

       99745
       -
              license = "unknown";

     

       99746
       -
              mainProgram = "fix-whitespace";

     

       99747
       -
            }) {};

     

       99748
       -
       

     

       99749
       -
         "fix-whitespace_0_0_11" = callPackage

     

       99750
       -
           ({ mkDerivation, base, directory, extra, filepath, filepattern

     

       99751
       -
            , text, yaml

     

       99752
       -
            }:

     

       99753
       -
            mkDerivation {

     

       99754
       -
              pname = "fix-whitespace";

     

       99755
        
              version = "0.0.11";

     

       99756
        
              sha256 = "0q36vr3pfk1x14hl86g4g557299ih0510j7cf37h8n5nv8bs8gq2";

     

       99757
        
              isLibrary = false;

     
···

       99761
        
              ];

     

       99762
        
              description = "Fixes whitespace issues";

     

       99763
        
              license = "unknown";

     

       99764
       -
              hydraPlatforms = lib.platforms.none;

     

       99765
        
              mainProgram = "fix-whitespace";

     

       99766
        
            }) {};

     

       99767
        
       

     
···

       99886
        
           ({ mkDerivation, base, deepseq, doctest, filemanip, primitive }:

     

       99887
        
            mkDerivation {

     

       99888
        
              pname = "fixed-vector";

     

       99889
       -
              version = "1.2.1.0";

     

       99890
       -
              sha256 = "05x3qivymg02n17wik17fmz2bqbbhj4b0w5iz7vnjz3szhwjizdf";

     

       99891
        
              libraryHaskellDepends = [ base deepseq primitive ];

     

       99892
        
              testHaskellDepends = [ base doctest filemanip primitive ];

     

       99893
        
              description = "Generic vectors with statically known size";

     

       99894
        
              license = lib.licenses.bsd3;

     

       99895
       -
            }) {};

     

       99896
       -
       

     

       99897
       -
         "fixed-vector_1_2_1_1" = callPackage

     

       99898
       -
           ({ mkDerivation, base, deepseq, doctest, filemanip, primitive }:

     

       99899
       -
            mkDerivation {

     

       99900
       -
              pname = "fixed-vector";

     

       99901
       -
              version = "1.2.1.1";

     

       99902
       -
              sha256 = "1gf3gpdl92yb7s68d39wmj7h9ivm925ix3yb7l5x0ljdw5xjldki";

     

       99903
       -
              libraryHaskellDepends = [ base deepseq primitive ];

     

       99904
       -
              testHaskellDepends = [ base doctest filemanip primitive ];

     

       99905
       -
              description = "Generic vectors with statically known size";

     

       99906
       -
              license = lib.licenses.bsd3;

     

       99907
       -
              hydraPlatforms = lib.platforms.none;

     

       99908
        
            }) {};

     

       99909
        
       

     

       99910
        
         "fixed-vector-binary" = callPackage

     
···

       123632
        
              pname = "hackage-security-HTTP";

     

       123633
        
              version = "0.1.1.1";

     

       123634
        
              sha256 = "14hp7gssf80b9937j7m56w8sxrv3hrzjf2s9kgfk76v6llgx79k2";

     

       123635
       -
              revision = "3";

     

       123636
       -
              editedCabalFile = "14cypbxm6njhxwxps9ac80nf1j00vgh9bwcyxx9h74z5hi7wdld2";

     

       123637
        
              libraryHaskellDepends = [

     

       123638
        
                base bytestring hackage-security HTTP mtl network network-uri zlib

     

       123639
        
              ];

     
···

       126771
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       126772
        
            mkDerivation {

     

       126773
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       126774
       -
              version = "0.0.0.3";

     

       126775
       -
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       126776
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       126777
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       126778
        
              license = lib.licenses.mit;

     
···

       128998
        
           ({ mkDerivation, base }:

     

       128999
        
            mkDerivation {

     

       129000
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       129001
       -
              version = "1.1";

     

       129002
       -
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       129003
       -
              libraryHaskellDepends = [ base ];

     

       129004
       -
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       129005
       -
              license = lib.licenses.bsd3;

     

       129006
       -
            }) {};

     

       129007
       -
       

     

       129008
       -
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       129009
       -
           ({ mkDerivation, base }:

     

       129010
       -
            mkDerivation {

     

       129011
       -
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       129012
        
              version = "1.1.1";

     

       129013
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       129014
        
              libraryHaskellDepends = [ base ];

     

       129015
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       129016
        
              license = lib.licenses.mit;

     

       129017
       -
              hydraPlatforms = lib.platforms.none;

     

       129018
        
            }) {};

     

       129019
        
       

     

       129020
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     
···

       135131
        
            }:

     

       135132
        
            mkDerivation {

     

       135133
        
              pname = "hedgehog-classes";

     

       135134
       -
              version = "0.2.5.3";

     

       135135
       -
              sha256 = "1qanfnvciykm5hmiqyf0icn4xn16v6zvlfal98lphhcmym26m9x1";

     

       135136
       -
              revision = "3";

     

       135137
       -
              editedCabalFile = "09khb9px24zj24ahb51w1a6glgmcnhk2xn89gn1qwzhs3xn4vlj5";

     

       135138
       -
              libraryHaskellDepends = [

     

       135139
       -
                aeson base binary comonad containers hedgehog pretty-show primitive

     

       135140
       -
                semirings silently transformers vector wl-pprint-annotated

     

       135141
       -
              ];

     

       135142
       -
              testHaskellDepends = [

     

       135143
       -
                aeson base binary comonad containers hedgehog vector

     

       135144
       -
              ];

     

       135145
       -
              description = "Hedgehog will eat your typeclass bugs";

     

       135146
       -
              license = lib.licenses.bsd3;

     

       135147
       -
            }) {};

     

       135148
       -
       

     

       135149
       -
         "hedgehog-classes_0_2_5_4" = callPackage

     

       135150
       -
           ({ mkDerivation, aeson, base, binary, comonad, containers, hedgehog

     

       135151
       -
            , pretty-show, primitive, semirings, silently, transformers, vector

     

       135152
       -
            , wl-pprint-annotated

     

       135153
       -
            }:

     

       135154
       -
            mkDerivation {

     

       135155
       -
              pname = "hedgehog-classes";

     

       135156
        
              version = "0.2.5.4";

     

       135157
        
              sha256 = "0z9ik5asddc2pnz430jsi1pyahkh6jy36ng0vwm7ywcq7cvhcvlz";

     

       135158
        
              libraryHaskellDepends = [

     
···

       135164
        
              ];

     

       135165
        
              description = "Hedgehog will eat your typeclass bugs";

     

       135166
        
              license = lib.licenses.bsd3;

     

       135167
       -
              hydraPlatforms = lib.platforms.none;

     

       135168
        
            }) {};

     

       135169
        
       

     

       135170
        
         "hedgehog-corpus" = callPackage

     
···

       136226
        
            }:

     

       136227
        
            mkDerivation {

     

       136228
        
              pname = "hercules-ci-agent";

     

       136229
       -
              version = "0.9.9";

     

       136230
       -
              sha256 = "1havsghzsbicixb8cya0v1694l7r9n2frnmy297ar3chblfj8hgl";

     

       136231
        
              isLibrary = true;

     

       136232
        
              isExecutable = true;

     

       136233
        
              enableSeparateDataOutput = true;

     
···

       136280
        
            }:

     

       136281
        
            mkDerivation {

     

       136282
        
              pname = "hercules-ci-api";

     

       136283
       -
              version = "0.7.2.0";

     

       136284
       -
              sha256 = "0z3j96il0rvzplxih4vq5dghp18plbk5k55ymwm7dxp51d0jg902";

     

       136285
        
              isLibrary = true;

     

       136286
        
              isExecutable = true;

     

       136287
        
              libraryHaskellDepends = [

     
···

       136313
        
            }:

     

       136314
        
            mkDerivation {

     

       136315
        
              pname = "hercules-ci-api-agent";

     

       136316
       -
              version = "0.4.6.0";

     

       136317
       -
              sha256 = "0bdmz7c4ln2bbss5wa4q8k9wha47knnp9d9n3w9kj8p7wzhc2kly";

     

       136318
        
              libraryHaskellDepends = [

     

       136319
        
                aeson base base64-bytestring-type bytestring containers cookie

     

       136320
        
                deepseq exceptions hashable hercules-ci-api-core http-api-data

     
···

       136362
        
            , hercules-ci-api, hercules-ci-api-agent, hercules-ci-api-core

     

       136363
        
            , hercules-ci-cnix-expr, hercules-ci-cnix-store

     

       136364
        
            , hercules-ci-optparse-applicative, hostname, hspec, http-client

     

       136365
       -
            , http-client-tls, http-types, katip, lens, lens-aeson, lifted-base

     

       136366
       -
            , monad-control, network-uri, process, protolude, QuickCheck, retry

     

       136367
       -
            , rio, safe-exceptions, servant, servant-auth-client

     

       136368
       -
            , servant-client, servant-client-core, servant-conduit, temporary

     

       136369
       -
            , text, transformers, transformers-base, unix, unliftio

     

       136370
       -
            , unliftio-core, unordered-containers, uuid

     

       136371
        
            }:

     

       136372
        
            mkDerivation {

     

       136373
        
              pname = "hercules-ci-cli";

     

       136374
       -
              version = "0.3.4";

     

       136375
       -
              sha256 = "1n79ka1bn99vqa8i14f94zs4b78vl2pidx0h8nrdvg1xclqa5fka";

     

       136376
        
              isLibrary = true;

     

       136377
        
              isExecutable = true;

     

       136378
        
              libraryHaskellDepends = [

     
···

       136381
        
                hercules-ci-agent hercules-ci-api hercules-ci-api-agent

     

       136382
        
                hercules-ci-api-core hercules-ci-cnix-expr hercules-ci-cnix-store

     

       136383
        
                hercules-ci-optparse-applicative hostname http-client

     

       136384
       -
                http-client-tls http-types katip lens lens-aeson lifted-base

     

       136385
       -
                monad-control network-uri process protolude retry rio

     

       136386
        
                safe-exceptions servant servant-auth-client servant-client

     

       136387
        
                servant-client-core servant-conduit temporary text transformers

     

       136388
        
                transformers-base unix unliftio unliftio-core unordered-containers

     
···

       136411
        
            }:

     

       136412
        
            mkDerivation {

     

       136413
        
              pname = "hercules-ci-cnix-expr";

     

       136414
       -
              version = "0.3.4.0";

     

       136415
       -
              sha256 = "1mszhnd2z0qy58x13w5nbw3ymqvd8vf0d4kh3bprrjlbll0rxmgn";

     

       136416
        
              enableSeparateDataOutput = true;

     

       136417
        
              setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ];

     

       136418
        
              libraryHaskellDepends = [

     
···

       136441
        
            }:

     

       136442
        
            mkDerivation {

     

       136443
        
              pname = "hercules-ci-cnix-store";

     

       136444
       -
              version = "0.3.3.2";

     

       136445
       -
              sha256 = "11z6k9r8z2bvf0wly6b0fr0s3svbrf1rgz0v2in33jq6739lci92";

     

       136446
        
              setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ];

     

       136447
        
              libraryHaskellDepends = [

     

       136448
        
                base bytestring conduit containers inline-c inline-c-cpp protolude

     
···

       136876
        
           ({ mkDerivation, abstract-par, aeson, ansi-wl-pprint, array, async

     

       136877
        
            , base, base16-bytestring, binary, brick, bytestring, cereal

     

       136878
        
            , containers, cryptonite, data-dword, Decimal, deepseq, directory

     

       136879
       -
            , fgl, filepath, free, haskeline, here, HUnit, lens, lens-aeson

     

       136880
       -
            , libff, megaparsec, memory, monad-par, mtl, multiset, operational

     

       136881
       -
            , optparse-generic, parsec, process, QuickCheck

     

       136882
        
            , quickcheck-instances, quickcheck-text, regex, regex-tdfa

     

       136883
        
            , restless-git, rosezipper, s-cargot, scientific, secp256k1

     

       136884
        
            , semver-range, smt2-parser, spool, tasty, tasty-expected-failure

     
···

       136888
        
            }:

     

       136889
        
            mkDerivation {

     

       136890
        
              pname = "hevm";

     

       136891
       -
              version = "0.50.0";

     

       136892
       -
              sha256 = "0wdp7vl1aq79k8sw7n4mf6wv184as0pmprdffzklzkcskvs9yjmb";

     

       136893
        
              isLibrary = true;

     

       136894
        
              isExecutable = true;

     

       136895
       -
              enableSeparateDataOutput = true;

     

       136896
        
              libraryHaskellDepends = [

     

       136897
        
                abstract-par aeson ansi-wl-pprint array async base

     

       136898
        
                base16-bytestring binary brick bytestring cereal containers

     

       136899
       -
                cryptonite data-dword Decimal deepseq directory fgl filepath free

     

       136900
       -
                haskeline here HUnit lens lens-aeson megaparsec memory monad-par

     

       136901
       -
                mtl multiset operational optparse-generic parsec process QuickCheck

     

       136902
       -
                quickcheck-instances quickcheck-text regex regex-tdfa restless-git

     

       136903
       -
                rosezipper s-cargot scientific semver-range smt2-parser spool tasty

     

       136904
       -
                tasty-expected-failure tasty-hunit tasty-quickcheck temporary text

     

       136905
       -
                time transformers tree-view tuple unordered-containers vector vty

     

       136906
       -
                witherable word-wrap wreq

     

       136907
        
              ];

     

       136908
        
              librarySystemDepends = [ libff secp256k1 ];

     

       136909
        
              executableHaskellDepends = [

     
···

       136914
        
                temporary text unordered-containers vector vty

     

       136915
        
              ];

     

       136916
        
              testHaskellDepends = [

     

       136917
       -
                array base base16-bytestring binary bytestring containers

     

       136918
       -
                data-dword directory here HUnit lens mtl process QuickCheck

     

       136919
       -
                quickcheck-instances regex regex-tdfa smt2-parser tasty

     

       136920
        
                tasty-expected-failure tasty-hunit tasty-quickcheck temporary text

     

       136921
       -
                time vector

     

       136922
        
              ];

     

       136923
        
              testSystemDepends = [ secp256k1 ];

     

       136924
        
              doHaddock = false;

     

       136925
        
              description = "Ethereum virtual machine evaluator";

     

       136926
        
              license = lib.licenses.agpl3Only;

     

       136927
       -
              hydraPlatforms = lib.platforms.none;

     

       136928
        
              mainProgram = "hevm";

     

       136929
        
              maintainers = [ lib.maintainers.arturcygan ];

     

       136930
       -
              broken = true;

     

       136931
        
            }) {inherit (pkgs) libff; inherit (pkgs) secp256k1;};

     

       136932
        
       

     

       136933
        
         "hevolisa" = callPackage

     
···

       141252
        
              ];

     

       141253
        
              description = "Call hierarchy plugin for Haskell Language Server";

     

       141254
        
              license = lib.licenses.asl20;

     

       0
        
       
     

       0
        
       
     

       141255
        
            }) {};

     

       141256
        
       

     

       141257
        
         "hls-change-type-signature-plugin" = callPackage

     
···

       144406
        
            }:

     

       144407
        
            mkDerivation {

     

       144408
        
              pname = "horizon-gen-nix";

     

       144409
       -
              version = "0.3.1.0";

     

       144410
       -
              sha256 = "1by0813yzhnzl188b7sdcy682arprhgahnivpqxkm1pfk2im92i9";

     

       144411
        
              isLibrary = true;

     

       144412
        
              isExecutable = true;

     

       144413
        
              libraryHaskellDepends = [

     
···

       144841
        
              mainProgram = "hp2pretty";

     

       144842
        
            }) {};

     

       144843
        
       

     

       144844
       -
         "hpack" = callPackage

     

       144845
        
           ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal

     

       144846
        
            , containers, cryptonite, deepseq, directory, filepath, Glob, hspec

     

       144847
        
            , hspec-discover, http-client, http-client-tls, http-types, HUnit

     
···

       144879
        
              testToolDepends = [ hspec-discover ];

     

       144880
        
              description = "A modern format for Haskell packages";

     

       144881
        
              license = lib.licenses.mit;

     

       0
        
       
     

       144882
        
              mainProgram = "hpack";

     

       144883
        
            }) {};

     

       144884
        
       

     

       144885
       -
         "hpack_0_35_1" = callPackage

     

       144886
        
           ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal

     

       144887
        
            , containers, cryptonite, deepseq, directory, filepath, Glob, hspec

     

       144888
        
            , hspec-discover, http-client, http-client-tls, http-types, HUnit

     
···

       144918
        
              testToolDepends = [ hspec-discover ];

     

       144919
        
              description = "A modern format for Haskell packages";

     

       144920
        
              license = lib.licenses.mit;

     

       144921
       -
              hydraPlatforms = lib.platforms.none;

     

       144922
        
              mainProgram = "hpack";

     

       144923
        
            }) {};

     

       144924
        
       

     
···

       155413
        
            }:

     

       155414
        
            mkDerivation {

     

       155415
        
              pname = "hw-json-simd";

     

       155416
       -
              version = "0.1.1.1";

     

       155417
       -
              sha256 = "0nn6fyvw0j2csn8anqpgjzdzdasiwa99g1v2qrcyym1wi86biqqb";

     

       155418
       -
              revision = "1";

     

       155419
       -
              editedCabalFile = "0cavymml55m8f1zyh8pby44xq67ckdqdy0wgib8i0xjq00hrp07m";

     

       155420
       -
              isLibrary = true;

     

       155421
       -
              isExecutable = true;

     

       155422
       -
              libraryHaskellDepends = [ base bytestring hw-prim lens vector ];

     

       155423
       -
              libraryToolDepends = [ c2hs ];

     

       155424
       -
              executableHaskellDepends = [

     

       155425
       -
                base bytestring hw-prim lens optparse-applicative vector

     

       155426
       -
              ];

     

       155427
       -
              testHaskellDepends = [

     

       155428
       -
                base bytestring doctest doctest-discover hw-prim lens transformers

     

       155429
       -
                vector

     

       155430
       -
              ];

     

       155431
       -
              testToolDepends = [ doctest-discover ];

     

       155432
       -
              description = "SIMD-based JSON semi-indexer";

     

       155433
       -
              license = lib.licenses.bsd3;

     

       155434
       -
              mainProgram = "hw-json-simd";

     

       155435
       -
            }) {};

     

       155436
       -
       

     

       155437
       -
         "hw-json-simd_0_1_1_2" = callPackage

     

       155438
       -
           ({ mkDerivation, base, bytestring, c2hs, doctest, doctest-discover

     

       155439
       -
            , hw-prim, lens, optparse-applicative, transformers, vector

     

       155440
       -
            }:

     

       155441
       -
            mkDerivation {

     

       155442
       -
              pname = "hw-json-simd";

     

       155443
        
              version = "0.1.1.2";

     

       155444
        
              sha256 = "03g2gwmkp6v7b0vf4x8bh4qk91ghr0av5x3c9paj3rp3igycccd6";

     

       155445
        
              isLibrary = true;

     
···

       155456
        
              testToolDepends = [ doctest-discover ];

     

       155457
        
              description = "SIMD-based JSON semi-indexer";

     

       155458
        
              license = lib.licenses.bsd3;

     

       155459
       -
              hydraPlatforms = lib.platforms.none;

     

       155460
        
              mainProgram = "hw-json-simd";

     

       155461
        
            }) {};

     

       155462
        
       

     
···

       155882
        
            }:

     

       155883
        
            mkDerivation {

     

       155884
        
              pname = "hw-simd";

     

       155885
       -
              version = "0.1.2.1";

     

       155886
       -
              sha256 = "051dbwi4kvv04dnglcx9666g097fy9rw8kmgbcw5y9cs06mbw9cr";

     

       155887
       -
              revision = "2";

     

       155888
       -
              editedCabalFile = "10ns52d5xzry7bkaaggv5sgry44fxl9jpyx48iafyfpcn3h8439k";

     

       155889
       -
              libraryHaskellDepends = [

     

       155890
       -
                base bits-extra bytestring deepseq hw-bits hw-prim hw-rankselect

     

       155891
       -
                hw-rankselect-base transformers vector

     

       155892
       -
              ];

     

       155893
       -
              libraryToolDepends = [ c2hs ];

     

       155894
       -
              testHaskellDepends = [

     

       155895
       -
                base bits-extra bytestring deepseq directory doctest

     

       155896
       -
                doctest-discover hedgehog hspec hw-bits hw-hedgehog

     

       155897
       -
                hw-hspec-hedgehog hw-prim hw-rankselect hw-rankselect-base lens

     

       155898
       -
                text vector

     

       155899
       -
              ];

     

       155900
       -
              testToolDepends = [ doctest-discover hspec-discover ];

     

       155901
       -
              benchmarkHaskellDepends = [

     

       155902
       -
                base bits-extra bytestring cassava containers criterion deepseq

     

       155903
       -
                directory hw-bits hw-prim hw-rankselect hw-rankselect-base mmap

     

       155904
       -
                transformers vector

     

       155905
       -
              ];

     

       155906
       -
              description = "SIMD library";

     

       155907
       -
              license = lib.licenses.bsd3;

     

       155908
       -
            }) {};

     

       155909
       -
       

     

       155910
       -
         "hw-simd_0_1_2_2" = callPackage

     

       155911
       -
           ({ mkDerivation, base, bits-extra, bytestring, c2hs, cassava

     

       155912
       -
            , containers, criterion, deepseq, directory, doctest

     

       155913
       -
            , doctest-discover, hedgehog, hspec, hspec-discover, hw-bits

     

       155914
       -
            , hw-hedgehog, hw-hspec-hedgehog, hw-prim, hw-rankselect

     

       155915
       -
            , hw-rankselect-base, lens, mmap, text, transformers, vector

     

       155916
       -
            }:

     

       155917
       -
            mkDerivation {

     

       155918
       -
              pname = "hw-simd";

     

       155919
        
              version = "0.1.2.2";

     

       155920
        
              sha256 = "0ipcrv19xwmq6znbmwmzrjahmymmcmpbs7hpx0183hrwbx2hyhqx";

     

       155921
        
              libraryHaskellDepends = [

     
···

       155937
        
              ];

     

       155938
        
              description = "SIMD library";

     

       155939
        
              license = lib.licenses.bsd3;

     

       155940
       -
              hydraPlatforms = lib.platforms.none;

     

       155941
        
            }) {};

     

       155942
        
       

     

       155943
        
         "hw-simd-cli" = callPackage

     
···

       159791
        
            }:

     

       159792
        
            mkDerivation {

     

       159793
        
              pname = "incipit";

     

       159794
       -
              version = "0.5.0.0";

     

       159795
       -
              sha256 = "137i92xfpchyvnrckb8876cxw514zxf53hbzqyyj6f4mipiq319j";

     

       159796
        
              libraryHaskellDepends = [

     

       159797
        
                base incipit-core polysemy-conc polysemy-log polysemy-resume

     

       159798
        
                polysemy-time

     
···

       159808
        
            }:

     

       159809
        
            mkDerivation {

     

       159810
        
              pname = "incipit-base";

     

       159811
       -
              version = "0.4.0.0";

     

       159812
       -
              sha256 = "08r934qii1hc7hb3xmk7mpw0srh82h2djxkh55gskm7wbaby15qi";

     

       159813
        
              libraryHaskellDepends = [

     

       159814
        
                base bytestring containers data-default stm text

     

       159815
        
              ];

     
···

       159821
        
           ({ mkDerivation, base, incipit-base, polysemy }:

     

       159822
        
            mkDerivation {

     

       159823
        
              pname = "incipit-core";

     

       159824
       -
              version = "0.4.0.0";

     

       159825
       -
              sha256 = "0nh1ivn74fcciwmvnqdr1h1vdhxxy3xjf2bzsdm1dpyylglcaspr";

     

       159826
        
              libraryHaskellDepends = [ base incipit-base polysemy ];

     

       159827
        
              description = "A Prelude for Polysemy";

     

       159828
        
              license = "BSD-2-Clause-Patent";

     
···

       165892
        
              ];

     

       165893
        
              description = "OpenAPI Definitions for Jordan, Automatically";

     

       165894
        
              license = lib.licenses.mit;

     

       0
        
       
     

       165895
        
            }) {};

     

       165896
        
       

     

       165897
        
         "jordan-servant" = callPackage

     
···

       165961
        
              ];

     

       165962
        
              description = "OpenAPI schemas for Jordan-Powered Servant APIs";

     

       165963
        
              license = lib.licenses.mit;

     

       0
        
       
     

       165964
        
            }) {};

     

       165965
        
       

     

       165966
        
         "jordan-servant-server" = callPackage

     
···

       184065
        
            }:

     

       184066
        
            mkDerivation {

     

       184067
        
              pname = "lzma-static";

     

       184068
       -
              version = "5.2.5.4";

     

       184069
       -
              sha256 = "0ql96kb7hg50d1flk36999p5p05bqs7rp7a59ys4q02423mq1z7b";

     

       184070
       -
              revision = "2";

     

       184071
       -
              editedCabalFile = "0dvqqjihfzkcqaahicga0cnimcwh197dpj8spqrk9mmicmqs5gcr";

     

       184072
        
              libraryHaskellDepends = [ base bytestring ];

     

       184073
        
              testHaskellDepends = [

     

       184074
        
                base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck

     
···

       186385
        
         "massiv" = callPackage

     

       186386
        
           ({ mkDerivation, base, bytestring, deepseq, doctest, exceptions

     

       186387
        
            , primitive, random, scheduler, unliftio-core, vector

     

       186388
       -
            }:

     

       186389
       -
            mkDerivation {

     

       186390
       -
              pname = "massiv";

     

       186391
       -
              version = "1.0.2.0";

     

       186392
       -
              sha256 = "15ckrsavsrkgm4c9al2jlk1r4nm2mdjshw1ksbkh8m65l3l5kcrr";

     

       186393
       -
              libraryHaskellDepends = [

     

       186394
       -
                base bytestring deepseq exceptions primitive random scheduler

     

       186395
       -
                unliftio-core vector

     

       186396
       -
              ];

     

       186397
       -
              testHaskellDepends = [ base doctest ];

     

       186398
       -
              description = "Massiv (Массив) is an Array Library";

     

       186399
       -
              license = lib.licenses.bsd3;

     

       186400
       -
            }) {};

     

       186401
       -
       

     

       186402
       -
         "massiv_1_0_3_0" = callPackage

     

       186403
       -
           ({ mkDerivation, base, bytestring, deepseq, doctest, exceptions

     

       186404
       -
            , primitive, random, scheduler, unliftio-core, vector

     

       186405
        
            , vector-stream

     

       186406
        
            }:

     

       186407
        
            mkDerivation {

     
···

       186415
        
              testHaskellDepends = [ base doctest ];

     

       186416
        
              description = "Massiv (Массив) is an Array Library";

     

       186417
        
              license = lib.licenses.bsd3;

     

       186418
       -
              hydraPlatforms = lib.platforms.none;

     

       186419
        
            }) {};

     

       186420
        
       

     

       186421
        
         "massiv-io" = callPackage

     
···

       189794
        
           ({ mkDerivation, base, microlens }:

     

       189795
        
            mkDerivation {

     

       189796
        
              pname = "microlens-contra";

     

       189797
       -
              version = "0.1.0.2";

     

       189798
       -
              sha256 = "1ny9qhvd7rfzdkq4jdcgh4mfia856rsgpdhg8lprfprh6p7lhy5m";

     

       189799
       -
              libraryHaskellDepends = [ base microlens ];

     

       189800
       -
              description = "True folds and getters for microlens";

     

       189801
       -
              license = lib.licenses.bsd3;

     

       189802
       -
            }) {};

     

       189803
       -
       

     

       189804
       -
         "microlens-contra_0_1_0_3" = callPackage

     

       189805
       -
           ({ mkDerivation, base, microlens }:

     

       189806
       -
            mkDerivation {

     

       189807
       -
              pname = "microlens-contra";

     

       189808
        
              version = "0.1.0.3";

     

       189809
        
              sha256 = "1jxm6shmvacbic6i6hask0kv89kramnk77pcxpv4gv4xydjsr88n";

     

       189810
        
              libraryHaskellDepends = [ base microlens ];

     

       189811
        
              description = "True folds and getters for microlens";

     

       189812
        
              license = lib.licenses.bsd3;

     

       189813
       -
              hydraPlatforms = lib.platforms.none;

     

       189814
        
            }) {};

     

       189815
        
       

     

       189816
        
         "microlens-each" = callPackage

     
···

       189863
        
            }:

     

       189864
        
            mkDerivation {

     

       189865
        
              pname = "microlens-mtl";

     

       189866
       -
              version = "0.2.0.2";

     

       189867
       -
              sha256 = "0y1jli9379l8sgv5a4xl8v3qkz9fkp4qlfsywzdpywbnydl1d5v6";

     

       189868
       -
              libraryHaskellDepends = [

     

       189869
       -
                base microlens mtl transformers transformers-compat

     

       189870
       -
              ];

     

       189871
       -
              description = "microlens support for Reader/Writer/State from mtl";

     

       189872
       -
              license = lib.licenses.bsd3;

     

       189873
       -
            }) {};

     

       189874
       -
       

     

       189875
       -
         "microlens-mtl_0_2_0_3" = callPackage

     

       189876
       -
           ({ mkDerivation, base, microlens, mtl, transformers

     

       189877
       -
            , transformers-compat

     

       189878
       -
            }:

     

       189879
       -
            mkDerivation {

     

       189880
       -
              pname = "microlens-mtl";

     

       189881
        
              version = "0.2.0.3";

     

       189882
        
              sha256 = "1ilz0zyyk9f6h97gjsaqq65njfs23fk3wxhigvj4z0brf7rnlssd";

     

       189883
        
              libraryHaskellDepends = [

     
···

       189885
        
              ];

     

       189886
        
              description = "microlens support for Reader/Writer/State from mtl";

     

       189887
        
              license = lib.licenses.bsd3;

     

       189888
       -
              hydraPlatforms = lib.platforms.none;

     

       189889
        
            }) {};

     

       189890
        
       

     

       189891
        
         "microlens-platform" = callPackage

     
···

       189944
        
            }:

     

       189945
        
            mkDerivation {

     

       189946
        
              pname = "microlens-th";

     

       189947
       -
              version = "0.4.3.10";

     

       189948
       -
              sha256 = "1dg2xhj85fy8q39m5dd94kjlabjyxgc0336vzkg0174l6l110l1c";

     

       189949
       -
              revision = "1";

     

       189950
       -
              editedCabalFile = "142wksvc854qmd665qd6mwzik8g02yzfpjk1fpxw4mlcns06y4m2";

     

       189951
       -
              libraryHaskellDepends = [

     

       189952
       -
                base containers microlens template-haskell th-abstraction

     

       189953
       -
                transformers

     

       189954
       -
              ];

     

       189955
       -
              testHaskellDepends = [ base microlens tagged ];

     

       189956
       -
              description = "Automatic generation of record lenses for microlens";

     

       189957
       -
              license = lib.licenses.bsd3;

     

       189958
       -
            }) {};

     

       189959
       -
       

     

       189960
       -
         "microlens-th_0_4_3_11" = callPackage

     

       189961
       -
           ({ mkDerivation, base, containers, microlens, tagged

     

       189962
       -
            , template-haskell, th-abstraction, transformers

     

       189963
       -
            }:

     

       189964
       -
            mkDerivation {

     

       189965
       -
              pname = "microlens-th";

     

       189966
        
              version = "0.4.3.11";

     

       189967
        
              sha256 = "1vjjaclfxr0kvlpmj8zh7f6ci4n4b8vynqd67zszx42al7gal6pj";

     

       189968
        
              libraryHaskellDepends = [

     
···

       189972
        
              testHaskellDepends = [ base microlens tagged ];

     

       189973
        
              description = "Automatic generation of record lenses for microlens";

     

       189974
        
              license = lib.licenses.bsd3;

     

       189975
       -
              hydraPlatforms = lib.platforms.none;

     

       189976
        
            }) {};

     

       189977
        
       

     

       189978
        
         "micrologger" = callPackage

     
···

       194588
        
            }:

     

       194589
        
            mkDerivation {

     

       194590
        
              pname = "monoid-extras";

     

       194591
       -
              version = "0.6.1";

     

       194592
       -
              sha256 = "1nj5rfax9lmr1pprvgdgq90am9mknx9iv7s84smv6qaw050356jf";

     

       194593
       -
              revision = "2";

     

       194594
       -
              editedCabalFile = "04zbzq7dbv0ddpc1dxrxn9jfyg1xj8sar6ngzhc0cji72cail503";

     

       194595
       -
              libraryHaskellDepends = [ base groups semigroupoids ];

     

       194596
       -
              benchmarkHaskellDepends = [ base criterion semigroups ];

     

       194597
       -
              description = "Various extra monoid-related definitions and utilities";

     

       194598
       -
              license = lib.licenses.bsd3;

     

       194599
       -
            }) {};

     

       194600
       -
       

     

       194601
       -
         "monoid-extras_0_6_2" = callPackage

     

       194602
       -
           ({ mkDerivation, base, criterion, groups, semigroupoids, semigroups

     

       194603
       -
            }:

     

       194604
       -
            mkDerivation {

     

       194605
       -
              pname = "monoid-extras";

     

       194606
        
              version = "0.6.2";

     

       194607
        
              sha256 = "1qaxp0cf2cvzvfpk7x9mjz1zmlpjfzxij8v2n45w89s7bq9ckvlw";

     

       194608
        
              libraryHaskellDepends = [ base groups semigroupoids ];

     

       194609
        
              benchmarkHaskellDepends = [ base criterion semigroups ];

     

       194610
        
              description = "Various extra monoid-related definitions and utilities";

     

       194611
        
              license = lib.licenses.bsd3;

     

       194612
       -
              hydraPlatforms = lib.platforms.none;

     

       194613
        
            }) {};

     

       194614
        
       

     

       194615
        
         "monoid-map" = callPackage

     
···

       194840
        
            }:

     

       194841
        
            mkDerivation {

     

       194842
        
              pname = "monomer-hagrid";

     

       194843
       -
              version = "0.2.0.0";

     

       194844
       -
              sha256 = "160d4acqrrxhlbx85749vm02c01sz7lxp8gxnykv1f0f00bb8w67";

     

       194845
        
              isLibrary = true;

     

       194846
        
              isExecutable = true;

     

       194847
        
              libraryHaskellDepends = [

     
···

       197610
        
              hydraPlatforms = lib.platforms.none;

     

       197611
        
            }) {};

     

       197612
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       197613
        
         "multifile" = callPackage

     

       197614
        
           ({ mkDerivation, base, directory, HaXml, optparse-applicative

     

       197615
        
            , pretty, process, transformers

     
···

       199873
        
            }) {};

     

       199874
        
       

     

       199875
        
         "named-text" = callPackage

     

       199876
       -
           ({ mkDerivation, base, deepseq, hashable, prettyprinter, sayable

     

       199877
       -
            , text

     

       0
        
       
     

       199878
        
            }:

     

       199879
        
            mkDerivation {

     

       199880
        
              pname = "named-text";

     

       199881
       -
              version = "1.0.1.0";

     

       199882
       -
              sha256 = "05v79ry6rlrpfvf36nkzf6l4xm2kzgpdrvaivg878nxcrni1gr78";

     

       199883
        
              libraryHaskellDepends = [

     

       199884
       -
                base deepseq hashable prettyprinter sayable text

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       199885
        
              ];

     

       199886
        
              description = "A parameterized named text type and associated functionality";

     

       199887
        
              license = lib.licenses.isc;

     

       0
        
       
     

       199888
        
            }) {};

     

       199889
        
       

     

       199890
        
         "namelist" = callPackage

     
···

       202720
        
            }:

     

       202721
        
            mkDerivation {

     

       202722
        
              pname = "network-uri";

     

       202723
       -
              version = "2.6.4.1";

     

       202724
       -
              sha256 = "111m485rx2kyqdymi1x6sl08hi6lp34q3f41yqcx99086swnv1ap";

     

       202725
       -
              libraryHaskellDepends = [

     

       202726
       -
                base deepseq parsec template-haskell th-compat

     

       202727
       -
              ];

     

       202728
       -
              testHaskellDepends = [

     

       202729
       -
                base HUnit QuickCheck tasty tasty-hunit tasty-quickcheck

     

       202730
       -
              ];

     

       202731
       -
              benchmarkHaskellDepends = [ base criterion deepseq HUnit ];

     

       202732
       -
              description = "URI manipulation";

     

       202733
       -
              license = lib.licenses.bsd3;

     

       202734
       -
            }) {};

     

       202735
       -
       

     

       202736
       -
         "network-uri_2_6_4_2" = callPackage

     

       202737
       -
           ({ mkDerivation, base, criterion, deepseq, HUnit, parsec

     

       202738
       -
            , QuickCheck, tasty, tasty-hunit, tasty-quickcheck

     

       202739
       -
            , template-haskell, th-compat

     

       202740
       -
            }:

     

       202741
       -
            mkDerivation {

     

       202742
       -
              pname = "network-uri";

     

       202743
        
              version = "2.6.4.2";

     

       202744
        
              sha256 = "0a3jg6aykwm1yw32nh137hi6r86w2640xwl1p18352bf29rqj64w";

     

       202745
        
              libraryHaskellDepends = [

     
···

       202751
        
              benchmarkHaskellDepends = [ base criterion deepseq HUnit ];

     

       202752
        
              description = "URI manipulation";

     

       202753
        
              license = lib.licenses.bsd3;

     

       202754
       -
              hydraPlatforms = lib.platforms.none;

     

       202755
        
            }) {};

     

       202756
        
       

     

       202757
        
         "network-uri-flag" = callPackage

     
···

       206418
        
            }:

     

       206419
        
            mkDerivation {

     

       206420
        
              pname = "nvim-hs";

     

       206421
       -
              version = "2.3.1.0";

     

       206422
       -
              sha256 = "1vgdvcvjyl7dxmvmcljb130gwp806769hks00fj1sqfi953lm9bf";

     

       206423
       -
              libraryHaskellDepends = [

     

       206424
       -
                base bytestring cereal cereal-conduit conduit containers

     

       206425
       -
                data-default deepseq foreign-store hslogger megaparsec messagepack

     

       206426
       -
                mtl network optparse-applicative path path-io prettyprinter

     

       206427
       -
                prettyprinter-ansi-terminal resourcet stm streaming-commons

     

       206428
       -
                template-haskell template-haskell-compat-v0208 text time

     

       206429
       -
                time-locale-compat transformers transformers-base typed-process

     

       206430
       -
                unliftio unliftio-core utf8-string vector void

     

       206431
       -
              ];

     

       206432
       -
              testHaskellDepends = [

     

       206433
       -
                base bytestring cereal cereal-conduit conduit containers

     

       206434
       -
                data-default foreign-store hslogger hspec hspec-discover HUnit

     

       206435
       -
                megaparsec messagepack mtl network optparse-applicative path

     

       206436
       -
                path-io prettyprinter prettyprinter-ansi-terminal QuickCheck

     

       206437
       -
                resourcet stm streaming-commons template-haskell

     

       206438
       -
                template-haskell-compat-v0208 text time time-locale-compat

     

       206439
       -
                transformers transformers-base typed-process unliftio unliftio-core

     

       206440
       -
                utf8-string vector

     

       206441
       -
              ];

     

       206442
       -
              testToolDepends = [ hspec-discover ];

     

       206443
       -
              description = "Haskell plugin backend for neovim";

     

       206444
       -
              license = lib.licenses.asl20;

     

       206445
       -
            }) {};

     

       206446
       -
       

     

       206447
       -
         "nvim-hs_2_3_2_0" = callPackage

     

       206448
       -
           ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit

     

       206449
       -
            , containers, data-default, deepseq, foreign-store, hslogger, hspec

     

       206450
       -
            , hspec-discover, HUnit, megaparsec, messagepack, mtl, network

     

       206451
       -
            , optparse-applicative, path, path-io, prettyprinter

     

       206452
       -
            , prettyprinter-ansi-terminal, QuickCheck, resourcet, stm

     

       206453
       -
            , streaming-commons, template-haskell

     

       206454
       -
            , template-haskell-compat-v0208, text, time, time-locale-compat

     

       206455
       -
            , transformers, transformers-base, typed-process, unliftio

     

       206456
       -
            , unliftio-core, utf8-string, vector, void

     

       206457
       -
            }:

     

       206458
       -
            mkDerivation {

     

       206459
       -
              pname = "nvim-hs";

     

       206460
        
              version = "2.3.2.0";

     

       206461
        
              sha256 = "1szvh65sbxk81321ml0b1iib5ziiks2l8liwkgs4z47pmb14cps9";

     

       206462
        
              libraryHaskellDepends = [

     
···

       206481
        
              testToolDepends = [ hspec-discover ];

     

       206482
        
              description = "Haskell plugin backend for neovim";

     

       206483
        
              license = lib.licenses.asl20;

     

       206484
       -
              hydraPlatforms = lib.platforms.none;

     

       206485
        
            }) {};

     

       206486
        
       

     

       206487
        
         "nvim-hs-contrib" = callPackage

     
···

       206508
        
            }) {};

     

       206509
        
       

     

       206510
        
         "nvim-hs-ghcid" = callPackage

     

       206511
       -
           ({ mkDerivation, base, bytestring, containers, directory, filepath

     

       206512
       -
            , ghcid, nvim-hs, nvim-hs-contrib, resourcet, transformers

     

       206513
       -
            , unliftio, yaml

     

       206514
       -
            }:

     

       206515
       -
            mkDerivation {

     

       206516
       -
              pname = "nvim-hs-ghcid";

     

       206517
       -
              version = "2.0.0.0";

     

       206518
       -
              sha256 = "0i9wc6mgxxzymw1smjvin70i4ynqsn2k3ig36pxmbb6qd0ci0hwg";

     

       206519
       -
              revision = "1";

     

       206520
       -
              editedCabalFile = "0na6lv57jdrpq1zkp3dhlpzh0wrr9632h7izw7jf8622x51qlh4r";

     

       206521
       -
              isLibrary = true;

     

       206522
       -
              isExecutable = true;

     

       206523
       -
              libraryHaskellDepends = [

     

       206524
       -
                base bytestring containers directory filepath ghcid nvim-hs

     

       206525
       -
                nvim-hs-contrib resourcet transformers unliftio yaml

     

       206526
       -
              ];

     

       206527
       -
              executableHaskellDepends = [ base nvim-hs ];

     

       206528
       -
              description = "Neovim plugin that runs ghcid to update the quickfix list";

     

       206529
       -
              license = lib.licenses.asl20;

     

       206530
       -
              hydraPlatforms = lib.platforms.none;

     

       206531
       -
              mainProgram = "nvim-hs-ghcid";

     

       206532
       -
              broken = true;

     

       206533
       -
            }) {};

     

       206534
       -
       

     

       206535
       -
         "nvim-hs-ghcid_2_0_1_0" = callPackage

     

       206536
        
           ({ mkDerivation, base, bytestring, containers, directory, filepath

     

       206537
        
            , ghcid, nvim-hs, nvim-hs-contrib, resourcet, transformers

     

       206538
        
            , unliftio, yaml

     
···

       208814
        
           ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries

     

       208815
        
            , bytestring, Cabal, cabal-doctest, containers, cookie, doctest

     

       208816
        
            , generics-sop, Glob, hashable, hspec, hspec-discover, http-media

     

       208817
       -
            , HUnit, insert-ordered-containers, lens, mtl, network, optics-core

     

       208818
       -
            , optics-th, QuickCheck, quickcheck-instances, scientific

     

       208819
       -
            , template-haskell, text, time, transformers, unordered-containers

     

       208820
       -
            , utf8-string, uuid-types, vector

     

       208821
       -
            }:

     

       208822
       -
            mkDerivation {

     

       208823
       -
              pname = "openapi3";

     

       208824
       -
              version = "3.2.2";

     

       208825
       -
              sha256 = "0d31ilv2ivwswzbpfibqwnld8697vk63wyr6yl80brjx60g4jp9j";

     

       208826
       -
              revision = "2";

     

       208827
       -
              editedCabalFile = "1yc3wlc8j84glav3hzx1l4yq33k05bll252a8yl6ld275jjswn8p";

     

       208828
       -
              isLibrary = true;

     

       208829
       -
              isExecutable = true;

     

       208830
       -
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       208831
       -
              libraryHaskellDepends = [

     

       208832
       -
                aeson aeson-pretty base base-compat-batteries bytestring containers

     

       208833
       -
                cookie generics-sop hashable http-media insert-ordered-containers

     

       208834
       -
                lens mtl network optics-core optics-th QuickCheck scientific

     

       208835
       -
                template-haskell text time transformers unordered-containers

     

       208836
       -
                uuid-types vector

     

       208837
       -
              ];

     

       208838
       -
              executableHaskellDepends = [ aeson base lens text ];

     

       208839
       -
              testHaskellDepends = [

     

       208840
       -
                aeson base base-compat-batteries bytestring containers doctest Glob

     

       208841
       -
                hashable hspec HUnit insert-ordered-containers lens mtl QuickCheck

     

       208842
       -
                quickcheck-instances template-haskell text time

     

       208843
       -
                unordered-containers utf8-string vector

     

       208844
       -
              ];

     

       208845
       -
              testToolDepends = [ hspec-discover ];

     

       208846
       -
              description = "OpenAPI 3.0 data model";

     

       208847
       -
              license = lib.licenses.bsd3;

     

       208848
       -
              mainProgram = "example";

     

       208849
       -
            }) {};

     

       208850
       -
       

     

       208851
       -
         "openapi3_3_2_3" = callPackage

     

       208852
       -
           ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries

     

       208853
       -
            , bytestring, Cabal, cabal-doctest, containers, cookie, doctest

     

       208854
       -
            , generics-sop, Glob, hashable, hspec, hspec-discover, http-media

     

       208855
        
            , HUnit, insert-ordered-containers, lens, mtl, optics-core

     

       208856
        
            , optics-th, QuickCheck, quickcheck-instances, scientific

     

       208857
        
            , template-haskell, text, time, transformers, unordered-containers

     
···

       208883
        
              license = lib.licenses.bsd3;

     

       208884
        
              hydraPlatforms = lib.platforms.none;

     

       208885
        
              mainProgram = "example";

     

       0
        
       
     

       208886
        
            }) {};

     

       208887
        
       

     

       208888
        
         "openapi3-code-generator" = callPackage

     
···

       212910
        
            }) {};

     

       212911
        
       

     

       212912
        
         "pandoc-stylefrommeta" = callPackage

     

       212913
       -
           ({ mkDerivation, base, bytestring, containers, extra, pandoc

     

       212914
       -
            , pandoc-types, text

     

       212915
        
            }:

     

       212916
        
            mkDerivation {

     

       212917
        
              pname = "pandoc-stylefrommeta";

     

       212918
       -
              version = "0.2.3.0";

     

       212919
       -
              sha256 = "1145flz4jkn5knqkc5cppc1412m6hfzd13124k2kfm8dmw196k31";

     

       212920
        
              isLibrary = false;

     

       212921
        
              isExecutable = true;

     

       212922
        
              executableHaskellDepends = [

     

       212923
       -
                base bytestring containers extra pandoc pandoc-types text

     

       212924
        
              ];

     

       212925
        
              description = "Pandoc filter to customize links, images and paragraphs";

     

       212926
        
              license = lib.licenses.bsd3;

     
···

       215022
        
           ({ mkDerivation, base, hedgehog, partial-semigroup }:

     

       215023
        
            mkDerivation {

     

       215024
        
              pname = "partial-semigroup-hedgehog";

     

       215025
       -
              version = "0.6.0.12";

     

       215026
       -
              sha256 = "0razhgznrrzp23zdpl1z8056n2dp2azl42cnha2g0b5h04nipg4q";

     

       215027
       -
              revision = "1";

     

       215028
       -
              editedCabalFile = "13ba819c67d1j6a5rr5w2lss1drb3znjdkfv2y0fd5givda2ds5v";

     

       215029
        
              libraryHaskellDepends = [ base hedgehog partial-semigroup ];

     

       215030
        
              description = "Property testing for partial semigroups using Hedgehog";

     

       215031
        
              license = lib.licenses.asl20;

     
···

       223610
        
              license = lib.licenses.bsd3;

     

       223611
        
            }) {};

     

       223612
        
       

     

       223613
       -
         "polysemy_1_8_0_0" = callPackage

     

       223614
        
           ({ mkDerivation, async, base, Cabal, cabal-doctest, containers

     

       223615
        
            , doctest, first-class-families, hspec, hspec-discover

     

       223616
        
            , inspection-testing, mtl, stm, syb, template-haskell

     
···

       223618
        
            }:

     

       223619
        
            mkDerivation {

     

       223620
        
              pname = "polysemy";

     

       223621
       -
              version = "1.8.0.0";

     

       223622
       -
              sha256 = "1fyysldfnirhk8nfgiji248rc35c97r0hm4hk6j1n12ynhxcaiwb";

     

       223623
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       223624
        
              libraryHaskellDepends = [

     

       223625
        
                async base containers first-class-families mtl stm syb

     
···

       223708
        
            }:

     

       223709
        
            mkDerivation {

     

       223710
        
              pname = "polysemy-conc";

     

       223711
       -
              version = "0.11.1.0";

     

       223712
       -
              sha256 = "0kwfvwv4hzbm51sk78k1ka9i3f23jp9r8d0acs4gjnbbjfvv78wk";

     

       223713
        
              libraryHaskellDepends = [

     

       223714
        
                async base containers incipit-core polysemy polysemy-resume

     

       223715
        
                polysemy-time stm stm-chans torsor unagi-chan unix

     
···

       223777
        
            }:

     

       223778
        
            mkDerivation {

     

       223779
        
              pname = "polysemy-http";

     

       223780
       -
              version = "0.9.0.0";

     

       223781
       -
              sha256 = "13d5ydyaq6jjinq8h8slxj0iw6bfpg7cdv0lj0kl8kpvikr6livg";

     

       223782
        
              libraryHaskellDepends = [

     

       223783
        
                aeson base case-insensitive exon http-client http-client-tls

     

       223784
        
                http-types polysemy polysemy-plugin prelate time

     
···

       223853
        
            }:

     

       223854
        
            mkDerivation {

     

       223855
        
              pname = "polysemy-log";

     

       223856
       -
              version = "0.8.0.0";

     

       223857
       -
              sha256 = "0zvlx1y852c1jyaw3lcxps8yb6qk56i8drnfbqvdpss3hb6jhii7";

     

       223858
        
              libraryHaskellDepends = [

     

       223859
        
                ansi-terminal async base incipit-core polysemy polysemy-conc

     

       223860
        
                polysemy-time stm time

     
···

       223878
        
            }:

     

       223879
        
            mkDerivation {

     

       223880
        
              pname = "polysemy-log-co";

     

       223881
       -
              version = "0.8.0.0";

     

       223882
       -
              sha256 = "09r4aqkwfjnwnlym97mfasghb3c9jq9vlmqlycz0kgsid8hdjh52";

     

       223883
        
              libraryHaskellDepends = [

     

       223884
        
                base co-log co-log-concurrent co-log-polysemy incipit-core polysemy

     

       223885
        
                polysemy-conc polysemy-log polysemy-time stm

     
···

       223900
        
            }:

     

       223901
        
            mkDerivation {

     

       223902
        
              pname = "polysemy-log-di";

     

       223903
       -
              version = "0.8.0.0";

     

       223904
       -
              sha256 = "1gmwrmnw4675y8hzywazjcafd0hkfal7rxpcycz4dpvzsqznrcrz";

     

       223905
        
              libraryHaskellDepends = [

     

       223906
        
                base di-polysemy incipit-core polysemy polysemy-conc polysemy-log

     

       223907
        
                polysemy-time stm

     
···

       223993
        
            }:

     

       223994
        
            mkDerivation {

     

       223995
        
              pname = "polysemy-mocks";

     

       223996
       -
              version = "0.3.0.0";

     

       223997
       -
              sha256 = "03yq5pyrg2rhykyhvp3f8b816r9j035xr5d9d1cls73zh9pbbh7z";

     

       223998
        
              libraryHaskellDepends = [ base polysemy template-haskell ];

     

       223999
        
              testHaskellDepends = [ base hspec polysemy ];

     

       224000
        
              testToolDepends = [ hspec-discover ];

     
···

       224038
        
            }:

     

       224039
        
            mkDerivation {

     

       224040
        
              pname = "polysemy-plugin";

     

       224041
       -
              version = "0.4.3.1";

     

       224042
       -
              sha256 = "02s9hb0y4fgvmlkg7izwq24hrgb92h1jd7v0gjzayjn6la8xmf6r";

     

       224043
       -
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       224044
       -
              libraryHaskellDepends = [

     

       224045
       -
                base containers ghc ghc-tcplugins-extra polysemy syb transformers

     

       224046
       -
              ];

     

       224047
       -
              testHaskellDepends = [

     

       224048
       -
                base containers doctest ghc ghc-tcplugins-extra hspec

     

       224049
       -
                inspection-testing polysemy should-not-typecheck syb transformers

     

       224050
       -
              ];

     

       224051
       -
              testToolDepends = [ hspec-discover ];

     

       224052
       -
              description = "Disambiguate obvious uses of effects";

     

       224053
       -
              license = lib.licenses.bsd3;

     

       224054
       -
            }) {};

     

       224055
       -
       

     

       224056
       -
         "polysemy-plugin_0_4_4_0" = callPackage

     

       224057
       -
           ({ mkDerivation, base, Cabal, cabal-doctest, containers, doctest

     

       224058
       -
            , ghc, ghc-tcplugins-extra, hspec, hspec-discover

     

       224059
       -
            , inspection-testing, polysemy, should-not-typecheck, syb

     

       224060
       -
            , transformers

     

       224061
       -
            }:

     

       224062
       -
            mkDerivation {

     

       224063
       -
              pname = "polysemy-plugin";

     

       224064
        
              version = "0.4.4.0";

     

       224065
        
              sha256 = "1kp7d4m007mlk4pl2p8933b5yzzb8gl30g1vfbbz01vm3pgjcj3d";

     

       224066
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       224075
        
              testToolDepends = [ hspec-discover ];

     

       224076
        
              description = "Disambiguate obvious uses of effects";

     

       224077
        
              license = lib.licenses.bsd3;

     

       224078
       -
              hydraPlatforms = lib.platforms.none;

     

       224079
        
            }) {};

     

       224080
        
       

     

       224081
        
         "polysemy-process" = callPackage

     
···

       224086
        
            }:

     

       224087
        
            mkDerivation {

     

       224088
        
              pname = "polysemy-process";

     

       224089
       -
              version = "0.11.1.0";

     

       224090
       -
              sha256 = "09bzjdnj15bv0fnvs99f6x71yqmy0lbsnxbr4w3mxn4yp73sppc1";

     

       224091
        
              libraryHaskellDepends = [

     

       224092
        
                base incipit-core path path-io polysemy polysemy-conc

     

       224093
        
                polysemy-resume polysemy-time posix-pty process stm-chans

     
···

       224150
        
            }:

     

       224151
        
            mkDerivation {

     

       224152
        
              pname = "polysemy-resume";

     

       224153
       -
              version = "0.6.0.0";

     

       224154
       -
              sha256 = "1m6rw8h1glvzic2zhnksiag377zqyf771ypqks59yksmw11hvsyv";

     

       224155
        
              libraryHaskellDepends = [

     

       224156
        
                base incipit-core polysemy transformers

     

       224157
        
              ];

     
···

       227367
        
            }:

     

       227368
        
            mkDerivation {

     

       227369
        
              pname = "prelate";

     

       227370
       -
              version = "0.3.0.0";

     

       227371
       -
              sha256 = "13qrk305k5mgpkhjhk92zs0rp3y68k7rhj5d3cqj785bvyvpz3wh";

     

       227372
        
              libraryHaskellDepends = [

     

       227373
        
                aeson base exon extra generic-lens incipit microlens microlens-ghc

     

       227374
        
                polysemy-chronos polysemy-conc polysemy-log polysemy-process

     
···

       234216
        
              license = lib.licenses.bsd3;

     

       234217
        
            }) {};

     

       234218
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       234219
        
         "quickcheck-poly" = callPackage

     

       234220
        
           ({ mkDerivation, base, haskell98, hint, MonadCatchIO-mtl

     

       234221
        
            , QuickCheck, regex-compat, regex-tdfa

     
···

       238490
        
            }:

     

       238491
        
            mkDerivation {

     

       238492
        
              pname = "recursion-schemes";

     

       238493
       -
              version = "5.2.2.2";

     

       238494
       -
              sha256 = "018l7j9pk8izi817vqyrakrkjsxr332jh24d6j0yl35i5wm4khv6";

     

       238495
       -
              revision = "1";

     

       238496
       -
              editedCabalFile = "1l6wbzx8804pb6p8gvk45hal6sz8r1gvyxb8aa9ih6j8pqv4q04c";

     

       238497
       -
              libraryHaskellDepends = [

     

       238498
       -
                base base-orphans comonad containers data-fix free template-haskell

     

       238499
       -
                th-abstraction transformers

     

       238500
       -
              ];

     

       238501
       -
              testHaskellDepends = [ base HUnit template-haskell transformers ];

     

       238502
       -
              description = "Representing common recursion patterns as higher-order functions";

     

       238503
       -
              license = lib.licenses.bsd2;

     

       238504
       -
            }) {};

     

       238505
       -
       

     

       238506
       -
         "recursion-schemes_5_2_2_3" = callPackage

     

       238507
       -
           ({ mkDerivation, base, base-orphans, comonad, containers, data-fix

     

       238508
       -
            , free, HUnit, template-haskell, th-abstraction, transformers

     

       238509
       -
            }:

     

       238510
       -
            mkDerivation {

     

       238511
       -
              pname = "recursion-schemes";

     

       238512
        
              version = "5.2.2.3";

     

       238513
        
              sha256 = "04233y5qw7vm0kyh4h44zpfk2zsd6kz9081ngvi098y0xiphrwm9";

     

       238514
        
              libraryHaskellDepends = [

     
···

       238518
        
              testHaskellDepends = [ base HUnit template-haskell transformers ];

     

       238519
        
              description = "Representing common recursion patterns as higher-order functions";

     

       238520
        
              license = lib.licenses.bsd2;

     

       238521
       -
              hydraPlatforms = lib.platforms.none;

     

       238522
        
            }) {};

     

       238523
        
       

     

       238524
        
         "recursion-schemes-ext" = callPackage

     
···

       242411
        
              ];

     

       242412
        
              description = "Perform fft with repa via FFTW";

     

       242413
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       242414
        
            }) {};

     

       242415
        
       

     

       242416
        
         "repa-flow" = callPackage

     
···

       245196
        
              ];

     

       245197
        
              description = "A library for process pools coupled with asynchronous message queues";

     

       245198
        
              license = lib.licenses.bsd2;

     

       0
        
       
     

       245199
        
              mainProgram = "rio-process-pool-memleak-test";

     

       245200
        
            }) {};

     

       245201
        
       

     
···

       245758
        
                vector-sized

     

       245759
        
              ];

     

       245760
        
              description = "Implementation of the ROC National ID standard";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       245761
        
              license = lib.licenses.bsd3;

     

       245762
        
              hydraPlatforms = lib.platforms.none;

     

       245763
        
              broken = true;

     
···

       255201
        
            }:

     

       255202
        
            mkDerivation {

     

       255203
        
              pname = "servant-openapi3";

     

       255204
       -
              version = "2.0.1.5";

     

       255205
       -
              sha256 = "0zcyqga4hbdyk34368108vv9vavzdhv26xphas7yppada2sshfay";

     

       255206
       -
              revision = "3";

     

       255207
       -
              editedCabalFile = "0xvs5a9zsg32iziznvvjhfji577xmza419xk0cy1hwamw17f43mi";

     

       255208
       -
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       255209
       -
              libraryHaskellDepends = [

     

       255210
       -
                aeson aeson-pretty base base-compat bytestring hspec http-media

     

       255211
       -
                insert-ordered-containers lens openapi3 QuickCheck servant

     

       255212
       -
                singleton-bool text unordered-containers

     

       255213
       -
              ];

     

       255214
       -
              testHaskellDepends = [

     

       255215
       -
                aeson base base-compat directory doctest filepath hspec lens

     

       255216
       -
                lens-aeson openapi3 QuickCheck servant template-haskell text time

     

       255217
       -
                utf8-string vector

     

       255218
       -
              ];

     

       255219
       -
              testToolDepends = [ hspec-discover ];

     

       255220
       -
              description = "Generate a Swagger/OpenAPI/OAS 3.0 specification for your servant API.";

     

       255221
       -
              license = lib.licenses.bsd3;

     

       255222
       -
            }) {};

     

       255223
       -
       

     

       255224
       -
         "servant-openapi3_2_0_1_6" = callPackage

     

       255225
       -
           ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring

     

       255226
       -
            , Cabal, cabal-doctest, directory, doctest, filepath, hspec

     

       255227
       -
            , hspec-discover, http-media, insert-ordered-containers, lens

     

       255228
       -
            , lens-aeson, openapi3, QuickCheck, servant, singleton-bool

     

       255229
       -
            , template-haskell, text, time, unordered-containers, utf8-string

     

       255230
       -
            , vector

     

       255231
       -
            }:

     

       255232
       -
            mkDerivation {

     

       255233
       -
              pname = "servant-openapi3";

     

       255234
        
              version = "2.0.1.6";

     

       255235
        
              sha256 = "1hxz3n6l5l8p9s58sjilrn4lv1z17kfik0xdh05v5v1bzf0j2aij";

     

       255236
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       256308
        
              testToolDepends = [ hspec-discover ];

     

       256309
        
              description = "Servant servers utilities";

     

       256310
        
              license = lib.licenses.mpl20;

     

       0
        
       
     

       256311
        
              mainProgram = "servant-util-examples";

     

       256312
        
            }) {};

     

       256313
        
       

     
···

       256339
        
              testToolDepends = [ hspec-discover ];

     

       256340
        
              description = "Implementation of servant-util primitives for beam-postgres";

     

       256341
        
              license = lib.licenses.mpl20;

     

       0
        
       
     

       256342
        
              mainProgram = "servant-util-beam-pg-examples";

     

       256343
        
            }) {};

     

       256344
        
       

     
···

       261980
        
         "skylighting" = callPackage

     

       261981
        
           ({ mkDerivation, base, binary, blaze-html, bytestring, containers

     

       261982
        
            , pretty-show, skylighting-core, skylighting-format-ansi

     

       261983
       -
            , skylighting-format-blaze-html, skylighting-format-latex, text

     

       261984
       -
            }:

     

       261985
       -
            mkDerivation {

     

       261986
       -
              pname = "skylighting";

     

       261987
       -
              version = "0.13.1.2";

     

       261988
       -
              sha256 = "05m11hd6xr4kh6jgdj4mgwa7nbrj29jzca76pjpm0mjiqv3ah3av";

     

       261989
       -
              configureFlags = [ "-fexecutable" ];

     

       261990
       -
              isLibrary = true;

     

       261991
       -
              isExecutable = true;

     

       261992
       -
              libraryHaskellDepends = [

     

       261993
       -
                base binary containers skylighting-core skylighting-format-ansi

     

       261994
       -
                skylighting-format-blaze-html skylighting-format-latex

     

       261995
       -
              ];

     

       261996
       -
              executableHaskellDepends = [

     

       261997
       -
                base blaze-html bytestring containers pretty-show text

     

       261998
       -
              ];

     

       261999
       -
              description = "syntax highlighting library";

     

       262000
       -
              license = lib.licenses.gpl2Only;

     

       262001
       -
              mainProgram = "skylighting";

     

       262002
       -
            }) {};

     

       262003
       -
       

     

       262004
       -
         "skylighting_0_13_2" = callPackage

     

       262005
       -
           ({ mkDerivation, base, binary, blaze-html, bytestring, containers

     

       262006
       -
            , pretty-show, skylighting-core, skylighting-format-ansi

     

       262007
        
            , skylighting-format-blaze-html, skylighting-format-context

     

       262008
        
            , skylighting-format-latex, text

     

       262009
        
            }:

     
···

       262024
        
              ];

     

       262025
        
              description = "syntax highlighting library";

     

       262026
        
              license = lib.licenses.gpl2Only;

     

       262027
       -
              hydraPlatforms = lib.platforms.none;

     

       262028
        
              mainProgram = "skylighting";

     

       262029
        
            }) {};

     

       262030
        
       

     
···

       262037
        
            }:

     

       262038
        
            mkDerivation {

     

       262039
        
              pname = "skylighting-core";

     

       262040
       -
              version = "0.13.1.2";

     

       262041
       -
              sha256 = "0081zihpiq4w99x4s5bhf0r2j627dzmlnmpca5rq16mqvhz22mmz";

     

       262042
       -
              isLibrary = true;

     

       262043
       -
              isExecutable = true;

     

       262044
       -
              libraryHaskellDepends = [

     

       262045
       -
                aeson attoparsec base base64-bytestring binary bytestring

     

       262046
       -
                case-insensitive colour containers directory filepath mtl safe text

     

       262047
       -
                transformers utf8-string xml-conduit

     

       262048
       -
              ];

     

       262049
       -
              testHaskellDepends = [

     

       262050
       -
                aeson base bytestring containers Diff directory filepath

     

       262051
       -
                pretty-show QuickCheck tasty tasty-golden tasty-hunit

     

       262052
       -
                tasty-quickcheck text

     

       262053
       -
              ];

     

       262054
       -
              benchmarkHaskellDepends = [

     

       262055
       -
                base containers criterion filepath text

     

       262056
       -
              ];

     

       262057
       -
              description = "syntax highlighting library";

     

       262058
       -
              license = lib.licenses.bsd3;

     

       262059
       -
            }) {};

     

       262060
       -
       

     

       262061
       -
         "skylighting-core_0_13_2" = callPackage

     

       262062
       -
           ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary

     

       262063
       -
            , bytestring, case-insensitive, colour, containers, criterion, Diff

     

       262064
       -
            , directory, filepath, mtl, pretty-show, QuickCheck, safe, tasty

     

       262065
       -
            , tasty-golden, tasty-hunit, tasty-quickcheck, text, transformers

     

       262066
       -
            , utf8-string, xml-conduit

     

       262067
       -
            }:

     

       262068
       -
            mkDerivation {

     

       262069
       -
              pname = "skylighting-core";

     

       262070
        
              version = "0.13.2";

     

       262071
        
              sha256 = "0iwzfgynj3l8rnvvrl4kg0i1n31rz15da8cf1943gw1vcfh6w585";

     

       262072
        
              isLibrary = true;

     
···

       262086
        
              ];

     

       262087
        
              description = "syntax highlighting library";

     

       262088
        
              license = lib.licenses.bsd3;

     

       262089
       -
              hydraPlatforms = lib.platforms.none;

     

       262090
        
            }) {};

     

       262091
        
       

     

       262092
        
         "skylighting-extensions" = callPackage

     
···

       265259
        
              ];

     

       265260
        
              description = "A checksummed variation on Twitter's Snowflake UID generation algorithm";

     

       265261
        
              license = lib.licenses.asl20;

     

       0
        
       
     

       0
        
       
     

       265262
        
            }) {};

     

       265263
        
       

     

       265264
        
         "snowflake" = callPackage

     
···

       265876
        
           ({ mkDerivation, base, deepseq }:

     

       265877
        
            mkDerivation {

     

       265878
        
              pname = "some";

     

       265879
       -
              version = "1.0.3";

     

       265880
       -
              sha256 = "0w3syapwz9v916zf1i4f8vxymdfg7syc2cpxgnqr018pbswzxrk2";

     

       265881
       -
              revision = "2";

     

       265882
       -
              editedCabalFile = "1w3snkgqhrgi2x2bdny9i7a9ybmal3asrh6g6kg8v86kq1gyr34k";

     

       265883
       -
              libraryHaskellDepends = [ base deepseq ];

     

       265884
       -
              testHaskellDepends = [ base ];

     

       265885
       -
              description = "Existential type: Some";

     

       265886
       -
              license = lib.licenses.bsd3;

     

       265887
       -
            }) {};

     

       265888
       -
       

     

       265889
       -
         "some_1_0_4_1" = callPackage

     

       265890
       -
           ({ mkDerivation, base, deepseq }:

     

       265891
       -
            mkDerivation {

     

       265892
       -
              pname = "some";

     

       265893
        
              version = "1.0.4.1";

     

       265894
        
              sha256 = "1qy840b2f58f0jxmw4q9sfgbx64kypzdlqnwc72md5wwv84b9b1d";

     

       265895
        
              libraryHaskellDepends = [ base deepseq ];

     

       265896
        
              testHaskellDepends = [ base ];

     

       265897
        
              description = "Existential type: Some";

     

       265898
        
              license = lib.licenses.bsd3;

     

       265899
       -
              hydraPlatforms = lib.platforms.none;

     

       265900
        
            }) {};

     

       265901
        
       

     

       265902
        
         "some-dict-of" = callPackage

     
···

       271030
        
              testHaskellDepends = [ base hspec mtl stm stm-queue ];

     

       271031
        
              description = "A simplistic actor model based on STM";

     

       271032
        
              license = lib.licenses.mit;

     

       0
        
       
     

       271033
        
            }) {};

     

       271034
        
       

     

       271035
        
         "stm-channelize" = callPackage

     
···

       271269
        
              ];

     

       271270
        
              description = "An implementation of a real-time concurrent queue";

     

       271271
        
              license = lib.licenses.mit;

     

       0
        
       
     

       0
        
       
     

       271272
        
            }) {};

     

       271273
        
       

     

       271274
        
         "stm-queue-extras" = callPackage

     
···

       271694
        
              pname = "store-core";

     

       271695
        
              version = "0.4.4.4";

     

       271696
        
              sha256 = "0h21wp51phbwk9ajblqaqzx1hk9c58gkihmycjn0hj299kxly80y";

     

       0
        
       
     

       0
        
       
     

       271697
        
              libraryHaskellDepends = [

     

       271698
        
                base bytestring ghc-prim primitive text transformers

     

       271699
        
              ];

     
···

       273333
        
            }:

     

       273334
        
            mkDerivation {

     

       273335
        
              pname = "string-interpolate";

     

       273336
       -
              version = "0.3.1.2";

     

       273337
       -
              sha256 = "0gmph9mikqq8hch9wjyyx6dxfxwhmdfrwsrxkvbk7i24lvi19hhp";

     

       273338
       -
              revision = "1";

     

       273339
       -
              editedCabalFile = "1nrpng7r59a25z4qns8vy26rvp1wgn5f4bs8ism40q66ags8f2ad";

     

       273340
       -
              libraryHaskellDepends = [

     

       273341
       -
                base bytestring haskell-src-exts haskell-src-meta split

     

       273342
       -
                template-haskell text text-conversions utf8-string

     

       273343
       -
              ];

     

       273344
       -
              testHaskellDepends = [

     

       273345
       -
                base bytestring hspec hspec-core QuickCheck quickcheck-instances

     

       273346
       -
                quickcheck-text quickcheck-unicode template-haskell text

     

       273347
       -
                unordered-containers

     

       273348
       -
              ];

     

       273349
       -
              benchmarkHaskellDepends = [

     

       273350
       -
                base bytestring criterion deepseq formatting interpolate

     

       273351
       -
                neat-interpolation QuickCheck text

     

       273352
       -
              ];

     

       273353
       -
              description = "Haskell string/text/bytestring interpolation that just works";

     

       273354
       -
              license = lib.licenses.bsd3;

     

       273355
       -
            }) {};

     

       273356
       -
       

     

       273357
       -
         "string-interpolate_0_3_2_0" = callPackage

     

       273358
       -
           ({ mkDerivation, base, bytestring, criterion, deepseq, formatting

     

       273359
       -
            , haskell-src-exts, haskell-src-meta, hspec, hspec-core

     

       273360
       -
            , interpolate, neat-interpolation, QuickCheck, quickcheck-instances

     

       273361
       -
            , quickcheck-text, quickcheck-unicode, split, template-haskell

     

       273362
       -
            , text, text-conversions, unordered-containers, utf8-string

     

       273363
       -
            }:

     

       273364
       -
            mkDerivation {

     

       273365
       -
              pname = "string-interpolate";

     

       273366
        
              version = "0.3.2.0";

     

       273367
        
              sha256 = "1sdd472rvykrqkv76745vavpycvb0dzcaxs3yw9dfczaxaz16xws";

     

       273368
        
              libraryHaskellDepends = [

     
···

       273380
        
              ];

     

       273381
        
              description = "Haskell string/text/bytestring interpolation that just works";

     

       273382
        
              license = lib.licenses.bsd3;

     

       273383
       -
              hydraPlatforms = lib.platforms.none;

     

       273384
        
            }) {};

     

       273385
        
       

     

       273386
        
         "string-interpreter" = callPackage

     
···

       279680
        
            }) {};

     

       279681
        
       

     

       279682
        
         "tasty" = callPackage

     

       279683
       -
           ({ mkDerivation, ansi-terminal, base, clock, containers

     

       279684
       -
            , optparse-applicative, stm, tagged, transformers, unbounded-delays

     

       279685
       -
            , unix, wcwidth

     

       279686
       -
            }:

     

       279687
       -
            mkDerivation {

     

       279688
       -
              pname = "tasty";

     

       279689
       -
              version = "1.4.2.3";

     

       279690
       -
              sha256 = "1inhrayiqhd3k14b9cnjcv5kdxb95sgk8b0ibbf37z4dlalsf569";

     

       279691
       -
              libraryHaskellDepends = [

     

       279692
       -
                ansi-terminal base clock containers optparse-applicative stm tagged

     

       279693
       -
                transformers unbounded-delays unix wcwidth

     

       279694
       -
              ];

     

       279695
       -
              description = "Modern and extensible testing framework";

     

       279696
       -
              license = lib.licenses.mit;

     

       279697
       -
            }) {};

     

       279698
       -
       

     

       279699
       -
         "tasty_1_4_3" = callPackage

     

       279700
        
           ({ mkDerivation, ansi-terminal, base, containers

     

       279701
        
            , optparse-applicative, stm, tagged, transformers, unix

     

       279702
        
            }:

     
···

       279710
        
              ];

     

       279711
        
              description = "Modern and extensible testing framework";

     

       279712
        
              license = lib.licenses.mit;

     

       279713
       -
              hydraPlatforms = lib.platforms.none;

     

       279714
        
            }) {};

     

       279715
        
       

     

       279716
        
         "tasty-ant-xml" = callPackage

     
···

       281309
        
            }:

     

       281310
        
            mkDerivation {

     

       281311
        
              pname = "telegram-bot-simple";

     

       281312
       -
              version = "0.6";

     

       281313
       -
              sha256 = "1f4nfh32v5l60p2bqifg5dl311p86lis51na7hri074w0p3kg6ki";

     

       281314
       -
              isLibrary = true;

     

       281315
       -
              isExecutable = true;

     

       281316
       -
              libraryHaskellDepends = [

     

       281317
       -
                aeson aeson-pretty base bytestring cron filepath hashable

     

       281318
       -
                http-api-data http-client http-client-tls monad-control mtl

     

       281319
       -
                pretty-show profunctors servant servant-client

     

       281320
       -
                servant-multipart-api servant-multipart-client servant-server split

     

       281321
       -
                stm template-haskell text time transformers unordered-containers

     

       281322
       -
                warp warp-tls

     

       281323
       -
              ];

     

       281324
       -
              description = "Easy to use library for building Telegram bots";

     

       281325
       -
              license = lib.licenses.bsd3;

     

       281326
       -
            }) {};

     

       281327
       -
       

     

       281328
       -
         "telegram-bot-simple_0_6_1" = callPackage

     

       281329
       -
           ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron

     

       281330
       -
            , filepath, hashable, http-api-data, http-client, http-client-tls

     

       281331
       -
            , monad-control, mtl, pretty-show, profunctors, servant

     

       281332
       -
            , servant-client, servant-multipart-api, servant-multipart-client

     

       281333
       -
            , servant-server, split, stm, template-haskell, text, time

     

       281334
       -
            , transformers, unordered-containers, warp, warp-tls

     

       281335
       -
            }:

     

       281336
       -
            mkDerivation {

     

       281337
       -
              pname = "telegram-bot-simple";

     

       281338
        
              version = "0.6.1";

     

       281339
        
              sha256 = "01rxkgzfvqxgnxlcw70rhs84ygvccydlki827f3icqwfpm7cn6vn";

     

       281340
        
              isLibrary = true;

     
···

       281349
        
              ];

     

       281350
        
              description = "Easy to use library for building Telegram bots";

     

       281351
        
              license = lib.licenses.bsd3;

     

       281352
       -
              hydraPlatforms = lib.platforms.none;

     

       281353
        
            }) {};

     

       281354
        
       

     

       281355
        
         "telegram-raw-api" = callPackage

     
···

       283588
        
            }:

     

       283589
        
            mkDerivation {

     

       283590
        
              pname = "text-builder-dev";

     

       283591
       -
              version = "0.3.3";

     

       283592
       -
              sha256 = "0h88yxj0w7ycpmzxyxnxkrz05dmi902dv9v8mxlx7nrr8idxss74";

     

       283593
       -
              libraryHaskellDepends = [

     

       283594
       -
                base bytestring deferred-folds isomorphism-class split text

     

       283595
       -
                transformers

     

       283596
       -
              ];

     

       283597
       -
              testHaskellDepends = [

     

       283598
       -
                QuickCheck quickcheck-instances rerebase tasty tasty-hunit

     

       283599
       -
                tasty-quickcheck

     

       283600
       -
              ];

     

       283601
       -
              benchmarkHaskellDepends = [ criterion rerebase ];

     

       283602
       -
              description = "Edge of developments for \"text-builder\"";

     

       283603
       -
              license = lib.licenses.mit;

     

       283604
       -
            }) {};

     

       283605
       -
       

     

       283606
       -
         "text-builder-dev_0_3_3_2" = callPackage

     

       283607
       -
           ({ mkDerivation, base, bytestring, criterion, deferred-folds

     

       283608
       -
            , isomorphism-class, QuickCheck, quickcheck-instances, rerebase

     

       283609
       -
            , split, tasty, tasty-hunit, tasty-quickcheck, text, transformers

     

       283610
       -
            }:

     

       283611
       -
            mkDerivation {

     

       283612
       -
              pname = "text-builder-dev";

     

       283613
        
              version = "0.3.3.2";

     

       283614
        
              sha256 = "1bsm4yl22mpzggcnh908ccw9mvg3prckydwxxqa4rfj4k8hy4x7m";

     

       283615
        
              libraryHaskellDepends = [

     
···

       283623
        
              benchmarkHaskellDepends = [ criterion rerebase ];

     

       283624
        
              description = "Edge of developments for \"text-builder\"";

     

       283625
        
              license = lib.licenses.mit;

     

       283626
       -
              hydraPlatforms = lib.platforms.none;

     

       283627
        
            }) {};

     

       283628
        
       

     

       283629
        
         "text-builder-linear" = callPackage

     
···

       284282
        
            }) {};

     

       284283
        
       

     

       284284
        
         "text-show-instances" = callPackage

     

       284285
       -
           ({ mkDerivation, base, base-compat-batteries, bifunctors, binary

     

       284286
        
            , containers, directory, generic-deriving, ghc-boot-th, ghc-prim

     

       284287
        
            , haskeline, hpc, hspec, hspec-discover, old-locale, old-time

     

       284288
        
            , pretty, QuickCheck, quickcheck-instances, random, scientific

     
···

       284292
        
            }:

     

       284293
        
            mkDerivation {

     

       284294
        
              pname = "text-show-instances";

     

       284295
       -
              version = "3.9.2";

     

       284296
       -
              sha256 = "1j1mcmw9l7hfmvhmv083bssc2w6zbvibaq3w4c7g7a2vxxcqwh3y";

     

       284297
        
              libraryHaskellDepends = [

     

       284298
       -
                base base-compat-batteries bifunctors binary containers directory

     

       284299
        
                ghc-boot-th haskeline hpc old-locale old-time pretty random

     

       284300
        
                scientific semigroups tagged template-haskell terminfo text

     

       284301
       -
                text-short text-show time transformers transformers-compat unix

     

       284302
       -
                unordered-containers uuid-types vector xhtml

     

       284303
        
              ];

     

       284304
        
              testHaskellDepends = [

     

       284305
       -
                base base-compat-batteries bifunctors binary containers directory

     

       284306
        
                generic-deriving ghc-boot-th ghc-prim haskeline hpc hspec

     

       284307
        
                old-locale old-time pretty QuickCheck quickcheck-instances random

     

       284308
        
                scientific tagged template-haskell terminfo text-short text-show

     
···

       284314
        
              license = lib.licenses.bsd3;

     

       284315
        
            }) {};

     

       284316
        
       

     

       284317
       -
         "text-show-instances_3_9_3" = callPackage

     

       284318
        
           ({ mkDerivation, aeson, base, base-compat, bifunctors, binary

     

       284319
        
            , containers, directory, generic-deriving, ghc-boot-th, ghc-prim

     

       284320
        
            , haskeline, hpc, hspec, hspec-discover, old-locale, old-time

     
···

       284325
        
            }:

     

       284326
        
            mkDerivation {

     

       284327
        
              pname = "text-show-instances";

     

       284328
       -
              version = "3.9.3";

     

       284329
       -
              sha256 = "153hfl8k0489ll71apq48s59ngv8ag1vyhhs6pp3fgxmdwwg2xpl";

     

       284330
        
              libraryHaskellDepends = [

     

       284331
        
                aeson base base-compat bifunctors binary containers directory

     

       284332
        
                ghc-boot-th haskeline hpc old-locale old-time pretty random

     
···

       291580
        
              testHaskellDepends = [ base containers template-haskell time ];

     

       291581
        
              description = "Template Haskell hack to violate module abstractions";

     

       291582
        
              license = lib.licenses.bsd3;

     

       291583
       -
              hydraPlatforms = lib.platforms.none;

     

       291584
       -
              broken = true;

     

       291585
        
            }) {};

     

       291586
        
       

     

       291587
        
         "truelevel" = callPackage

     
···

       297578
        
              ];

     

       297579
        
              description = "Fast and robust message queues for concurrent processes";

     

       297580
        
              license = lib.licenses.bsd2;

     

       0
        
       
     

       297581
        
              mainProgram = "unliftio-messagebox-memleak-test";

     

       0
        
       
     

       297582
        
            }) {};

     

       297583
        
       

     

       297584
        
         "unliftio-path" = callPackage

     
···

       300298
        
           ({ mkDerivation, base, stm }:

     

       300299
        
            mkDerivation {

     

       300300
        
              pname = "var-monad";

     

       300301
       -
              version = "0.2.0.0";

     

       300302
       -
              sha256 = "12l536ca32dhvylp3kizq664lsfysmc5r0hqzs50aqrbx8db40ji";

     

       300303
        
              libraryHaskellDepends = [ base stm ];

     

       300304
        
              description = "The VarMonad typeclass, generalizing types of references";

     

       300305
        
              license = lib.licenses.asl20;

     
···

       301118
        
            }:

     

       301119
        
            mkDerivation {

     

       301120
        
              pname = "vector-extras";

     

       301121
       -
              version = "0.2.7.1";

     

       301122
       -
              sha256 = "1a8aak9v68qmrx719w782ww7accn7bk11gnca3d2lvbzw793dl4q";

     

       301123
       -
              libraryHaskellDepends = [

     

       301124
       -
                base containers deferred-folds foldl hashable unordered-containers

     

       301125
       -
                vector

     

       301126
       -
              ];

     

       301127
       -
              description = "Utilities for the \"vector\" library";

     

       301128
       -
              license = lib.licenses.mit;

     

       301129
       -
            }) {};

     

       301130
       -
       

     

       301131
       -
         "vector-extras_0_2_8" = callPackage

     

       301132
       -
           ({ mkDerivation, base, containers, deferred-folds, foldl, hashable

     

       301133
       -
            , unordered-containers, vector

     

       301134
       -
            }:

     

       301135
       -
            mkDerivation {

     

       301136
       -
              pname = "vector-extras";

     

       301137
        
              version = "0.2.8";

     

       301138
        
              sha256 = "1xnz733p9p66693hb31fmq2cfsy2rwyw1b0915p7y5my1d8dxyzi";

     

       301139
        
              libraryHaskellDepends = [

     
···

       301142
        
              ];

     

       301143
        
              description = "Utilities for the \"vector\" library";

     

       301144
        
              license = lib.licenses.mit;

     

       301145
       -
              hydraPlatforms = lib.platforms.none;

     

       301146
        
            }) {};

     

       301147
        
       

     

       301148
        
         "vector-fft" = callPackage

     
···

       301332
        
              pname = "vector-sized";

     

       301333
        
              version = "1.5.0";

     

       301334
        
              sha256 = "13h4qck1697iswd9f8w17fpjc6yhl2pgrvay7pb22j2h3mgaxpjl";

     

       0
        
       
     

       0
        
       
     

       301335
        
              libraryHaskellDepends = [

     

       301336
        
                adjunctions base binary comonad deepseq distributive

     

       301337
        
                finite-typelits hashable indexed-list-literals primitive vector

     
···

       302905
        
              pname = "vty";

     

       302906
        
              version = "5.35.1";

     

       302907
        
              sha256 = "062dpz8fxrnggzpl041zpbph0xj56jki98ajm2s78dldg5vy0c9k";

     

       0
        
       
     

       0
        
       
     

       302908
        
              isLibrary = true;

     

       302909
        
              isExecutable = true;

     

       302910
        
              libraryHaskellDepends = [

     
···

       306795
        
              ];

     

       306796
        
              description = "Composable, type-safe library to build HTTP API servers";

     

       306797
        
              license = lib.licenses.mpl20;

     

       0
        
       
     

       306798
        
            }) {};

     

       306799
        
       

     

       306800
        
         "webgear-server" = callPackage

     
···

       307785
        
            }:

     

       307786
        
            mkDerivation {

     

       307787
        
              pname = "wide-word";

     

       307788
       -
              version = "0.1.3.0";

     

       307789
       -
              sha256 = "03g0v5zp3ra2z31vyjkhgd23s2dyaks640y2imkv649fcvvz33xj";

     

       307790
       -
              revision = "1";

     

       307791
       -
              editedCabalFile = "1y1w3ih92dni6bzp4w1hcwn96ahdrk34lmqrgkri2dcdkykwyqwb";

     

       307792
       -
              libraryHaskellDepends = [

     

       307793
       -
                base deepseq ghc-prim hashable primitive

     

       307794
       -
              ];

     

       307795
       -
              testHaskellDepends = [

     

       307796
       -
                base bytestring ghc-prim hedgehog primitive QuickCheck

     

       307797
       -
                quickcheck-classes semirings

     

       307798
       -
              ];

     

       307799
       -
              description = "Data types for large but fixed width signed and unsigned integers";

     

       307800
       -
              license = lib.licenses.bsd2;

     

       307801
       -
            }) {};

     

       307802
       -
       

     

       307803
       -
         "wide-word_0_1_4_0" = callPackage

     

       307804
       -
           ({ mkDerivation, base, bytestring, deepseq, ghc-prim, hashable

     

       307805
       -
            , hedgehog, primitive, QuickCheck, quickcheck-classes, semirings

     

       307806
       -
            }:

     

       307807
       -
            mkDerivation {

     

       307808
       -
              pname = "wide-word";

     

       307809
        
              version = "0.1.4.0";

     

       307810
        
              sha256 = "1jajlkcbymf0jqmcbn46x3yxqxjslzdcnp1v582jjpa2glibsnf0";

     

       307811
        
              libraryHaskellDepends = [

     
···

       307817
        
              ];

     

       307818
        
              description = "Data types for large but fixed width signed and unsigned integers";

     

       307819
        
              license = lib.licenses.bsd2;

     

       307820
       -
              hydraPlatforms = lib.platforms.none;

     

       307821
        
            }) {};

     

       307822
        
       

     

       307823
        
         "wide-word-instances" = callPackage

···

       1305
        
            }) {};

     

       1306
        
       

     

       1307
        
         "BNFC" = callPackage

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1308
        
           ({ mkDerivation, alex, array, base, containers, deepseq, directory

     

       1309
        
            , filepath, happy, hspec, hspec-discover, HUnit, mtl, pretty

     

       1310
        
            , process, QuickCheck, string-qq, temporary, time, transformers

     
···

       1328
        
              testToolDepends = [ alex happy hspec-discover ];

     

       1329
        
              description = "A compiler front-end generator";

     

       1330
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       1331
        
              mainProgram = "bnfc";

     

       1332
        
            }) {};

     

       1333
        
       

     
···

       2967
        
              pname = "Cabal-syntax";

     

       2968
        
              version = "3.8.1.0";

     

       2969
        
              sha256 = "03yfk3b2sjmqpxmvx3mj185nifiaqapvc8hmbx4825z0kyqxvs07";

     

       2970
       +
              revision = "2";

     

       2971
       +
              editedCabalFile = "1bzwjxj5mrsxxcgrfgisamx3f3ymz5bz085k6p83s7djh39ayaxx";

     

       2972
        
              libraryHaskellDepends = [

     

       2973
        
                array base binary bytestring containers deepseq directory filepath

     

       2974
        
                mtl parsec pretty text time transformers unix

     
···

       9611
        
              pname = "HStringTemplate";

     

       9612
        
              version = "0.8.8";

     

       9613
        
              sha256 = "1n8ci0kzjcgnqh4dfpqwlh7mnlzyiqiqc6hc0zr65p0balbg8zbi";

     

       9614
       +
              revision = "4";

     

       9615
       +
              editedCabalFile = "0sj82pzq2hcx3yjsljwgbr1kcdgwpgfmq0n0dhz3am8ckwir0slz";

     

       9616
        
              libraryHaskellDepends = [

     

       9617
        
                array base blaze-builder bytestring containers deepseq directory

     

       9618
        
                filepath mtl old-locale parsec pretty semigroups syb

     
···

       11098
        
           ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }:

     

       11099
        
            mkDerivation {

     

       11100
        
              pname = "HsOpenSSL";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       11101
        
              version = "0.11.7.4";

     

       11102
        
              sha256 = "0zxcfa8b0ng97v53vb8fvg2gss89b28xiz83rx38a0h4lsxpn2xf";

     

       11103
        
              setupHaskellDepends = [ base Cabal ];

     
···

       11106
        
              testHaskellDepends = [ base bytestring ];

     

       11107
        
              description = "Partial OpenSSL binding for Haskell";

     

       11108
        
              license = lib.licenses.publicDomain;

     

       0
        
       
     

       11109
        
            }) {inherit (pkgs) openssl;};

     

       11110
        
       

     

       11111
        
         "HsOpenSSL-x509-system" = callPackage

     
···

       12172
        
              ];

     

       12173
        
              description = "Scale JuicyPixels images with DCT";

     

       12174
        
              license = lib.licenses.bsd3;

     

       12175
       +
              hydraPlatforms = lib.platforms.none;

     

       12176
        
            }) {};

     

       12177
        
       

     

       12178
        
         "JuicyPixels-stbir" = callPackage

     
···

       15297
        
              hydraPlatforms = lib.platforms.none;

     

       15298
        
              broken = true;

     

       15299
        
            }) {};

     

       15300
       +
       

     

       15301
       +
         "OGDF" = callPackage

     

       15302
       +
           ({ mkDerivation, base, COIN, fficxx, fficxx-runtime, OGDF, stdcxx

     

       15303
       +
            , template-haskell

     

       15304
       +
            }:

     

       15305
       +
            mkDerivation {

     

       15306
       +
              pname = "OGDF";

     

       15307
       +
              version = "1.0.0.0";

     

       15308
       +
              sha256 = "0sn5xyn2yqh7aywadzxvaxcyqj2clivvizqdbnjkljib7960w44z";

     

       15309
       +
              libraryHaskellDepends = [

     

       15310
       +
                base fficxx fficxx-runtime stdcxx template-haskell

     

       15311
       +
              ];

     

       15312
       +
              librarySystemDepends = [ COIN OGDF ];

     

       15313
       +
              description = "Haskell binding to OGDF";

     

       15314
       +
              license = lib.licenses.bsd2;

     

       15315
       +
              hydraPlatforms = lib.platforms.none;

     

       15316
       +
              broken = true;

     

       15317
       +
            }) {COIN = null; OGDF = null;};

     

       15318
        
       

     

       15319
        
         "OGL" = callPackage

     

       15320
        
           ({ mkDerivation, base, mtl }:

     
···

       25177
        
            }:

     

       25178
        
            mkDerivation {

     

       25179
        
              pname = "advent-of-code-api";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25180
        
              version = "0.2.8.4";

     

       25181
        
              sha256 = "1l7bl0aqn5d6ph730jpwb5h0lwhvrkcw4vla0l73sxrm52j9ma58";

     

       25182
        
              libraryHaskellDepends = [

     
···

       25188
        
              testHaskellDepends = [ base directory filepath HUnit text ];

     

       25189
        
              description = "Advent of Code REST API bindings and servant API";

     

       25190
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       25191
        
            }) {};

     

       25192
        
       

     

       25193
        
         "advent-of-code-ocr" = callPackage

     
···

       31731
        
       

     

       31732
        
         "ansi-terminal-game" = callPackage

     

       31733
        
           ({ mkDerivation, ansi-terminal, array, base, bytestring, cereal

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31734
        
            , clock, colour, containers, exceptions, hspec, hspec-discover

     

       31735
        
            , linebreak, mintty, mtl, QuickCheck, random, split, terminal-size

     

       31736
        
            , timers-tick, unidecode

     
···

       31754
        
              testToolDepends = [ hspec-discover ];

     

       31755
        
              description = "sdl-like functions for terminal applications, based on ansi-terminal";

     

       31756
        
              license = lib.licenses.gpl3Only;

     

       0
        
       
     

       31757
        
            }) {};

     

       31758
        
       

     

       31759
        
         "ansi-wl-pprint" = callPackage

     
···

       35048
        
            }:

     

       35049
        
            mkDerivation {

     

       35050
        
              pname = "ascii";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35051
        
              version = "1.2.4.0";

     

       35052
        
              sha256 = "1rsv9ah0jvf66w3k4smh67wpbm03xl4pdyj8svmdy49hbpihimwi";

     

       35053
        
              libraryHaskellDepends = [

     
···

       35057
        
              testHaskellDepends = [ base hedgehog text ];

     

       35058
        
              description = "The ASCII character set and encoding";

     

       35059
        
              license = lib.licenses.asl20;

     

       0
        
       
     

       35060
        
            }) {};

     

       35061
        
       

     

       35062
        
         "ascii-art-to-unicode" = callPackage

     
···

       35076
        
            }) {};

     

       35077
        
       

     

       35078
        
         "ascii-case" = callPackage

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35079
        
           ({ mkDerivation, ascii-char, base, hashable, hspec }:

     

       35080
        
            mkDerivation {

     

       35081
        
              pname = "ascii-case";

     
···

       35085
        
              testHaskellDepends = [ ascii-char base hspec ];

     

       35086
        
              description = "ASCII letter case";

     

       35087
        
              license = lib.licenses.asl20;

     

       0
        
       
     

       35088
        
            }) {};

     

       35089
        
       

     

       35090
        
         "ascii-caseless" = callPackage

     
···

       35102
        
            }) {};

     

       35103
        
       

     

       35104
        
         "ascii-char" = callPackage

     

       35105
       +
           ({ mkDerivation, base, hashable, hspec }:

     

       35106
        
            mkDerivation {

     

       35107
        
              pname = "ascii-char";

     

       35108
       +
              version = "1.0.0.16";

     

       35109
       +
              sha256 = "06iig5p15ip0wpg330dq8kclq7g7j2xkrkk0dbl3z509d44mg049";

     

       0
        
       
     

       0
        
       
     

       35110
        
              libraryHaskellDepends = [ base hashable ];

     

       35111
       +
              testHaskellDepends = [ base hspec ];

     

       35112
        
              description = "A Char type representing an ASCII character";

     

       35113
        
              license = lib.licenses.asl20;

     

       35114
        
            }) {};

     

       35115
        
       

     

       35116
       +
         "ascii-char_1_0_0_17" = callPackage

     

       35117
        
           ({ mkDerivation, base, hashable, hspec }:

     

       35118
        
            mkDerivation {

     

       35119
        
              pname = "ascii-char";

     

       35120
       +
              version = "1.0.0.17";

     

       35121
       +
              sha256 = "1562gkfvrcjygs9qpyswsk25d4m2pxblmmbb0hw8jsaml2jwsyss";

     

       35122
        
              libraryHaskellDepends = [ base hashable ];

     

       35123
        
              testHaskellDepends = [ base hspec ];

     

       35124
        
              description = "A Char type representing an ASCII character";

     
···

       35159
        
           ({ mkDerivation, ascii-char, base, hashable, hedgehog }:

     

       35160
        
            mkDerivation {

     

       35161
        
              pname = "ascii-group";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35162
        
              version = "1.0.0.14";

     

       35163
        
              sha256 = "0rk3lvs4b6d4cfzb5zc87f42wdmziprpfd4fww5r68ry3ccyn1ps";

     

       35164
       +
              revision = "1";

     

       35165
       +
              editedCabalFile = "0iwf48cq67qzgw4ih6532yxl03bpnzrhz68y0yfk87r1y3hsdxfx";

     

       35166
        
              libraryHaskellDepends = [ ascii-char base hashable ];

     

       35167
        
              testHaskellDepends = [ ascii-char base hedgehog ];

     

       35168
        
              description = "ASCII character groups";

     

       35169
        
              license = lib.licenses.asl20;

     

       0
        
       
     

       35170
        
            }) {};

     

       35171
        
       

     

       35172
        
         "ascii-holidays" = callPackage

     
···

       35206
        
              license = lib.licenses.asl20;

     

       35207
        
            }) {};

     

       35208
        
       

     

       35209
       +
         "ascii-numbers_1_1_0_1" = callPackage

     

       35210
       +
           ({ mkDerivation, ascii-case, ascii-char, ascii-superset, base

     

       35211
       +
            , bytestring, hashable, hedgehog, invert, text

     

       35212
       +
            }:

     

       35213
       +
            mkDerivation {

     

       35214
       +
              pname = "ascii-numbers";

     

       35215
       +
              version = "1.1.0.1";

     

       35216
       +
              sha256 = "1zb37db0vpcnh63izq9m62p2an1w496ljh7d196k0i1w76j2jhiy";

     

       35217
       +
              libraryHaskellDepends = [

     

       35218
       +
                ascii-case ascii-char ascii-superset base bytestring hashable text

     

       35219
       +
              ];

     

       35220
       +
              testHaskellDepends = [

     

       35221
       +
                ascii-case ascii-char ascii-superset base bytestring hashable

     

       35222
       +
                hedgehog invert text

     

       35223
       +
              ];

     

       35224
       +
              description = "ASCII representations of numbers";

     

       35225
       +
              license = lib.licenses.asl20;

     

       35226
       +
              hydraPlatforms = lib.platforms.none;

     

       35227
       +
            }) {};

     

       35228
       +
       

     

       35229
        
         "ascii-predicates" = callPackage

     

       35230
        
           ({ mkDerivation, ascii-char, base, hedgehog }:

     

       35231
        
            mkDerivation {

     
···

       35238
        
              testHaskellDepends = [ ascii-char base hedgehog ];

     

       35239
        
              description = "Various categorizations of ASCII characters";

     

       35240
        
              license = lib.licenses.asl20;

     

       35241
       +
            }) {};

     

       35242
       +
       

     

       35243
       +
         "ascii-predicates_1_0_1_1" = callPackage

     

       35244
       +
           ({ mkDerivation, ascii-char, base, hedgehog }:

     

       35245
       +
            mkDerivation {

     

       35246
       +
              pname = "ascii-predicates";

     

       35247
       +
              version = "1.0.1.1";

     

       35248
       +
              sha256 = "1r8kd5p17jd46298wp7b1rvfg86g752k2x45ppqikrbkqv9vkvmc";

     

       35249
       +
              libraryHaskellDepends = [ ascii-char base ];

     

       35250
       +
              testHaskellDepends = [ ascii-char base hedgehog ];

     

       35251
       +
              description = "Various categorizations of ASCII characters";

     

       35252
       +
              license = lib.licenses.asl20;

     

       35253
       +
              hydraPlatforms = lib.platforms.none;

     

       35254
        
            }) {};

     

       35255
        
       

     

       35256
        
         "ascii-progress" = callPackage

     
···

       35315
        
              license = lib.licenses.asl20;

     

       35316
        
            }) {};

     

       35317
        
       

     

       35318
       +
         "ascii-superset_1_0_1_14" = callPackage

     

       35319
       +
           ({ mkDerivation, ascii-char, base, bytestring, hashable, hedgehog

     

       35320
       +
            , text

     

       35321
       +
            }:

     

       35322
       +
            mkDerivation {

     

       35323
       +
              pname = "ascii-superset";

     

       35324
       +
              version = "1.0.1.14";

     

       35325
       +
              sha256 = "1zggxgxwdc8cd224dgmrq0bijgi0adv233ysnpaw97sa9m6mgmb6";

     

       35326
       +
              libraryHaskellDepends = [

     

       35327
       +
                ascii-char base bytestring hashable text

     

       35328
       +
              ];

     

       35329
       +
              testHaskellDepends = [ ascii-char base hedgehog text ];

     

       35330
       +
              description = "Representing ASCII with refined supersets";

     

       35331
       +
              license = lib.licenses.asl20;

     

       35332
       +
              hydraPlatforms = lib.platforms.none;

     

       35333
       +
            }) {};

     

       35334
       +
       

     

       35335
        
         "ascii-table" = callPackage

     

       35336
        
           ({ mkDerivation, aeson, base, containers, dlist, hashable, text

     

       35337
        
            , unordered-containers, vector, wl-pprint-extras

     
···

       35369
        
              license = lib.licenses.asl20;

     

       35370
        
            }) {};

     

       35371
        
       

     

       35372
       +
         "ascii-th_1_0_0_12" = callPackage

     

       35373
       +
           ({ mkDerivation, ascii-char, ascii-superset, base, bytestring

     

       35374
       +
            , hedgehog, template-haskell, text

     

       35375
       +
            }:

     

       35376
       +
            mkDerivation {

     

       35377
       +
              pname = "ascii-th";

     

       35378
       +
              version = "1.0.0.12";

     

       35379
       +
              sha256 = "1kdqkd7sq8kb8ymy4p45w39ndr7z2jcjy9c5ws227hrhglam9pcy";

     

       35380
       +
              libraryHaskellDepends = [

     

       35381
       +
                ascii-char ascii-superset base template-haskell

     

       35382
       +
              ];

     

       35383
       +
              testHaskellDepends = [

     

       35384
       +
                ascii-char ascii-superset base bytestring hedgehog text

     

       35385
       +
              ];

     

       35386
       +
              description = "Template Haskell support for ASCII";

     

       35387
       +
              license = lib.licenses.asl20;

     

       35388
       +
              hydraPlatforms = lib.platforms.none;

     

       35389
       +
            }) {};

     

       35390
       +
       

     

       35391
        
         "ascii-vector-avc" = callPackage

     

       35392
        
           ({ mkDerivation, attoparsec, base, binary, bytestring, deepseq

     

       35393
        
            , deepseq-generics, HUnit, split, zlib

     
···

       36530
        
              hydraPlatforms = lib.platforms.none;

     

       36531
        
            }) {};

     

       36532
        
       

     

       36533
       +
         "atomic-counter" = callPackage

     

       36534
       +
           ({ mkDerivation, async, base, primitive, QuickCheck, stm, tasty

     

       36535
       +
            , tasty-bench, tasty-quickcheck

     

       36536
       +
            }:

     

       36537
       +
            mkDerivation {

     

       36538
       +
              pname = "atomic-counter";

     

       36539
       +
              version = "0.1";

     

       36540
       +
              sha256 = "1vrggycr9jbnrx2gz71rfqrldmf6417kx5sp2w5g238iv6a3m9p1";

     

       36541
       +
              libraryHaskellDepends = [ async base QuickCheck ];

     

       36542
       +
              testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];

     

       36543
       +
              benchmarkHaskellDepends = [

     

       36544
       +
                base primitive QuickCheck stm tasty tasty-bench tasty-quickcheck

     

       36545
       +
              ];

     

       36546
       +
              doHaddock = false;

     

       36547
       +
              description = "Mutable counters that can be modified with atomic operatinos";

     

       36548
       +
              license = lib.licenses.asl20;

     

       36549
       +
            }) {};

     

       36550
       +
       

     

       36551
        
         "atomic-file-ops" = callPackage

     

       36552
        
           ({ mkDerivation, base, directory, filelock, filepath

     

       36553
        
            , io-string-like

     
···

       37665
        
              ];

     

       37666
        
              description = "Autodocodec interpreters for openapi3";

     

       37667
        
              license = lib.licenses.mit;

     

       37668
       +
              hydraPlatforms = lib.platforms.none;

     

       37669
        
            }) {};

     

       37670
        
       

     

       37671
        
         "autodocodec-schema" = callPackage

     
···

       39956
        
            }:

     

       39957
        
            mkDerivation {

     

       39958
        
              pname = "barbies";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       39959
        
              version = "2.0.4.0";

     

       39960
        
              sha256 = "0v8bckxi58fkqgf1i1xd3100wp792pzd319xlfvmmw8z0ii1g872";

     

       39961
        
              libraryHaskellDepends = [ base distributive transformers ];

     
···

       39964
        
              ];

     

       39965
        
              description = "Classes for working with types that can change clothes";

     

       39966
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       39967
        
            }) {};

     

       39968
        
       

     

       39969
        
         "barbies-layered" = callPackage

     
···

       42044
        
           ({ mkDerivation, base, hspec }:

     

       42045
        
            mkDerivation {

     

       42046
        
              pname = "benri-hspec";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       42047
        
              version = "0.1.0.1";

     

       42048
        
              sha256 = "11x7dsp6hmz1an1nm8076lgdvgd8r67hl54p81jprpi8m0lh6mqa";

     

       42049
        
              libraryHaskellDepends = [ base hspec ];

     

       42050
        
              description = "Simplify tests where Either or Maybe types are returned from monadic code";

     

       42051
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       42052
        
            }) {};

     

       42053
        
       

     

       42054
        
         "bento" = callPackage

     
···

       47585
        
            }:

     

       47586
        
            mkDerivation {

     

       47587
        
              pname = "boomerang";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       47588
        
              version = "1.4.8.1";

     

       47589
        
              sha256 = "1hal4z1c1skqjq7vvjql0gm2rhfgrrlj29rgchjwlr2hm22zgnjp";

     

       47590
        
              libraryHaskellDepends = [

     
···

       47592
        
              ];

     

       47593
        
              description = "Library for invertible parsing and printing";

     

       47594
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       47595
        
            }) {};

     

       47596
        
       

     

       47597
        
         "boomslang" = callPackage

     
···

       50627
        
            }:

     

       50628
        
            mkDerivation {

     

       50629
        
              pname = "bytesmith";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       50630
        
              version = "0.3.9.1";

     

       50631
        
              sha256 = "10d0wzinc30b2xc26cfadvpn29gf30gnppysyl3n35ym3p9lnhm2";

     

       50632
        
              libraryHaskellDepends = [

     
···

       50642
        
              ];

     

       50643
        
              description = "Nonresumable byte parser";

     

       50644
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       50645
        
            }) {};

     

       50646
        
       

     

       50647
        
         "bytestring_0_11_3_1" = callPackage

     
···

       51720
        
            }:

     

       51721
        
            mkDerivation {

     

       51722
        
              pname = "cabal-cache";

     

       51723
       +
              version = "1.0.5.5";

     

       51724
       +
              sha256 = "0474z8cw2wikqg3bnsxqj4rxy13n5l8p06fq72l4klh01s8i1qfl";

     

       51725
        
              isLibrary = true;

     

       51726
        
              isExecutable = true;

     

       51727
        
              libraryHaskellDepends = [

     
···

       57791
        
            }) {};

     

       57792
        
       

     

       57793
        
         "chimera" = callPackage

     

       57794
       +
           ({ mkDerivation, adjunctions, base, distributive, mtl, primitive

     

       57795
       +
            , QuickCheck, random, tasty, tasty-bench, tasty-hunit

     

       57796
       +
            , tasty-quickcheck, tasty-smallcheck, transformers, vector

     

       57797
        
            }:

     

       57798
        
            mkDerivation {

     

       57799
        
              pname = "chimera";

     

       57800
       +
              version = "0.3.3.0";

     

       57801
       +
              sha256 = "1cy38pgdlgz4f1fglm70w3dlqbnd0lzpckr7j065nnpp0ljlwlpx";

     

       57802
        
              libraryHaskellDepends = [

     

       57803
       +
                adjunctions base distributive mtl primitive transformers vector

     

       57804
        
              ];

     

       57805
        
              testHaskellDepends = [

     

       57806
        
                base QuickCheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck

     

       57807
        
                vector

     

       57808
        
              ];

     

       57809
       +
              benchmarkHaskellDepends = [ base mtl random tasty tasty-bench ];

     

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

     

       57811
        
              license = lib.licenses.bsd3;

     

       57812
        
            }) {};

     
···

       59384
        
              pname = "clash-prelude";

     

       59385
        
              version = "1.6.4";

     

       59386
        
              sha256 = "12ic8jcgz3jr4zrgrx06dzd6whlypyyxilrgbja27dcdv02fs6yr";

     

       59387
       +
              revision = "1";

     

       59388
       +
              editedCabalFile = "09ra3gbhghrqlzaanjlvm0qpj05v3ilps62lblzy44n7sxmc5db7";

     

       59389
        
              libraryHaskellDepends = [

     

       59390
        
                array arrows base binary bytestring constraints containers

     

       59391
        
                data-binary-ieee754 data-default-class deepseq extra ghc-bignum

     
···

       64393
        
            }:

     

       64394
        
            mkDerivation {

     

       64395
        
              pname = "composite-base";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       64396
        
              version = "0.8.2.1";

     

       64397
        
              sha256 = "0i2mamh5gz7ay1cm5nkmdbh2lnaph42pfi2aa9jb2baxi0jgxdri";

     

       64398
        
              libraryHaskellDepends = [

     
···

       64407
        
              ];

     

       64408
        
              description = "Shared utilities for composite-* packages";

     

       64409
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       64410
        
            }) {};

     

       64411
        
       

     

       64412
        
         "composite-binary" = callPackage

     

       64413
        
           ({ mkDerivation, base, binary, composite-base }:

     

       64414
        
            mkDerivation {

     

       64415
        
              pname = "composite-binary";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       64416
        
              version = "0.8.2.1";

     

       64417
        
              sha256 = "0bxnzxvw5mjhz3kh6x265l70hp1z3z1y9fbdwhrgv6bhhinxb3hq";

     

       64418
        
              libraryHaskellDepends = [ base binary composite-base ];

     

       64419
        
              description = "Orphan binary instances";

     

       64420
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       64421
        
            }) {};

     

       64422
        
       

     

       64423
        
         "composite-cassava" = callPackage

     
···

       64462
        
            }:

     

       64463
        
            mkDerivation {

     

       64464
        
              pname = "composite-ekg";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       64465
        
              version = "0.8.2.1";

     

       64466
        
              sha256 = "0c0rxa30r19wcvqrw20xk96652mxknbs1lqpnzdj9kz77al3k1kl";

     

       64467
        
              libraryHaskellDepends = [

     
···

       64469
        
              ];

     

       64470
        
              description = "EKG Metrics for Vinyl records";

     

       64471
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       64472
        
            }) {};

     

       64473
        
       

     

       64474
        
         "composite-hashable" = callPackage

     
···

       74585
        
           ({ mkDerivation, base }:

     

       74586
        
            mkDerivation {

     

       74587
        
              pname = "data-forest";

     

       74588
       +
              version = "0.1.0.10";

     

       74589
       +
              sha256 = "0wfw87vb00lgc1pf6cmqmlzfqskhy42kyzfj5nyfw1lch8s6sbvm";

     

       0
        
       
     

       0
        
       
     

       74590
        
              libraryHaskellDepends = [ base ];

     

       74591
        
              testHaskellDepends = [ base ];

     

       74592
        
              description = "A simple multi-way tree data structure";

     
···

       78173
        
           ({ mkDerivation, base, constraints-extras, some }:

     

       78174
        
            mkDerivation {

     

       78175
        
              pname = "dependent-sum";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       78176
        
              version = "0.7.2.0";

     

       78177
        
              sha256 = "1frw5965v8i6xqdgs95gg8asgdqcqnmfahz0pmbwiaw5ybn62rc2";

     

       78178
        
              libraryHaskellDepends = [ base constraints-extras some ];

     

       78179
        
              description = "Dependent sum type";

     

       78180
        
              license = lib.licenses.publicDomain;

     

       0
        
       
     

       78181
        
            }) {};

     

       78182
        
       

     

       78183
        
         "dependent-sum-aeson-orphans" = callPackage

     
···

       81073
        
           ({ mkDerivation, base, bytestring, zlib }:

     

       81074
        
            mkDerivation {

     

       81075
        
              pname = "digest";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       81076
        
              version = "0.0.1.4";

     

       81077
        
              sha256 = "05pc5l4bwddszc6vy1hazwi1dnrxg323521gdkis9cvh7zs2a4gr";

     

       81078
        
              libraryHaskellDepends = [ base bytestring ];

     

       81079
        
              libraryPkgconfigDepends = [ zlib ];

     

       81080
        
              description = "Various hashes for bytestrings; CRC32 and Adler32 for now";

     

       81081
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       81082
        
            }) {inherit (pkgs) zlib;};

     

       81083
        
       

     

       81084
        
         "digest-pure" = callPackage

     
···

       83413
        
            }:

     

       83414
        
            mkDerivation {

     

       83415
        
              pname = "dlist-nonempty";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       83416
        
              version = "0.1.2";

     

       83417
        
              sha256 = "1phdqr9fi2smscmqn7l9kfjxfnqfw6ws1v0a1lrqm5civ15gxhms";

     

       83418
        
              libraryHaskellDepends = [ base deepseq dlist semigroupoids ];

     
···

       83424
        
              ];

     

       83425
        
              description = "Non-empty difference lists";

     

       83426
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       83427
        
            }) {};

     

       83428
        
       

     

       83429
        
         "dmc" = callPackage

     
···

       84342
        
           ({ mkDerivation, base, doctest }:

     

       84343
        
            mkDerivation {

     

       84344
        
              pname = "doctest-driver-gen";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       84345
        
              version = "0.3.0.6";

     

       84346
        
              sha256 = "0a4jdg4mzhdgfal7jp60yrlv63iv7d8f7nxc9aqvrl93mairny8l";

     

       84347
        
              isLibrary = true;

     
···

       84351
        
              testHaskellDepends = [ base doctest ];

     

       84352
        
              description = "Generate driver file for doctest's cabal integration";

     

       84353
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       84354
        
              mainProgram = "doctest-driver-gen";

     

       84355
        
            }) {};

     

       84356
        
       

     
···

       84414
        
            }:

     

       84415
        
            mkDerivation {

     

       84416
        
              pname = "doctest-parallel";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       84417
        
              version = "0.2.6";

     

       84418
        
              sha256 = "13hjwhdjw8jrj07zxkrrfbzr0mrk8gwyis1rbdi4ld4jbq3rr1z7";

     

       84419
        
              libraryHaskellDepends = [

     
···

       84431
        
              doHaddock = false;

     

       84432
        
              description = "Test interactive Haskell examples";

     

       84433
        
              license = lib.licenses.mit;

     

       0
        
       
     

       84434
        
            }) {};

     

       84435
        
       

     

       84436
        
         "doctest-prop" = callPackage

     
···

       84950
        
            }:

     

       84951
        
            mkDerivation {

     

       84952
        
              pname = "dotenv";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       84953
        
              version = "0.10.0.0";

     

       84954
        
              sha256 = "04brkjk9a17xv2qv2xbsdxbil6ncrrzxcfji9q0civmxhj4vbcfq";

     

       84955
        
              isLibrary = true;

     
···

       84969
        
              testToolDepends = [ hspec-discover ];

     

       84970
        
              description = "Loads environment variables from dotenv files";

     

       84971
        
              license = lib.licenses.mit;

     

       0
        
       
     

       84972
        
              mainProgram = "dotenv";

     

       84973
        
            }) {};

     

       84974
        
       

     
···

       85056
        
            }:

     

       85057
        
            mkDerivation {

     

       85058
        
              pname = "double-conversion";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       85059
        
              version = "2.0.4.2";

     

       85060
        
              sha256 = "0r7c1801gzdm5x1flmpx8ajxygbc9dl7sgdj0xn3bpm71wgvrf4s";

     

       85061
        
              revision = "2";

     
···

       85067
        
              ];

     

       85068
        
              description = "Fast conversion between single and double precision floating point and text";

     

       85069
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       85070
        
            }) {};

     

       85071
        
       

     

       85072
        
         "double-extra" = callPackage

     
···

       86396
        
            }:

     

       86397
        
            mkDerivation {

     

       86398
        
              pname = "dunai";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       86399
        
              version = "0.9.2";

     

       86400
        
              sha256 = "08skmwkfwiyy83s764fcpa9i8zny10bdbpv9wha6fjqr1b80i80f";

     

       86401
        
              libraryHaskellDepends = [

     
···

       86404
        
              testHaskellDepends = [ base tasty tasty-hunit transformers ];

     

       86405
        
              description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";

     

       86406
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       86407
        
              maintainers = [ lib.maintainers.turion ];

     

       86408
        
            }) {};

     

       86409
        
       

     
···

       92245
        
            }:

     

       92246
        
            mkDerivation {

     

       92247
        
              pname = "essence-of-live-coding";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       92248
        
              version = "0.2.7";

     

       92249
        
              sha256 = "1vg10x8radvr8ysqfzf1cngp2hnqy8g139x07pwqwycj9zwwnbl4";

     

       92250
        
              isLibrary = true;

     
···

       92288
        
            }:

     

       92289
        
            mkDerivation {

     

       92290
        
              pname = "essence-of-live-coding-gloss";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       92291
        
              version = "0.2.7";

     

       92292
        
              sha256 = "0iv5wgzfxy1k80dh6c6hrzh4jcjy3ak4l3l004jm3wpfm7fm0lmx";

     

       92293
        
              libraryHaskellDepends = [

     
···

       92325
        
            }:

     

       92326
        
            mkDerivation {

     

       92327
        
              pname = "essence-of-live-coding-pulse";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       92328
        
              version = "0.2.7";

     

       92329
        
              sha256 = "0bmnc7901zgak223kfm29md0w5fd9lfv4dxc8c27cdcrdqnqfc2p";

     

       92330
        
              libraryHaskellDepends = [

     
···

       92362
        
            }:

     

       92363
        
            mkDerivation {

     

       92364
        
              pname = "essence-of-live-coding-quickcheck";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       92365
        
              version = "0.2.7";

     

       92366
        
              sha256 = "0jn5bz7xq8jmlkhrrbn5mj3ywh8288gpx43n8fkjzmzdk233kbvp";

     

       92367
        
              libraryHaskellDepends = [

     
···

       92392
        
            }:

     

       92393
        
            mkDerivation {

     

       92394
        
              pname = "essence-of-live-coding-warp";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       92395
        
              version = "0.2.7";

     

       92396
        
              sha256 = "1zykg5qik61xr4ri6d9r04w5rj7wm0wqmnzm6nipwpixal3gdxqa";

     

       92397
        
              libraryHaskellDepends = [

     
···

       93725
        
           ({ mkDerivation, base, template-haskell }:

     

       93726
        
            mkDerivation {

     

       93727
        
              pname = "exception-hierarchy";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       93728
        
              version = "0.1.0.8";

     

       93729
        
              sha256 = "17wx40kic0gw5lbz1nr094ps612i0j0pbf0wfj4kgzsl6cj80hih";

     

       93730
        
              libraryHaskellDepends = [ base template-haskell ];

     

       93731
        
              description = "Exception type hierarchy with TemplateHaskell";

     

       93732
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       93733
        
            }) {};

     

       93734
        
       

     

       93735
        
         "exception-mailer" = callPackage

     
···

       94387
        
         "exon" = callPackage

     

       94388
        
           ({ mkDerivation, base, criterion, flatparse, generics-sop

     

       94389
        
            , ghc-hs-meta, hedgehog, incipit-base, tasty, tasty-hedgehog

     

       94390
       +
            , template-haskell

     

       94391
        
            }:

     

       94392
        
            mkDerivation {

     

       94393
        
              pname = "exon";

     

       94394
       +
              version = "1.3.0.0";

     

       94395
       +
              sha256 = "1w93x0yfqm1yp82lh2q1wibb88xn7rh4vh16pq1pzs8vdhgbapc2";

     

       94396
        
              libraryHaskellDepends = [

     

       94397
        
                base flatparse generics-sop ghc-hs-meta incipit-base

     

       94398
       +
                template-haskell

     

       94399
        
              ];

     

       94400
        
              testHaskellDepends = [

     

       94401
        
                base hedgehog incipit-base tasty tasty-hedgehog template-haskell

     
···

       94403
        
              benchmarkHaskellDepends = [ base criterion incipit-base ];

     

       94404
        
              description = "Customizable Quasiquote Interpolation";

     

       94405
        
              license = "BSD-2-Clause-Patent";

     

       0
        
       
     

       94406
        
            }) {};

     

       94407
        
       

     

       94408
        
         "exotic-list-monads" = callPackage

     
···

       97790
        
              testHaskellDepends = [ base carray QuickCheck storable-complex ];

     

       97791
        
              description = "Bindings to the FFTW library";

     

       97792
        
              license = lib.licenses.bsd3;

     

       97793
       +
              hydraPlatforms = lib.platforms.none;

     

       97794
       +
              broken = true;

     

       97795
        
            }) {inherit (pkgs) fftw; inherit (pkgs) fftwFloat;};

     

       97796
        
       

     

       97797
        
         "fftw-ffi" = callPackage

     
···

       99291
        
            }:

     

       99292
        
            mkDerivation {

     

       99293
        
              pname = "fix-whitespace";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       99294
        
              version = "0.0.11";

     

       99295
        
              sha256 = "0q36vr3pfk1x14hl86g4g557299ih0510j7cf37h8n5nv8bs8gq2";

     

       99296
        
              isLibrary = false;

     
···

       99300
        
              ];

     

       99301
        
              description = "Fixes whitespace issues";

     

       99302
        
              license = "unknown";

     

       0
        
       
     

       99303
        
              mainProgram = "fix-whitespace";

     

       99304
        
            }) {};

     

       99305
        
       

     
···

       99424
        
           ({ mkDerivation, base, deepseq, doctest, filemanip, primitive }:

     

       99425
        
            mkDerivation {

     

       99426
        
              pname = "fixed-vector";

     

       99427
       +
              version = "1.2.2.1";

     

       99428
       +
              sha256 = "0kp747v67x1ija33nyqmyh6g178pqn2c7glynrpzcv733lalp00z";

     

       99429
        
              libraryHaskellDepends = [ base deepseq primitive ];

     

       99430
        
              testHaskellDepends = [ base doctest filemanip primitive ];

     

       99431
        
              description = "Generic vectors with statically known size";

     

       99432
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       99433
        
            }) {};

     

       99434
        
       

     

       99435
        
         "fixed-vector-binary" = callPackage

     
···

       123157
        
              pname = "hackage-security-HTTP";

     

       123158
        
              version = "0.1.1.1";

     

       123159
        
              sha256 = "14hp7gssf80b9937j7m56w8sxrv3hrzjf2s9kgfk76v6llgx79k2";

     

       123160
       +
              revision = "4";

     

       123161
       +
              editedCabalFile = "09hs3iidjlwdppm5q1vq58p70js11whhcl5nr73kv8zj1yh0ir3h";

     

       123162
        
              libraryHaskellDepends = [

     

       123163
        
                base bytestring hackage-security HTTP mtl network network-uri zlib

     

       123164
        
              ];

     
···

       126296
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       126297
        
            mkDerivation {

     

       126298
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       126299
       +
              version = "0.0.0.4";

     

       126300
       +
              sha256 = "07cqp51hq9andw9pw5nbpqkcmk4q6a9xlspayfh964pvz7p0vsbv";

     

       126301
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       126302
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       126303
        
              license = lib.licenses.mit;

     
···

       128523
        
           ({ mkDerivation, base }:

     

       128524
        
            mkDerivation {

     

       128525
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       128526
        
              version = "1.1.1";

     

       128527
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       128528
        
              libraryHaskellDepends = [ base ];

     

       128529
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     

       128530
        
              license = lib.licenses.mit;

     

       0
        
       
     

       128531
        
            }) {};

     

       128532
        
       

     

       128533
        
           ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec

     
···

       134644
        
            }:

     

       134645
        
            mkDerivation {

     

       134646
        
              pname = "hedgehog-classes";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       134647
        
              version = "0.2.5.4";

     

       134648
        
              sha256 = "0z9ik5asddc2pnz430jsi1pyahkh6jy36ng0vwm7ywcq7cvhcvlz";

     

       134649
        
              libraryHaskellDepends = [

     
···

       134655
        
              ];

     

       134656
        
              description = "Hedgehog will eat your typeclass bugs";

     

       134657
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       134658
        
            }) {};

     

       134659
        
       

     

       134660
        
         "hedgehog-corpus" = callPackage

     
···

       135716
        
            }:

     

       135717
        
            mkDerivation {

     

       135718
        
              pname = "hercules-ci-agent";

     

       135719
       +
              version = "0.9.10";

     

       135720
       +
              sha256 = "1sbp3jjn54z6hwkfgb83g0zgn1dm8qi9254g2yc8r4msm6n3nzww";

     

       135721
        
              isLibrary = true;

     

       135722
        
              isExecutable = true;

     

       135723
        
              enableSeparateDataOutput = true;

     
···

       135770
        
            }:

     

       135771
        
            mkDerivation {

     

       135772
        
              pname = "hercules-ci-api";

     

       135773
       +
              version = "0.7.2.1";

     

       135774
       +
              sha256 = "1nkmiyfmidrfqvlfy9k75y4asrrbrs2511kdzhrpb3zlrlaw4zb8";

     

       135775
        
              isLibrary = true;

     

       135776
        
              isExecutable = true;

     

       135777
        
              libraryHaskellDepends = [

     
···

       135803
        
            }:

     

       135804
        
            mkDerivation {

     

       135805
        
              pname = "hercules-ci-api-agent";

     

       135806
       +
              version = "0.4.6.1";

     

       135807
       +
              sha256 = "07gvmcag36ai945j7bxnvy2x8fsx9apkabcikp6x1a2anvkgws24";

     

       135808
        
              libraryHaskellDepends = [

     

       135809
        
                aeson base base64-bytestring-type bytestring containers cookie

     

       135810
        
                deepseq exceptions hashable hercules-ci-api-core http-api-data

     
···

       135852
        
            , hercules-ci-api, hercules-ci-api-agent, hercules-ci-api-core

     

       135853
        
            , hercules-ci-cnix-expr, hercules-ci-cnix-store

     

       135854
        
            , hercules-ci-optparse-applicative, hostname, hspec, http-client

     

       135855
       +
            , http-client-tls, http-types, inline-c-cpp, katip, lens

     

       135856
       +
            , lens-aeson, lifted-base, monad-control, network-uri, process

     

       135857
       +
            , protolude, QuickCheck, retry, rio, safe-exceptions, servant

     

       135858
       +
            , servant-auth-client, servant-client, servant-client-core

     

       135859
       +
            , servant-conduit, temporary, text, transformers, transformers-base

     

       135860
       +
            , unix, unliftio, unliftio-core, unordered-containers, uuid

     

       135861
        
            }:

     

       135862
        
            mkDerivation {

     

       135863
        
              pname = "hercules-ci-cli";

     

       135864
       +
              version = "0.3.5";

     

       135865
       +
              sha256 = "0mk6q6ccgpdpjfc7mdms28dbhh1bawy4jnnqcfcb6vxg4cj83f44";

     

       135866
        
              isLibrary = true;

     

       135867
        
              isExecutable = true;

     

       135868
        
              libraryHaskellDepends = [

     
···

       135871
        
                hercules-ci-agent hercules-ci-api hercules-ci-api-agent

     

       135872
        
                hercules-ci-api-core hercules-ci-cnix-expr hercules-ci-cnix-store

     

       135873
        
                hercules-ci-optparse-applicative hostname http-client

     

       135874
       +
                http-client-tls http-types inline-c-cpp katip lens lens-aeson

     

       135875
       +
                lifted-base monad-control network-uri process protolude retry rio

     

       135876
        
                safe-exceptions servant servant-auth-client servant-client

     

       135877
        
                servant-client-core servant-conduit temporary text transformers

     

       135878
        
                transformers-base unix unliftio unliftio-core unordered-containers

     
···

       135901
        
            }:

     

       135902
        
            mkDerivation {

     

       135903
        
              pname = "hercules-ci-cnix-expr";

     

       135904
       +
              version = "0.3.5.0";

     

       135905
       +
              sha256 = "0r70kjn8a1wiw1zndahrg2gc88k52dscm4yjmms2caf22pkh562a";

     

       135906
        
              enableSeparateDataOutput = true;

     

       135907
        
              setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ];

     

       135908
        
              libraryHaskellDepends = [

     
···

       135931
        
            }:

     

       135932
        
            mkDerivation {

     

       135933
        
              pname = "hercules-ci-cnix-store";

     

       135934
       +
              version = "0.3.3.3";

     

       135935
       +
              sha256 = "1w4azya8phkk3gmkifcv2pc6jh8zanwk9m2vwqsdgk7kr8zkkzws";

     

       135936
        
              setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ];

     

       135937
        
              libraryHaskellDepends = [

     

       135938
        
                base bytestring conduit containers inline-c inline-c-cpp protolude

     
···

       136366
        
           ({ mkDerivation, abstract-par, aeson, ansi-wl-pprint, array, async

     

       136367
        
            , base, base16-bytestring, binary, brick, bytestring, cereal

     

       136368
        
            , containers, cryptonite, data-dword, Decimal, deepseq, directory

     

       136369
       +
            , fgl, filemanip, filepath, free, haskeline, here, HUnit, lens

     

       136370
       +
            , lens-aeson, libff, megaparsec, memory, monad-par, mtl, multiset

     

       136371
       +
            , operational, optparse-generic, parsec, process, QuickCheck

     

       136372
        
            , quickcheck-instances, quickcheck-text, regex, regex-tdfa

     

       136373
        
            , restless-git, rosezipper, s-cargot, scientific, secp256k1

     

       136374
        
            , semver-range, smt2-parser, spool, tasty, tasty-expected-failure

     
···

       136378
        
            }:

     

       136379
        
            mkDerivation {

     

       136380
        
              pname = "hevm";

     

       136381
       +
              version = "0.50.1";

     

       136382
       +
              sha256 = "07s6p22j8cagwyni8f362c0z9cmd7l0xhh6cm0xv1g7kphnla2qp";

     

       136383
        
              isLibrary = true;

     

       136384
        
              isExecutable = true;

     

       0
        
       
     

       136385
        
              libraryHaskellDepends = [

     

       136386
        
                abstract-par aeson ansi-wl-pprint array async base

     

       136387
        
                base16-bytestring binary brick bytestring cereal containers

     

       136388
       +
                cryptonite data-dword Decimal deepseq directory fgl filemanip

     

       136389
       +
                filepath free haskeline here HUnit lens lens-aeson megaparsec

     

       136390
       +
                memory monad-par mtl multiset operational optparse-generic parsec

     

       136391
       +
                process QuickCheck quickcheck-instances quickcheck-text regex

     

       136392
       +
                regex-tdfa restless-git rosezipper s-cargot scientific semver-range

     

       136393
       +
                smt2-parser spool tasty tasty-expected-failure tasty-hunit

     

       136394
       +
                tasty-quickcheck temporary text time transformers tree-view tuple

     

       136395
       +
                unordered-containers vector vty witherable word-wrap wreq

     

       136396
        
              ];

     

       136397
        
              librarySystemDepends = [ libff secp256k1 ];

     

       136398
        
              executableHaskellDepends = [

     
···

       136403
        
                temporary text unordered-containers vector vty

     

       136404
        
              ];

     

       136405
        
              testHaskellDepends = [

     

       136406
       +
                aeson array base base16-bytestring binary bytestring containers

     

       136407
       +
                data-dword directory filemanip filepath here HUnit lens mtl process

     

       136408
       +
                QuickCheck quickcheck-instances regex regex-tdfa smt2-parser tasty

     

       136409
        
                tasty-expected-failure tasty-hunit tasty-quickcheck temporary text

     

       136410
       +
                time vector witherable

     

       136411
        
              ];

     

       136412
        
              testSystemDepends = [ secp256k1 ];

     

       136413
        
              doHaddock = false;

     

       136414
        
              description = "Ethereum virtual machine evaluator";

     

       136415
        
              license = lib.licenses.agpl3Only;

     

       0
        
       
     

       136416
        
              mainProgram = "hevm";

     

       136417
        
              maintainers = [ lib.maintainers.arturcygan ];

     

       0
        
       
     

       136418
        
            }) {inherit (pkgs) libff; inherit (pkgs) secp256k1;};

     

       136419
        
       

     

       136420
        
         "hevolisa" = callPackage

     
···

       140739
        
              ];

     

       140740
        
              description = "Call hierarchy plugin for Haskell Language Server";

     

       140741
        
              license = lib.licenses.asl20;

     

       140742
       +
              hydraPlatforms = lib.platforms.none;

     

       140743
       +
              broken = true;

     

       140744
        
            }) {};

     

       140745
        
       

     

       140746
        
         "hls-change-type-signature-plugin" = callPackage

     
···

       143895
        
            }:

     

       143896
        
            mkDerivation {

     

       143897
        
              pname = "horizon-gen-nix";

     

       143898
       +
              version = "0.4.0";

     

       143899
       +
              sha256 = "0s0macrn45wh1y7nflw9y73wxsynvym7n12f9n0yhxi8w3j7wzn2";

     

       143900
        
              isLibrary = true;

     

       143901
        
              isExecutable = true;

     

       143902
        
              libraryHaskellDepends = [

     
···

       144330
        
              mainProgram = "hp2pretty";

     

       144331
        
            }) {};

     

       144332
        
       

     

       144333
       +
         "hpack_0_35_0" = callPackage

     

       144334
        
           ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal

     

       144335
        
            , containers, cryptonite, deepseq, directory, filepath, Glob, hspec

     

       144336
        
            , hspec-discover, http-client, http-client-tls, http-types, HUnit

     
···

       144368
        
              testToolDepends = [ hspec-discover ];

     

       144369
        
              description = "A modern format for Haskell packages";

     

       144370
        
              license = lib.licenses.mit;

     

       144371
       +
              hydraPlatforms = lib.platforms.none;

     

       144372
        
              mainProgram = "hpack";

     

       144373
        
            }) {};

     

       144374
        
       

     

       144375
       +
         "hpack" = callPackage

     

       144376
        
           ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal

     

       144377
        
            , containers, cryptonite, deepseq, directory, filepath, Glob, hspec

     

       144378
        
            , hspec-discover, http-client, http-client-tls, http-types, HUnit

     
···

       144408
        
              testToolDepends = [ hspec-discover ];

     

       144409
        
              description = "A modern format for Haskell packages";

     

       144410
        
              license = lib.licenses.mit;

     

       0
        
       
     

       144411
        
              mainProgram = "hpack";

     

       144412
        
            }) {};

     

       144413
        
       

     
···

       154902
        
            }:

     

       154903
        
            mkDerivation {

     

       154904
        
              pname = "hw-json-simd";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       154905
        
              version = "0.1.1.2";

     

       154906
        
              sha256 = "03g2gwmkp6v7b0vf4x8bh4qk91ghr0av5x3c9paj3rp3igycccd6";

     

       154907
        
              isLibrary = true;

     
···

       154918
        
              testToolDepends = [ doctest-discover ];

     

       154919
        
              description = "SIMD-based JSON semi-indexer";

     

       154920
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       154921
        
              mainProgram = "hw-json-simd";

     

       154922
        
            }) {};

     

       154923
        
       

     
···

       155343
        
            }:

     

       155344
        
            mkDerivation {

     

       155345
        
              pname = "hw-simd";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       155346
        
              version = "0.1.2.2";

     

       155347
        
              sha256 = "0ipcrv19xwmq6znbmwmzrjahmymmcmpbs7hpx0183hrwbx2hyhqx";

     

       155348
        
              libraryHaskellDepends = [

     
···

       155364
        
              ];

     

       155365
        
              description = "SIMD library";

     

       155366
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       155367
        
            }) {};

     

       155368
        
       

     

       155369
        
         "hw-simd-cli" = callPackage

     
···

       159217
        
            }:

     

       159218
        
            mkDerivation {

     

       159219
        
              pname = "incipit";

     

       159220
       +
              version = "0.7.0.0";

     

       159221
       +
              sha256 = "00ymmb2d5hlskc2zc88kibgx1c5mxp4bdfymahzhqg1qhyw3q9ci";

     

       159222
        
              libraryHaskellDepends = [

     

       159223
        
                base incipit-core polysemy-conc polysemy-log polysemy-resume

     

       159224
        
                polysemy-time

     
···

       159234
        
            }:

     

       159235
        
            mkDerivation {

     

       159236
        
              pname = "incipit-base";

     

       159237
       +
              version = "0.5.0.0";

     

       159238
       +
              sha256 = "1h3mmabxb0c29cy349xkk87df4x0dxakfaryyr8r43wj2l39yhj0";

     

       159239
        
              libraryHaskellDepends = [

     

       159240
        
                base bytestring containers data-default stm text

     

       159241
        
              ];

     
···

       159247
        
           ({ mkDerivation, base, incipit-base, polysemy }:

     

       159248
        
            mkDerivation {

     

       159249
        
              pname = "incipit-core";

     

       159250
       +
              version = "0.5.0.0";

     

       159251
       +
              sha256 = "17fbdp2v22fni36ijfm9hb9hkcarg4jy3xksngnhlzxqz77adcyj";

     

       159252
        
              libraryHaskellDepends = [ base incipit-base polysemy ];

     

       159253
        
              description = "A Prelude for Polysemy";

     

       159254
        
              license = "BSD-2-Clause-Patent";

     
···

       165318
        
              ];

     

       165319
        
              description = "OpenAPI Definitions for Jordan, Automatically";

     

       165320
        
              license = lib.licenses.mit;

     

       165321
       +
              hydraPlatforms = lib.platforms.none;

     

       165322
        
            }) {};

     

       165323
        
       

     

       165324
        
         "jordan-servant" = callPackage

     
···

       165388
        
              ];

     

       165389
        
              description = "OpenAPI schemas for Jordan-Powered Servant APIs";

     

       165390
        
              license = lib.licenses.mit;

     

       165391
       +
              hydraPlatforms = lib.platforms.none;

     

       165392
        
            }) {};

     

       165393
        
       

     

       165394
        
         "jordan-servant-server" = callPackage

     
···

       183493
        
            }:

     

       183494
        
            mkDerivation {

     

       183495
        
              pname = "lzma-static";

     

       183496
       +
              version = "5.2.5.5";

     

       183497
       +
              sha256 = "1qq0lzyfpnjdl9mh8qrr5lhhby8gxzgi1a8wiwpf3vkrziz5hh23";

     

       0
        
       
     

       0
        
       
     

       183498
        
              libraryHaskellDepends = [ base bytestring ];

     

       183499
        
              testHaskellDepends = [

     

       183500
        
                base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck

     
···

       185811
        
         "massiv" = callPackage

     

       185812
        
           ({ mkDerivation, base, bytestring, deepseq, doctest, exceptions

     

       185813
        
            , primitive, random, scheduler, unliftio-core, vector

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       185814
        
            , vector-stream

     

       185815
        
            }:

     

       185816
        
            mkDerivation {

     
···

       185824
        
              testHaskellDepends = [ base doctest ];

     

       185825
        
              description = "Massiv (Массив) is an Array Library";

     

       185826
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       185827
        
            }) {};

     

       185828
        
       

     

       185829
        
         "massiv-io" = callPackage

     
···

       189202
        
           ({ mkDerivation, base, microlens }:

     

       189203
        
            mkDerivation {

     

       189204
        
              pname = "microlens-contra";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       189205
        
              version = "0.1.0.3";

     

       189206
        
              sha256 = "1jxm6shmvacbic6i6hask0kv89kramnk77pcxpv4gv4xydjsr88n";

     

       189207
        
              libraryHaskellDepends = [ base microlens ];

     

       189208
        
              description = "True folds and getters for microlens";

     

       189209
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       189210
        
            }) {};

     

       189211
        
       

     

       189212
        
         "microlens-each" = callPackage

     
···

       189259
        
            }:

     

       189260
        
            mkDerivation {

     

       189261
        
              pname = "microlens-mtl";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       189262
        
              version = "0.2.0.3";

     

       189263
        
              sha256 = "1ilz0zyyk9f6h97gjsaqq65njfs23fk3wxhigvj4z0brf7rnlssd";

     

       189264
        
              libraryHaskellDepends = [

     
···

       189266
        
              ];

     

       189267
        
              description = "microlens support for Reader/Writer/State from mtl";

     

       189268
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       189269
        
            }) {};

     

       189270
        
       

     

       189271
        
         "microlens-platform" = callPackage

     
···

       189324
        
            }:

     

       189325
        
            mkDerivation {

     

       189326
        
              pname = "microlens-th";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       189327
        
              version = "0.4.3.11";

     

       189328
        
              sha256 = "1vjjaclfxr0kvlpmj8zh7f6ci4n4b8vynqd67zszx42al7gal6pj";

     

       189329
        
              libraryHaskellDepends = [

     
···

       189333
        
              testHaskellDepends = [ base microlens tagged ];

     

       189334
        
              description = "Automatic generation of record lenses for microlens";

     

       189335
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       189336
        
            }) {};

     

       189337
        
       

     

       189338
        
         "micrologger" = callPackage

     
···

       193948
        
            }:

     

       193949
        
            mkDerivation {

     

       193950
        
              pname = "monoid-extras";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       193951
        
              version = "0.6.2";

     

       193952
        
              sha256 = "1qaxp0cf2cvzvfpk7x9mjz1zmlpjfzxij8v2n45w89s7bq9ckvlw";

     

       193953
        
              libraryHaskellDepends = [ base groups semigroupoids ];

     

       193954
        
              benchmarkHaskellDepends = [ base criterion semigroups ];

     

       193955
        
              description = "Various extra monoid-related definitions and utilities";

     

       193956
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       193957
        
            }) {};

     

       193958
        
       

     

       193959
        
         "monoid-map" = callPackage

     
···

       194184
        
            }:

     

       194185
        
            mkDerivation {

     

       194186
        
              pname = "monomer-hagrid";

     

       194187
       +
              version = "0.2.0.1";

     

       194188
       +
              sha256 = "0vic013zr80wlm1gf33y8vlkpmrv6z52975dpa3ciypayd36hy2m";

     

       194189
        
              isLibrary = true;

     

       194190
        
              isExecutable = true;

     

       194191
        
              libraryHaskellDepends = [

     
···

       196954
        
              hydraPlatforms = lib.platforms.none;

     

       196955
        
            }) {};

     

       196956
        
       

     

       196957
       +
         "multicurryable" = callPackage

     

       196958
       +
           ({ mkDerivation, base, sop-core }:

     

       196959
       +
            mkDerivation {

     

       196960
       +
              pname = "multicurryable";

     

       196961
       +
              version = "0.1.0.0";

     

       196962
       +
              sha256 = "0p0wlz44scvkxzdhd059ivrhz4bsgbml26a8fm7jsav80cwbdfc4";

     

       196963
       +
              libraryHaskellDepends = [ base sop-core ];

     

       196964
       +
              testHaskellDepends = [ base sop-core ];

     

       196965
       +
              description = "Uncurry functions with multiple arguments";

     

       196966
       +
              license = lib.licenses.bsd3;

     

       196967
       +
            }) {};

     

       196968
       +
       

     

       196969
        
         "multifile" = callPackage

     

       196970
        
           ({ mkDerivation, base, directory, HaXml, optparse-applicative

     

       196971
        
            , pretty, process, transformers

     
···

       199229
        
            }) {};

     

       199230
        
       

     

       199231
        
         "named-text" = callPackage

     

       199232
       +
           ({ mkDerivation, aeson, base, bytestring, deepseq, hashable, hspec

     

       199233
       +
            , parameterized-utils, prettyprinter, sayable, tasty, tasty-ant-xml

     

       199234
       +
            , tasty-checklist, tasty-hspec, text, unordered-containers

     

       199235
        
            }:

     

       199236
        
            mkDerivation {

     

       199237
        
              pname = "named-text";

     

       199238
       +
              version = "1.1.1.0";

     

       199239
       +
              sha256 = "1g3xb3pr6sxn3sk9h2jbqlj30vh4nxcc14d06dawmqfva8b1gfp5";

     

       199240
        
              libraryHaskellDepends = [

     

       199241
       +
                aeson base deepseq hashable prettyprinter sayable text

     

       199242
       +
              ];

     

       199243
       +
              testHaskellDepends = [

     

       199244
       +
                aeson base bytestring hspec parameterized-utils prettyprinter

     

       199245
       +
                sayable tasty tasty-ant-xml tasty-checklist tasty-hspec text

     

       199246
       +
                unordered-containers

     

       199247
        
              ];

     

       199248
        
              description = "A parameterized named text type and associated functionality";

     

       199249
        
              license = lib.licenses.isc;

     

       199250
       +
              hydraPlatforms = lib.platforms.none;

     

       199251
        
            }) {};

     

       199252
        
       

     

       199253
        
         "namelist" = callPackage

     
···

       202083
        
            }:

     

       202084
        
            mkDerivation {

     

       202085
        
              pname = "network-uri";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       202086
        
              version = "2.6.4.2";

     

       202087
        
              sha256 = "0a3jg6aykwm1yw32nh137hi6r86w2640xwl1p18352bf29rqj64w";

     

       202088
        
              libraryHaskellDepends = [

     
···

       202094
        
              benchmarkHaskellDepends = [ base criterion deepseq HUnit ];

     

       202095
        
              description = "URI manipulation";

     

       202096
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       202097
        
            }) {};

     

       202098
        
       

     

       202099
        
         "network-uri-flag" = callPackage

     
···

       205760
        
            }:

     

       205761
        
            mkDerivation {

     

       205762
        
              pname = "nvim-hs";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       205763
        
              version = "2.3.2.0";

     

       205764
        
              sha256 = "1szvh65sbxk81321ml0b1iib5ziiks2l8liwkgs4z47pmb14cps9";

     

       205765
        
              libraryHaskellDepends = [

     
···

       205784
        
              testToolDepends = [ hspec-discover ];

     

       205785
        
              description = "Haskell plugin backend for neovim";

     

       205786
        
              license = lib.licenses.asl20;

     

       0
        
       
     

       205787
        
            }) {};

     

       205788
        
       

     

       205789
        
         "nvim-hs-contrib" = callPackage

     
···

       205810
        
            }) {};

     

       205811
        
       

     

       205812
        
         "nvim-hs-ghcid" = callPackage

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       205813
        
           ({ mkDerivation, base, bytestring, containers, directory, filepath

     

       205814
        
            , ghcid, nvim-hs, nvim-hs-contrib, resourcet, transformers

     

       205815
        
            , unliftio, yaml

     
···

       208091
        
           ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries

     

       208092
        
            , bytestring, Cabal, cabal-doctest, containers, cookie, doctest

     

       208093
        
            , generics-sop, Glob, hashable, hspec, hspec-discover, http-media

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       208094
        
            , HUnit, insert-ordered-containers, lens, mtl, optics-core

     

       208095
        
            , optics-th, QuickCheck, quickcheck-instances, scientific

     

       208096
        
            , template-haskell, text, time, transformers, unordered-containers

     
···

       208122
        
              license = lib.licenses.bsd3;

     

       208123
        
              hydraPlatforms = lib.platforms.none;

     

       208124
        
              mainProgram = "example";

     

       208125
       +
              broken = true;

     

       208126
        
            }) {};

     

       208127
        
       

     

       208128
        
         "openapi3-code-generator" = callPackage

     
···

       212150
        
            }) {};

     

       212151
        
       

     

       212152
        
         "pandoc-stylefrommeta" = callPackage

     

       212153
       +
           ({ mkDerivation, base, bytestring, containers, pandoc, pandoc-types

     

       212154
       +
            , text

     

       212155
        
            }:

     

       212156
        
            mkDerivation {

     

       212157
        
              pname = "pandoc-stylefrommeta";

     

       212158
       +
              version = "0.2.4.0";

     

       212159
       +
              sha256 = "0j25frcafcr0jvk3dfrmxan2q95920wy6jm0fahwf20f4jbanzfc";

     

       212160
        
              isLibrary = false;

     

       212161
        
              isExecutable = true;

     

       212162
        
              executableHaskellDepends = [

     

       212163
       +
                base bytestring containers pandoc pandoc-types text

     

       212164
        
              ];

     

       212165
        
              description = "Pandoc filter to customize links, images and paragraphs";

     

       212166
        
              license = lib.licenses.bsd3;

     
···

       214262
        
           ({ mkDerivation, base, hedgehog, partial-semigroup }:

     

       214263
        
            mkDerivation {

     

       214264
        
              pname = "partial-semigroup-hedgehog";

     

       214265
       +
              version = "0.6.0.13";

     

       214266
       +
              sha256 = "117k12wgaypj7lkj9lqi7xhli9f33hsd455p87g9xxcwx32m0r53";

     

       0
        
       
     

       0
        
       
     

       214267
        
              libraryHaskellDepends = [ base hedgehog partial-semigroup ];

     

       214268
        
              description = "Property testing for partial semigroups using Hedgehog";

     

       214269
        
              license = lib.licenses.asl20;

     
···

       222848
        
              license = lib.licenses.bsd3;

     

       222849
        
            }) {};

     

       222850
        
       

     

       222851
       +
         "polysemy_1_9_0_0" = callPackage

     

       222852
        
           ({ mkDerivation, async, base, Cabal, cabal-doctest, containers

     

       222853
        
            , doctest, first-class-families, hspec, hspec-discover

     

       222854
        
            , inspection-testing, mtl, stm, syb, template-haskell

     
···

       222856
        
            }:

     

       222857
        
            mkDerivation {

     

       222858
        
              pname = "polysemy";

     

       222859
       +
              version = "1.9.0.0";

     

       222860
       +
              sha256 = "00qmsn0mr88y29my389ln6c5imcac73p7hisd102w4qlwikwj9ir";

     

       222861
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       222862
        
              libraryHaskellDepends = [

     

       222863
        
                async base containers first-class-families mtl stm syb

     
···

       222946
        
            }:

     

       222947
        
            mkDerivation {

     

       222948
        
              pname = "polysemy-conc";

     

       222949
       +
              version = "0.12.1.0";

     

       222950
       +
              sha256 = "0js5hl84nfmb2i5si67wrf9d0i69piaj44v3sbia6yncq85fj7vn";

     

       222951
        
              libraryHaskellDepends = [

     

       222952
        
                async base containers incipit-core polysemy polysemy-resume

     

       222953
        
                polysemy-time stm stm-chans torsor unagi-chan unix

     
···

       223015
        
            }:

     

       223016
        
            mkDerivation {

     

       223017
        
              pname = "polysemy-http";

     

       223018
       +
              version = "0.10.0.0";

     

       223019
       +
              sha256 = "1j0a0gmlr1cd6mwa8y4f6dq3zf4asmgj4v4cdriiw0k1cxi81l9c";

     

       223020
        
              libraryHaskellDepends = [

     

       223021
        
                aeson base case-insensitive exon http-client http-client-tls

     

       223022
        
                http-types polysemy polysemy-plugin prelate time

     
···

       223091
        
            }:

     

       223092
        
            mkDerivation {

     

       223093
        
              pname = "polysemy-log";

     

       223094
       +
              version = "0.9.0.0";

     

       223095
       +
              sha256 = "1sgmgbh7gkyhp7rmdx2rj6dibwhi6z2qzg4cbnjsx8asz6xa188h";

     

       223096
        
              libraryHaskellDepends = [

     

       223097
        
                ansi-terminal async base incipit-core polysemy polysemy-conc

     

       223098
        
                polysemy-time stm time

     
···

       223116
        
            }:

     

       223117
        
            mkDerivation {

     

       223118
        
              pname = "polysemy-log-co";

     

       223119
       +
              version = "0.9.0.0";

     

       223120
       +
              sha256 = "18z75dbbqf18ff3dc641svm93fvrdaxzplbaicdy7y3dz3y7apmv";

     

       223121
        
              libraryHaskellDepends = [

     

       223122
        
                base co-log co-log-concurrent co-log-polysemy incipit-core polysemy

     

       223123
        
                polysemy-conc polysemy-log polysemy-time stm

     
···

       223138
        
            }:

     

       223139
        
            mkDerivation {

     

       223140
        
              pname = "polysemy-log-di";

     

       223141
       +
              version = "0.9.0.0";

     

       223142
       +
              sha256 = "0zwcv6b0m5phwiy0c1z3wfnbw0976qg744dpb6k66wdr3yvpl05f";

     

       223143
        
              libraryHaskellDepends = [

     

       223144
        
                base di-polysemy incipit-core polysemy polysemy-conc polysemy-log

     

       223145
        
                polysemy-time stm

     
···

       223231
        
            }:

     

       223232
        
            mkDerivation {

     

       223233
        
              pname = "polysemy-mocks";

     

       223234
       +
              version = "0.3.1.0";

     

       223235
       +
              sha256 = "08dsx682fvx7ywiixxjaa5b05r3s97anl893nlfc3vy6qynaqkns";

     

       223236
        
              libraryHaskellDepends = [ base polysemy template-haskell ];

     

       223237
        
              testHaskellDepends = [ base hspec polysemy ];

     

       223238
        
              testToolDepends = [ hspec-discover ];

     
···

       223276
        
            }:

     

       223277
        
            mkDerivation {

     

       223278
        
              pname = "polysemy-plugin";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       223279
        
              version = "0.4.4.0";

     

       223280
        
              sha256 = "1kp7d4m007mlk4pl2p8933b5yzzb8gl30g1vfbbz01vm3pgjcj3d";

     

       223281
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       223290
        
              testToolDepends = [ hspec-discover ];

     

       223291
        
              description = "Disambiguate obvious uses of effects";

     

       223292
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       223293
        
            }) {};

     

       223294
        
       

     

       223295
        
         "polysemy-process" = callPackage

     
···

       223300
        
            }:

     

       223301
        
            mkDerivation {

     

       223302
        
              pname = "polysemy-process";

     

       223303
       +
              version = "0.12.1.0";

     

       223304
       +
              sha256 = "0009h21pwfkwfyb5qk6v9gw5gh2ksap3xbcbny2icn88dhqs42k6";

     

       223305
        
              libraryHaskellDepends = [

     

       223306
        
                base incipit-core path path-io polysemy polysemy-conc

     

       223307
        
                polysemy-resume polysemy-time posix-pty process stm-chans

     
···

       223364
        
            }:

     

       223365
        
            mkDerivation {

     

       223366
        
              pname = "polysemy-resume";

     

       223367
       +
              version = "0.7.0.0";

     

       223368
       +
              sha256 = "0f2hlccg7qpx9dd1k73ni59yl447m3v2s6r8h9n2k1klxc21jr07";

     

       223369
        
              libraryHaskellDepends = [

     

       223370
        
                base incipit-core polysemy transformers

     

       223371
        
              ];

     
···

       226581
        
            }:

     

       226582
        
            mkDerivation {

     

       226583
        
              pname = "prelate";

     

       226584
       +
              version = "0.4.0.0";

     

       226585
       +
              sha256 = "0bil1d1daw6a37zi0fddf3mja3ab12rcsldi879qcipbjc7bh4bz";

     

       226586
        
              libraryHaskellDepends = [

     

       226587
        
                aeson base exon extra generic-lens incipit microlens microlens-ghc

     

       226588
        
                polysemy-chronos polysemy-conc polysemy-log polysemy-process

     
···

       233430
        
              license = lib.licenses.bsd3;

     

       233431
        
            }) {};

     

       233432
        
       

     

       233433
       +
         "quickcheck-monoid-subclasses" = callPackage

     

       233434
       +
           ({ mkDerivation, base, bytestring, commutative-semigroups

     

       233435
       +
            , containers, hspec, hspec-discover, monoid-subclasses, pretty-show

     

       233436
       +
            , QuickCheck, quickcheck-classes, quickcheck-instances

     

       233437
       +
            , semigroupoids, text, vector

     

       233438
       +
            }:

     

       233439
       +
            mkDerivation {

     

       233440
       +
              pname = "quickcheck-monoid-subclasses";

     

       233441
       +
              version = "0.0.0.1";

     

       233442
       +
              sha256 = "1x1jza5s1v89ik0h5m3kla5qwgh05j5dbd7f2m2miwyy1b75bqly";

     

       233443
       +
              libraryHaskellDepends = [

     

       233444
       +
                base containers monoid-subclasses pretty-show QuickCheck

     

       233445
       +
                quickcheck-classes quickcheck-instances semigroupoids

     

       233446
       +
              ];

     

       233447
       +
              testHaskellDepends = [

     

       233448
       +
                base bytestring commutative-semigroups containers hspec

     

       233449
       +
                monoid-subclasses QuickCheck quickcheck-classes

     

       233450
       +
                quickcheck-instances text vector

     

       233451
       +
              ];

     

       233452
       +
              testToolDepends = [ hspec-discover ];

     

       233453
       +
              doHaddock = false;

     

       233454
       +
              description = "Testing monoid subclass instances with QuickCheck";

     

       233455
       +
              license = lib.licenses.asl20;

     

       233456
       +
              hydraPlatforms = lib.platforms.none;

     

       233457
       +
              broken = true;

     

       233458
       +
            }) {};

     

       233459
       +
       

     

       233460
        
         "quickcheck-poly" = callPackage

     

       233461
        
           ({ mkDerivation, base, haskell98, hint, MonadCatchIO-mtl

     

       233462
        
            , QuickCheck, regex-compat, regex-tdfa

     
···

       237731
        
            }:

     

       237732
        
            mkDerivation {

     

       237733
        
              pname = "recursion-schemes";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       237734
        
              version = "5.2.2.3";

     

       237735
        
              sha256 = "04233y5qw7vm0kyh4h44zpfk2zsd6kz9081ngvi098y0xiphrwm9";

     

       237736
        
              libraryHaskellDepends = [

     
···

       237740
        
              testHaskellDepends = [ base HUnit template-haskell transformers ];

     

       237741
        
              description = "Representing common recursion patterns as higher-order functions";

     

       237742
        
              license = lib.licenses.bsd2;

     

       0
        
       
     

       237743
        
            }) {};

     

       237744
        
       

     

       237745
        
         "recursion-schemes-ext" = callPackage

     
···

       241632
        
              ];

     

       241633
        
              description = "Perform fft with repa via FFTW";

     

       241634
        
              license = lib.licenses.bsd3;

     

       241635
       +
              hydraPlatforms = lib.platforms.none;

     

       241636
        
            }) {};

     

       241637
        
       

     

       241638
        
         "repa-flow" = callPackage

     
···

       244418
        
              ];

     

       244419
        
              description = "A library for process pools coupled with asynchronous message queues";

     

       244420
        
              license = lib.licenses.bsd2;

     

       244421
       +
              hydraPlatforms = lib.platforms.none;

     

       244422
        
              mainProgram = "rio-process-pool-memleak-test";

     

       244423
        
            }) {};

     

       244424
        
       

     
···

       244981
        
                vector-sized

     

       244982
        
              ];

     

       244983
        
              description = "Implementation of the ROC National ID standard";

     

       244984
       +
              license = lib.licenses.bsd3;

     

       244985
       +
              hydraPlatforms = lib.platforms.none;

     

       244986
       +
              broken = true;

     

       244987
       +
            }) {};

     

       244988
       +
       

     

       244989
       +
         "roc-id_0_2_0_0" = callPackage

     

       244990
       +
           ({ mkDerivation, base, hspec, MonadRandom, Only, QuickCheck, text

     

       244991
       +
            , vector-sized

     

       244992
       +
            }:

     

       244993
       +
            mkDerivation {

     

       244994
       +
              pname = "roc-id";

     

       244995
       +
              version = "0.2.0.0";

     

       244996
       +
              sha256 = "1gng9rw9z9zmrkk68q8zf95w3d05yaglk2hp17jvnaw8qxfs3mvp";

     

       244997
       +
              libraryHaskellDepends = [

     

       244998
       +
                base MonadRandom Only text vector-sized

     

       244999
       +
              ];

     

       245000
       +
              testHaskellDepends = [

     

       245001
       +
                base hspec MonadRandom Only QuickCheck text vector-sized

     

       245002
       +
              ];

     

       245003
       +
              description = "Implementation of the ROC (Taiwan) National ID standard";

     

       245004
        
              license = lib.licenses.bsd3;

     

       245005
        
              hydraPlatforms = lib.platforms.none;

     

       245006
        
              broken = true;

     
···

       254444
        
            }:

     

       254445
        
            mkDerivation {

     

       254446
        
              pname = "servant-openapi3";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       254447
        
              version = "2.0.1.6";

     

       254448
        
              sha256 = "1hxz3n6l5l8p9s58sjilrn4lv1z17kfik0xdh05v5v1bzf0j2aij";

     

       254449
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       255521
        
              testToolDepends = [ hspec-discover ];

     

       255522
        
              description = "Servant servers utilities";

     

       255523
        
              license = lib.licenses.mpl20;

     

       255524
       +
              hydraPlatforms = lib.platforms.none;

     

       255525
        
              mainProgram = "servant-util-examples";

     

       255526
        
            }) {};

     

       255527
        
       

     
···

       255553
        
              testToolDepends = [ hspec-discover ];

     

       255554
        
              description = "Implementation of servant-util primitives for beam-postgres";

     

       255555
        
              license = lib.licenses.mpl20;

     

       255556
       +
              hydraPlatforms = lib.platforms.none;

     

       255557
        
              mainProgram = "servant-util-beam-pg-examples";

     

       255558
        
            }) {};

     

       255559
        
       

     
···

       261195
        
         "skylighting" = callPackage

     

       261196
        
           ({ mkDerivation, base, binary, blaze-html, bytestring, containers

     

       261197
        
            , pretty-show, skylighting-core, skylighting-format-ansi

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       261198
        
            , skylighting-format-blaze-html, skylighting-format-context

     

       261199
        
            , skylighting-format-latex, text

     

       261200
        
            }:

     
···

       261215
        
              ];

     

       261216
        
              description = "syntax highlighting library";

     

       261217
        
              license = lib.licenses.gpl2Only;

     

       0
        
       
     

       261218
        
              mainProgram = "skylighting";

     

       261219
        
            }) {};

     

       261220
        
       

     
···

       261227
        
            }:

     

       261228
        
            mkDerivation {

     

       261229
        
              pname = "skylighting-core";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       261230
        
              version = "0.13.2";

     

       261231
        
              sha256 = "0iwzfgynj3l8rnvvrl4kg0i1n31rz15da8cf1943gw1vcfh6w585";

     

       261232
        
              isLibrary = true;

     
···

       261246
        
              ];

     

       261247
        
              description = "syntax highlighting library";

     

       261248
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       261249
        
            }) {};

     

       261250
        
       

     

       261251
        
         "skylighting-extensions" = callPackage

     
···

       264418
        
              ];

     

       264419
        
              description = "A checksummed variation on Twitter's Snowflake UID generation algorithm";

     

       264420
        
              license = lib.licenses.asl20;

     

       264421
       +
              hydraPlatforms = lib.platforms.none;

     

       264422
       +
              broken = true;

     

       264423
        
            }) {};

     

       264424
        
       

     

       264425
        
         "snowflake" = callPackage

     
···

       265037
        
           ({ mkDerivation, base, deepseq }:

     

       265038
        
            mkDerivation {

     

       265039
        
              pname = "some";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       265040
        
              version = "1.0.4.1";

     

       265041
        
              sha256 = "1qy840b2f58f0jxmw4q9sfgbx64kypzdlqnwc72md5wwv84b9b1d";

     

       265042
        
              libraryHaskellDepends = [ base deepseq ];

     

       265043
        
              testHaskellDepends = [ base ];

     

       265044
        
              description = "Existential type: Some";

     

       265045
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       265046
        
            }) {};

     

       265047
        
       

     

       265048
        
         "some-dict-of" = callPackage

     
···

       270176
        
              testHaskellDepends = [ base hspec mtl stm stm-queue ];

     

       270177
        
              description = "A simplistic actor model based on STM";

     

       270178
        
              license = lib.licenses.mit;

     

       270179
       +
              hydraPlatforms = lib.platforms.none;

     

       270180
        
            }) {};

     

       270181
        
       

     

       270182
        
         "stm-channelize" = callPackage

     
···

       270416
        
              ];

     

       270417
        
              description = "An implementation of a real-time concurrent queue";

     

       270418
        
              license = lib.licenses.mit;

     

       270419
       +
              hydraPlatforms = lib.platforms.none;

     

       270420
       +
              broken = true;

     

       270421
        
            }) {};

     

       270422
        
       

     

       270423
        
         "stm-queue-extras" = callPackage

     
···

       270843
        
              pname = "store-core";

     

       270844
        
              version = "0.4.4.4";

     

       270845
        
              sha256 = "0h21wp51phbwk9ajblqaqzx1hk9c58gkihmycjn0hj299kxly80y";

     

       270846
       +
              revision = "1";

     

       270847
       +
              editedCabalFile = "04jv0y5k9iscw8ac72rbycmcscadnjsv2rjgwj6x0r2bymvdq00g";

     

       270848
        
              libraryHaskellDepends = [

     

       270849
        
                base bytestring ghc-prim primitive text transformers

     

       270850
        
              ];

     
···

       272484
        
            }:

     

       272485
        
            mkDerivation {

     

       272486
        
              pname = "string-interpolate";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       272487
        
              version = "0.3.2.0";

     

       272488
        
              sha256 = "1sdd472rvykrqkv76745vavpycvb0dzcaxs3yw9dfczaxaz16xws";

     

       272489
        
              libraryHaskellDepends = [

     
···

       272501
        
              ];

     

       272502
        
              description = "Haskell string/text/bytestring interpolation that just works";

     

       272503
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       272504
        
            }) {};

     

       272505
        
       

     

       272506
        
         "string-interpreter" = callPackage

     
···

       278800
        
            }) {};

     

       278801
        
       

     

       278802
        
         "tasty" = callPackage

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       278803
        
           ({ mkDerivation, ansi-terminal, base, containers

     

       278804
        
            , optparse-applicative, stm, tagged, transformers, unix

     

       278805
        
            }:

     
···

       278813
        
              ];

     

       278814
        
              description = "Modern and extensible testing framework";

     

       278815
        
              license = lib.licenses.mit;

     

       0
        
       
     

       278816
        
            }) {};

     

       278817
        
       

     

       278818
        
         "tasty-ant-xml" = callPackage

     
···

       280411
        
            }:

     

       280412
        
            mkDerivation {

     

       280413
        
              pname = "telegram-bot-simple";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       280414
        
              version = "0.6.1";

     

       280415
        
              sha256 = "01rxkgzfvqxgnxlcw70rhs84ygvccydlki827f3icqwfpm7cn6vn";

     

       280416
        
              isLibrary = true;

     
···

       280425
        
              ];

     

       280426
        
              description = "Easy to use library for building Telegram bots";

     

       280427
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       280428
        
            }) {};

     

       280429
        
       

     

       280430
        
         "telegram-raw-api" = callPackage

     
···

       282663
        
            }:

     

       282664
        
            mkDerivation {

     

       282665
        
              pname = "text-builder-dev";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       282666
        
              version = "0.3.3.2";

     

       282667
        
              sha256 = "1bsm4yl22mpzggcnh908ccw9mvg3prckydwxxqa4rfj4k8hy4x7m";

     

       282668
        
              libraryHaskellDepends = [

     
···

       282676
        
              benchmarkHaskellDepends = [ criterion rerebase ];

     

       282677
        
              description = "Edge of developments for \"text-builder\"";

     

       282678
        
              license = lib.licenses.mit;

     

       0
        
       
     

       282679
        
            }) {};

     

       282680
        
       

     

       282681
        
         "text-builder-linear" = callPackage

     
···

       283334
        
            }) {};

     

       283335
        
       

     

       283336
        
         "text-show-instances" = callPackage

     

       283337
       +
           ({ mkDerivation, aeson, base, base-compat, bifunctors, binary

     

       283338
        
            , containers, directory, generic-deriving, ghc-boot-th, ghc-prim

     

       283339
        
            , haskeline, hpc, hspec, hspec-discover, old-locale, old-time

     

       283340
        
            , pretty, QuickCheck, quickcheck-instances, random, scientific

     
···

       283344
        
            }:

     

       283345
        
            mkDerivation {

     

       283346
        
              pname = "text-show-instances";

     

       283347
       +
              version = "3.9.3";

     

       283348
       +
              sha256 = "153hfl8k0489ll71apq48s59ngv8ag1vyhhs6pp3fgxmdwwg2xpl";

     

       283349
        
              libraryHaskellDepends = [

     

       283350
       +
                aeson base base-compat bifunctors binary containers directory

     

       283351
        
                ghc-boot-th haskeline hpc old-locale old-time pretty random

     

       283352
        
                scientific semigroups tagged template-haskell terminfo text

     

       283353
       +
                text-short text-show time transformers unix unordered-containers

     

       283354
       +
                uuid-types vector xhtml

     

       283355
        
              ];

     

       283356
        
              testHaskellDepends = [

     

       283357
       +
                aeson base base-compat bifunctors binary containers directory

     

       283358
        
                generic-deriving ghc-boot-th ghc-prim haskeline hpc hspec

     

       283359
        
                old-locale old-time pretty QuickCheck quickcheck-instances random

     

       283360
        
                scientific tagged template-haskell terminfo text-short text-show

     
···

       283366
        
              license = lib.licenses.bsd3;

     

       283367
        
            }) {};

     

       283368
        
       

     

       283369
       +
         "text-show-instances_3_9_4" = callPackage

     

       283370
        
           ({ mkDerivation, aeson, base, base-compat, bifunctors, binary

     

       283371
        
            , containers, directory, generic-deriving, ghc-boot-th, ghc-prim

     

       283372
        
            , haskeline, hpc, hspec, hspec-discover, old-locale, old-time

     
···

       283377
        
            }:

     

       283378
        
            mkDerivation {

     

       283379
        
              pname = "text-show-instances";

     

       283380
       +
              version = "3.9.4";

     

       283381
       +
              sha256 = "154smhpc3l2h1iacdsywzirkv19w493yajhsiqg9pqmmiii7kwr5";

     

       283382
        
              libraryHaskellDepends = [

     

       283383
        
                aeson base base-compat bifunctors binary containers directory

     

       283384
        
                ghc-boot-th haskeline hpc old-locale old-time pretty random

     
···

       290632
        
              testHaskellDepends = [ base containers template-haskell time ];

     

       290633
        
              description = "Template Haskell hack to violate module abstractions";

     

       290634
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       290635
        
            }) {};

     

       290636
        
       

     

       290637
        
         "truelevel" = callPackage

     
···

       296628
        
              ];

     

       296629
        
              description = "Fast and robust message queues for concurrent processes";

     

       296630
        
              license = lib.licenses.bsd2;

     

       296631
       +
              hydraPlatforms = lib.platforms.none;

     

       296632
        
              mainProgram = "unliftio-messagebox-memleak-test";

     

       296633
       +
              broken = true;

     

       296634
        
            }) {};

     

       296635
        
       

     

       296636
        
         "unliftio-path" = callPackage

     
···

       299350
        
           ({ mkDerivation, base, stm }:

     

       299351
        
            mkDerivation {

     

       299352
        
              pname = "var-monad";

     

       299353
       +
              version = "0.2.0.1";

     

       299354
       +
              sha256 = "1k1v503ww56chlxy9a9vh3w5rh047l3q97si1bi3x1575b1sppm2";

     

       299355
        
              libraryHaskellDepends = [ base stm ];

     

       299356
        
              description = "The VarMonad typeclass, generalizing types of references";

     

       299357
        
              license = lib.licenses.asl20;

     
···

       300170
        
            }:

     

       300171
        
            mkDerivation {

     

       300172
        
              pname = "vector-extras";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       300173
        
              version = "0.2.8";

     

       300174
        
              sha256 = "1xnz733p9p66693hb31fmq2cfsy2rwyw1b0915p7y5my1d8dxyzi";

     

       300175
        
              libraryHaskellDepends = [

     
···

       300178
        
              ];

     

       300179
        
              description = "Utilities for the \"vector\" library";

     

       300180
        
              license = lib.licenses.mit;

     

       0
        
       
     

       300181
        
            }) {};

     

       300182
        
       

     

       300183
        
         "vector-fft" = callPackage

     
···

       300367
        
              pname = "vector-sized";

     

       300368
        
              version = "1.5.0";

     

       300369
        
              sha256 = "13h4qck1697iswd9f8w17fpjc6yhl2pgrvay7pb22j2h3mgaxpjl";

     

       300370
       +
              revision = "1";

     

       300371
       +
              editedCabalFile = "0y088b8fdhjrghi203n11ip4x2j4632c8rz6a5hx8azmdz2giiph";

     

       300372
        
              libraryHaskellDepends = [

     

       300373
        
                adjunctions base binary comonad deepseq distributive

     

       300374
        
                finite-typelits hashable indexed-list-literals primitive vector

     
···

       301942
        
              pname = "vty";

     

       301943
        
              version = "5.35.1";

     

       301944
        
              sha256 = "062dpz8fxrnggzpl041zpbph0xj56jki98ajm2s78dldg5vy0c9k";

     

       301945
       +
              revision = "1";

     

       301946
       +
              editedCabalFile = "1zqcvgqhcij92241g20zn3c3a4033biid3f3cqg05q1ygrmznxb5";

     

       301947
        
              isLibrary = true;

     

       301948
        
              isExecutable = true;

     

       301949
        
              libraryHaskellDepends = [

     
···

       305834
        
              ];

     

       305835
        
              description = "Composable, type-safe library to build HTTP API servers";

     

       305836
        
              license = lib.licenses.mpl20;

     

       305837
       +
              hydraPlatforms = lib.platforms.none;

     

       305838
        
            }) {};

     

       305839
        
       

     

       305840
        
         "webgear-server" = callPackage

     
···

       306825
        
            }:

     

       306826
        
            mkDerivation {

     

       306827
        
              pname = "wide-word";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       306828
        
              version = "0.1.4.0";

     

       306829
        
              sha256 = "1jajlkcbymf0jqmcbn46x3yxqxjslzdcnp1v582jjpa2glibsnf0";

     

       306830
        
              libraryHaskellDepends = [

     
···

       306836
        
              ];

     

       306837
        
              description = "Data types for large but fixed width signed and unsigned integers";

     

       306838
        
              license = lib.licenses.bsd2;

     

       0
        
       
     

       306839
        
            }) {};

     

       306840
        
       

     

       306841
        
         "wide-word-instances" = callPackage

-129

pkgs/development/haskell-modules/patches/hevm-update-deps.patch

···

       1
       -
       diff --git a/hevm.cabal b/hevm.cabal

     

       2
       -
       index cf36961e..3b31f595 100644

     

       3
       -
       --- a/hevm.cabal

     

       4
       -
       +++ b/hevm.cabal

     

       5
       -
       @@ -71,6 +71,10 @@ library

     

       6
       -
            -Wall -Wno-deprecations

     

       7
       -
          extra-libraries:

     

       8
       -
            secp256k1, ff

     

       9
       -
       +  if os(darwin)

     

       10
       -
       +     extra-libraries: c++

     

       11
       -
       +  else

     

       12
       -
       +     extra-libraries: stdc++

     

       13
       -
          c-sources:

     

       14
       -
            ethjet/tinykeccak.c, ethjet/ethjet.c

     

       15
       -
          cxx-sources:

     

       16
       -
       @@ -88,7 +92,7 @@ library

     

       17
       -
            transformers                      >= 0.5.6 && < 0.6,

     

       18
       -
            tree-view                         >= 0.5 && < 0.6,

     

       19
       -
            abstract-par                      >= 0.3.3 && < 0.4,

     

       20
       -
       -    aeson                             >= 1.5.6 && < 1.6,

     

       21
       -
       +    aeson                             >= 2.0 && < 2.1,

     

       22
       -
            bytestring                        >= 0.10.8 && < 0.11,

     

       23
       -
            scientific                        >= 0.3.6 && < 0.4,

     

       24
       -
            binary                            >= 0.8.6 && < 0.9,

     

       25
       -
       @@ -97,7 +101,7 @@ library

     

       26
       -
            vector                            >= 0.12.1 && < 0.13,

     

       27
       -
            ansi-wl-pprint                    >= 0.6.9 && < 0.7,

     

       28
       -
            base16-bytestring                 >= 1.0.0 && < 2.0,

     

       29
       -
       -    brick                             >= 0.58 && < 0.63,

     

       30
       -
       +    brick                             >= 0.58 && < 0.69,

     

       31
       -
            megaparsec                        >= 9.0.0 && < 10.0,

     

       32
       -
            mtl                               >= 2.2.2 && < 2.3,

     

       33
       -
            directory                         >= 1.3.3 && < 1.4,

     

       34
       -
       @@ -105,13 +109,13 @@ library

     

       35
       -
            vty                               >= 5.25.1 && < 5.34,

     

       36
       -
            cereal                            >= 0.5.8 && < 0.6,

     

       37
       -
            cryptonite                        >= 0.27 && <= 0.29,

     

       38
       -
       -    memory                            >= 0.14.18 && < 0.16,

     

       39
       -
       +    memory                            >= 0.14.18 && < 0.20,

     

       40
       -
            data-dword                        >= 0.3.1 && < 0.4,

     

       41
       -
            fgl                               >= 5.7.0 && < 5.8,

     

       42
       -
            free                              >= 5.1.3 && < 5.2,

     

       43
       -
            haskeline                         >= 0.8.0 && < 0.9,

     

       44
       -
            process                           >= 1.6.5 && < 1.7,

     

       45
       -
       -    lens                              >= 4.17.1 && < 4.20,

     

       46
       -
       +    lens                              >= 4.17.1 && < 5.1,

     

       47
       -
            lens-aeson                        >= 1.0.2 && < 1.2,

     

       48
       -
            monad-par                         >= 0.3.5 && < 0.4,

     

       49
       -
            multiset                          >= 0.3.4 && < 0.4,

     

       50
       -
       @@ -124,7 +128,6 @@ library

     

       51
       -
            sbv                               >= 8.9,

     

       52
       -
            semver-range                      >= 0.2.7 && < 0.3,

     

       53
       -
            temporary                         >= 1.3 && < 1.4,

     

       54
       -
       -    text-format                       >= 0.3.2 && < 0.4,

     

       55
       -
            witherable                        >= 0.3.5 && < 0.5,

     

       56
       -
            wreq                              >= 0.5.3 && < 0.6,

     

       57
       -
            regex-tdfa                        >= 1.2.3 && < 1.4,

     

       58
       -
       @@ -190,7 +193,6 @@ executable hevm

     

       59
       -
            sbv,

     

       60
       -
            temporary,

     

       61
       -
            text,

     

       62
       -
       -    text-format,

     

       63
       -
            unordered-containers,

     

       64
       -
            vector,

     

       65
       -
            vty

     

       66
       -
       diff --git a/src/EVM/Solidity.hs b/src/EVM/Solidity.hs

     

       67
       -
       index b7d0f36b..4e9d6892 100644

     

       68
       -
       --- a/src/EVM/Solidity.hs

     

       69
       -
       +++ b/src/EVM/Solidity.hs

     

       70
       -
       @@ -70,6 +70,7 @@ import Control.Monad

     

       71
       -
        import Control.Lens         hiding (Indexed, (.=))

     

       72
       -
        import qualified Data.String.Here as Here

     

       73
       -
        import Data.Aeson hiding (json)

     

       74
       -
       +import qualified Data.Aeson.KeyMap as KeyMap

     

       75
       -
        import Data.Aeson.Types

     

       76
       -
        import Data.Aeson.Lens

     

       77
       -
        import Data.Scientific

     

       78
       -
       @@ -714,8 +715,8 @@ astIdMap = foldMap f

     

       79
       -
            f :: Value -> Map Int Value

     

       80
       -
            f (Array x) = foldMap f x

     

       81
       -
            f v@(Object x) =

     

       82
       -
       -      let t = foldMap f (HMap.elems x)

     

       83
       -
       -      in case HMap.lookup "id" x of

     

       84
       -
       +      let t = foldMap f (KeyMap.elems x)

     

       85
       -
       +      in case KeyMap.lookup "id" x of

     

       86
       -
                Nothing         -> t

     

       87
       -
                Just (Number i) -> t <> Map.singleton (round i) v

     

       88
       -
                Just _          -> t

     

       89
       -
       diff --git a/src/EVM/SymExec.hs b/src/EVM/SymExec.hs

     

       90
       -
       index 5bbf1c03..b828098e 100644

     

       91
       -
       --- a/src/EVM/SymExec.hs

     

       92
       -
       +++ b/src/EVM/SymExec.hs

     

       93
       -
       @@ -40,8 +40,8 @@ type EquivalenceResult = ProofResult ([VM], [VM]) VM ()

     

       94
       -
       

     

       95
       -
        -- | Convenience functions for generating large symbolic byte strings

     

       96
       -
        sbytes32, sbytes128, sbytes256, sbytes512, sbytes1024 :: Query ([SWord 8])

     

       97
       -
       -sbytes32 = toBytes <$> freshVar_ @ (WordN 256)

     

       98
       -
       -sbytes128 = toBytes <$> freshVar_ @ (WordN 1024)

     

       99
       -
       +sbytes32 = toBytes <$> freshVar_ @(WordN 256)

     

       100
       -
       +sbytes128 = toBytes <$> freshVar_ @(WordN 1024)

     

       101
       -
        sbytes256 = liftA2 (++) sbytes128 sbytes128

     

       102
       -
        sbytes512 = liftA2 (++) sbytes256 sbytes256

     

       103
       -
        sbytes1024 = liftA2 (++) sbytes512 sbytes512

     

       104
       -
       diff --git a/src/EVM/Types.hs b/src/EVM/Types.hs

     

       105
       -
       index fdd2368d..1dc29e83 100644

     

       106
       -
       --- a/src/EVM/Types.hs

     

       107
       -
       +++ b/src/EVM/Types.hs

     

       108
       -
       @@ -434,17 +434,17 @@ readN s = fromIntegral (read s :: Integer)

     

       109
       -
        readNull :: Read a => a -> String -> a

     

       110
       -
        readNull x = fromMaybe x . Text.Read.readMaybe

     

       111
       -
       

     

       112
       -
       -wordField :: JSON.Object -> Text -> JSON.Parser W256

     

       113
       -
       +wordField :: JSON.Object -> Key -> JSON.Parser W256

     

       114
       -
        wordField x f = ((readNull 0) . Text.unpack)

     

       115
       -
                          <$> (x .: f)

     

       116
       -
       

     

       117
       -
       -addrField :: JSON.Object -> Text -> JSON.Parser Addr

     

       118
       -
       +addrField :: JSON.Object -> Key -> JSON.Parser Addr

     

       119
       -
        addrField x f = (read . Text.unpack) <$> (x .: f)

     

       120
       -
       

     

       121
       -
       -addrFieldMaybe :: JSON.Object -> Text -> JSON.Parser (Maybe Addr)

     

       122
       -
       +addrFieldMaybe :: JSON.Object -> Key -> JSON.Parser (Maybe Addr)

     

       123
       -
        addrFieldMaybe x f = (Text.Read.readMaybe . Text.unpack) <$> (x .: f)

     

       124
       -
       

     

       125
       -
       -dataField :: JSON.Object -> Text -> JSON.Parser ByteString

     

       126
       -
       +dataField :: JSON.Object -> Key -> JSON.Parser ByteString

     

       127
       -
        dataField x f = hexText <$> (x .: f)

     

       128
       -
       

     

       129
       -
        toWord512 :: W256 -> Word512

-24

pkgs/development/haskell-modules/patches/recursion-schemes-128.patch

···

       1
       -
       diff --git a/recursion-schemes.cabal b/recursion-schemes.cabal

     

       2
       -
       index c35f2c6..e692ade 100644

     

       3
       -
       --- a/recursion-schemes.cabal

     

       4
       -
       +++ b/recursion-schemes.cabal

     

       5
       -
       @@ -93,6 +93,7 @@ library

     

       6
       -
              Paths_recursion_schemes

     

       7
       -
        

     

       8
       -
          ghc-options: -Wall

     

       9
       -
       +  ghc-prof-options: -DPROFILING_ENABLED

     

       10
       -
          if impl(ghc >= 8.6)

     

       11
       -
            ghc-options: -Wno-star-is-type

     

       12
       -
          default-language: Haskell2010

     

       13
       -
       diff --git a/src/Data/Functor/Foldable/TH.hs b/src/Data/Functor/Foldable/TH.hs

     

       14
       -
       index b3d5ac8..d4ef0e4 100644

     

       15
       -
       --- a/src/Data/Functor/Foldable/TH.hs

     

       16
       -
       +++ b/src/Data/Functor/Foldable/TH.hs

     

       17
       -
       @@ -1,4 +1,7 @@

     

       18
       -
        {-# LANGUAGE CPP, PatternGuards, Rank2Types #-}

     

       19
       -
       +#if defined(PROFILING_ENABLED)

     

       20
       -
       +{-# OPTIONS_GHC -O0 #-}

     

       21
       -
       +#endif

     

       22
       -
        module Data.Functor.Foldable.TH

     

       23
       -
          ( MakeBaseFunctor(..)

     

       24
       -
          , BaseRules

+2 -16

pkgs/development/libraries/libbluray/default.nix

···

       11
        
       

     

       12
        
       stdenv.mkDerivation rec {

     

       13
        
         pname = "libbluray";

     

       14
       -
         version = "1.3.2";

     

       15
        
       

     

       16
        
         src = fetchurl {

     

       17
        
           url = "https://get.videolan.org/libbluray/${version}/${pname}-${version}.tar.bz2";

     

       18
       -
           sha256 = "sha256-RWgU258Hwe7N736ED8uyCXbvgU34dUKL+4Hs9FhR8XA=";

     

       19
        
         };

     

       20
       -
       

     

       21
       -
         patches = [

     

       22
       -
           ./BDJ-JARFILE-path.patch

     

       23
       -
           (fetchpatch {

     

       24
       -
             name = "Initial-support-for-Java-18.patch";

     

       25
       -
             url = "https://code.videolan.org/videolan/libbluray/-/commit/3187c3080096e107f0a27eed1843232b58342577.patch";

     

       26
       -
             hash = "sha256-2TSciAoPzELkgmFGB38h1RgynOCJueyCL8hIADxAPHo=";

     

       27
       -
           })

     

       28
       -
           (fetchpatch {

     

       29
       -
             name = "bd-j-BDJSecurityManager-Change-setSecurityManager-de.patch";

     

       30
       -
             url = "https://code.videolan.org/videolan/libbluray/-/commit/9a2d23d049760ef9cc9661ff90011a84d90368f1.patch";

     

       31
       -
             hash = "sha256-xCc2h5ocXCqnpVMPQaybT2Ncs2YOzifQ0mlCCUhYlc8=";

     

       32
       -
           })

     

       33
       -
         ];

     

       34
        
       

     

       35
        
         nativeBuildInputs = [ pkg-config autoreconfHook ]

     

       36
        
           ++ lib.optionals withJava [ ant ];

···

       11
        
       

     

       12
        
       stdenv.mkDerivation rec {

     

       13
        
         pname = "libbluray";

     

       14
       +
         version = "1.3.4";

     

       15
        
       

     

       16
        
         src = fetchurl {

     

       17
        
           url = "https://get.videolan.org/libbluray/${version}/${pname}-${version}.tar.bz2";

     

       18
       +
           hash = "sha256-R4/9aKD13ejvbKmJt/A1taCiLFmRQuXNP/ewO76+Xys=";

     

       19
        
         };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       20
        
       

     

       21
        
         nativeBuildInputs = [ pkg-config autoreconfHook ]

     

       22
        
           ++ lib.optionals withJava [ ant ];

+5 -4

pkgs/development/python-modules/ansible-lint/default.nix

···

       22
        
       

     

       23
        
       buildPythonPackage rec {

     

       24
        
         pname = "ansible-lint";

     

       25
       -
         version = "6.10.0";

     

       26
        
         format = "pyproject";

     

       0
        
       
     

       27
        
         disabled = pythonOlder "3.8";

     

       28
        
       

     

       29
        
         src = fetchPypi {

     

       30
        
           inherit pname version;

     

       31
       -
           sha256 = "sha256-9ezsWOvntr/El2vn1uQAQRqK8FsOGhnxXyX1nzQBNIw=";

     

       32
        
         };

     

       33
        
       

     

       34
        
         postPatch = ''

     
···

       91
        
           "test_run_inside_role_dir"

     

       92
        
           "test_run_multiple_role_path_no_trailing_slash"

     

       93
        
           "test_runner_exclude_globs"

     

       94
       -
       

     

       95
        
           "test_discover_lintables_umlaut"

     

       96
        
         ];

     

       97
        
       

     

       98
        
         makeWrapperArgs = [ "--prefix PATH : ${lib.makeBinPath [ ansible-core ]}" ];

     

       99
        
       

     

       100
        
         meta = with lib; {

     

       0
        
       
     

       101
        
           homepage = "https://github.com/ansible/ansible-lint";

     

       102
       -
           description = "Best practices checker for Ansible";

     

       103
        
           license = licenses.mit;

     

       104
        
           maintainers = with maintainers; [ sengaya ];

     

       105
        
         };

···

       22
        
       

     

       23
        
       buildPythonPackage rec {

     

       24
        
         pname = "ansible-lint";

     

       25
       +
         version = "6.10.1";

     

       26
        
         format = "pyproject";

     

       27
       +
       

     

       28
        
         disabled = pythonOlder "3.8";

     

       29
        
       

     

       30
        
         src = fetchPypi {

     

       31
        
           inherit pname version;

     

       32
       +
           hash = "sha256-JPFbYa9SvCKwXQCPnrdmLxz0KrdACNqfia9x/FQMz6Q=";

     

       33
        
         };

     

       34
        
       

     

       35
        
         postPatch = ''

     
···

       92
        
           "test_run_inside_role_dir"

     

       93
        
           "test_run_multiple_role_path_no_trailing_slash"

     

       94
        
           "test_runner_exclude_globs"

     

       0
        
       
     

       95
        
           "test_discover_lintables_umlaut"

     

       96
        
         ];

     

       97
        
       

     

       98
        
         makeWrapperArgs = [ "--prefix PATH : ${lib.makeBinPath [ ansible-core ]}" ];

     

       99
        
       

     

       100
        
         meta = with lib; {

     

       101
       +
           description = "Best practices checker for Ansible";

     

       102
        
           homepage = "https://github.com/ansible/ansible-lint";

     

       103
       +
           changelog = "https://github.com/ansible/ansible-lint/releases/tag/v${version}";

     

       104
        
           license = licenses.mit;

     

       105
        
           maintainers = with maintainers; [ sengaya ];

     

       106
        
         };

pkgs/development/python-modules/cachecontrol/default.nix

···

       18
        
       

     

       19
        
         disabled = pythonOlder "3.6";

     

       20
        
       

     

       0
        
       
     

       0
        
       
     

       21
        
         src = fetchFromGitHub {

     

       22
        
           owner = "ionrock";

     

       23
        
           repo = pname;

···

       18
        
       

     

       19
        
         disabled = pythonOlder "3.6";

     

       20
        
       

     

       21
       +
         __darwinAllowLocalNetworking = true;

     

       22
       +
       

     

       23
        
         src = fetchFromGitHub {

     

       24
        
           owner = "ionrock";

     

       25
        
           repo = pname;

+10 -2

pkgs/development/python-modules/ghrepo-stats/default.nix

···

       1
        
       { lib

     

       0
        
       
     

       2
        
       , buildPythonPackage

     

       3
        
       , fetchFromGitHub

     

       4
        
       , matplotlib

     
···

       8
        
       

     

       9
        
       buildPythonPackage rec {

     

       10
        
         pname = "ghrepo-stats";

     

       11
       -
         version = "0.4.0";

     

       12
        
         format = "setuptools";

     

       13
        
       

     

       14
        
         disabled = pythonOlder "3.8";

     
···

       17
        
           owner = "mrbean-bremen";

     

       18
        
           repo = pname;

     

       19
        
           rev = "v${version}";

     

       20
       -
           hash = "sha256-KFjqHrN0prcqu3wEPZpa7rLfuD0X/DN7BMo4zcHNmYo=";

     

       21
        
         };

     

       22
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       23
        
         propagatedBuildInputs = [

     

       0
        
       
     

       24
        
           matplotlib

     

       25
        
           PyGithub

     

       26
        
         ];

···

       1
        
       { lib

     

       2
       +
       , beautifulsoup4

     

       3
        
       , buildPythonPackage

     

       4
        
       , fetchFromGitHub

     

       5
        
       , matplotlib

     
···

       9
        
       

     

       10
        
       buildPythonPackage rec {

     

       11
        
         pname = "ghrepo-stats";

     

       12
       +
         version = "0.5.0";

     

       13
        
         format = "setuptools";

     

       14
        
       

     

       15
        
         disabled = pythonOlder "3.8";

     
···

       18
        
           owner = "mrbean-bremen";

     

       19
        
           repo = pname;

     

       20
        
           rev = "v${version}";

     

       21
       +
           hash = "sha256-rTW6wADpkP9GglNmQNVecHfA2yJZuzYhJfsLfucbcgY=";

     

       22
        
         };

     

       23
        
       

     

       24
       +
         postPatch = ''

     

       25
       +
           # https://github.com/mrbean-bremen/ghrepo-stats/pull/1

     

       26
       +
           substituteInPlace setup.py \

     

       27
       +
             --replace "bs4" "beautifulsoup4"

     

       28
       +
         '';

     

       29
       +
       

     

       30
        
         propagatedBuildInputs = [

     

       31
       +
           beautifulsoup4

     

       32
        
           matplotlib

     

       33
        
           PyGithub

     

       34
        
         ];

+2 -2

pkgs/development/python-modules/meross-iot/default.nix

···

       11
        
       

     

       12
        
       buildPythonPackage rec {

     

       13
        
         pname = "meross-iot";

     

       14
       -
         version = "0.4.5.2";

     

       15
        
         format = "setuptools";

     

       16
        
       

     

       17
        
         disabled = pythonOlder "3.7";

     
···

       20
        
           owner = "albertogeniola";

     

       21
        
           repo = "MerossIot";

     

       22
        
           rev = "refs/tags/${version}";

     

       23
       -
           hash = "sha256-gT4HxdmyX7oOQFBo1frkmmoXrNfGOcqL0hPZ40kRZeo=";

     

       24
        
         };

     

       25
        
       

     

       26
        
         propagatedBuildInputs = [

···

       11
        
       

     

       12
        
       buildPythonPackage rec {

     

       13
        
         pname = "meross-iot";

     

       14
       +
         version = "0.4.5.4";

     

       15
        
         format = "setuptools";

     

       16
        
       

     

       17
        
         disabled = pythonOlder "3.7";

     
···

       20
        
           owner = "albertogeniola";

     

       21
        
           repo = "MerossIot";

     

       22
        
           rev = "refs/tags/${version}";

     

       23
       +
           hash = "sha256-HPA3oeanFHx+g0nt/nsTzG3RTCdsjNSvDCXILR271P4=";

     

       24
        
         };

     

       25
        
       

     

       26
        
         propagatedBuildInputs = [

+4 -3

pkgs/development/python-modules/pypck/default.nix

···

       10
        
       

     

       11
        
       buildPythonPackage rec {

     

       12
        
         pname = "pypck";

     

       13
       -
         version = "0.7.15";

     

       14
        
         format = "setuptools";

     

       15
        
       

     

       16
        
         disabled = pythonOlder "3.8";

     
···

       18
        
         src = fetchFromGitHub {

     

       19
        
           owner = "alengwenus";

     

       20
        
           repo = pname;

     

       21
       -
           rev = version;

     

       22
       -
           hash = "sha256-OuM/r9rxIl4niY87cEcbZ73x2ZIQbaPZqbMrQ7hZE/g=";

     

       23
        
         };

     

       24
        
       

     

       25
        
         checkInputs = [

     
···

       45
        
         meta = with lib; {

     

       46
        
           description = "LCN-PCK library written in Python";

     

       47
        
           homepage = "https://github.com/alengwenus/pypck";

     

       0
        
       
     

       48
        
           license = with licenses; [ epl20 ];

     

       49
        
           maintainers = with maintainers; [ fab ];

     

       50
        
         };

···

       10
        
       

     

       11
        
       buildPythonPackage rec {

     

       12
        
         pname = "pypck";

     

       13
       +
         version = "0.7.16";

     

       14
        
         format = "setuptools";

     

       15
        
       

     

       16
        
         disabled = pythonOlder "3.8";

     
···

       18
        
         src = fetchFromGitHub {

     

       19
        
           owner = "alengwenus";

     

       20
        
           repo = pname;

     

       21
       +
           rev = "refs/tags/${version}";

     

       22
       +
           hash = "sha256-OcXMVgG62JUH28BGvfO/rpnC++/klhBLJ2HafDu9R40=";

     

       23
        
         };

     

       24
        
       

     

       25
        
         checkInputs = [

     
···

       45
        
         meta = with lib; {

     

       46
        
           description = "LCN-PCK library written in Python";

     

       47
        
           homepage = "https://github.com/alengwenus/pypck";

     

       48
       +
           changelog = "https://github.com/alengwenus/pypck/releases/tag/${version}";

     

       49
        
           license = with licenses; [ epl20 ];

     

       50
        
           maintainers = with maintainers; [ fab ];

     

       51
        
         };

+2 -2

pkgs/development/python-modules/python-fsutil/default.nix

···

       8
        
       

     

       9
        
       buildPythonPackage rec {

     

       10
        
         pname = "python-fsutil";

     

       11
       -
         version = "0.8.0";

     

       12
        
         format = "setuptools";

     

       13
        
       

     

       14
        
         disabled = pythonOlder "3.7";

     
···

       17
        
           owner = "fabiocaccamo";

     

       18
        
           repo = pname;

     

       19
        
           rev = "refs/tags/${version}";

     

       20
       -
           hash = "sha256-J5B5THfB/yPG1JSCpO2HTHTH0jn0nbKFzXpZMGJ/dKA=";

     

       21
        
         };

     

       22
        
       

     

       23
        
         propagatedBuildInputs = [

···

       8
        
       

     

       9
        
       buildPythonPackage rec {

     

       10
        
         pname = "python-fsutil";

     

       11
       +
         version = "0.9.1";

     

       12
        
         format = "setuptools";

     

       13
        
       

     

       14
        
         disabled = pythonOlder "3.7";

     
···

       17
        
           owner = "fabiocaccamo";

     

       18
        
           repo = pname;

     

       19
        
           rev = "refs/tags/${version}";

     

       20
       +
           hash = "sha256-rMQjsGqdiXe8zS18hZQAro3UWyHPjNJYyQ/NAoxbE7k=";

     

       21
        
         };

     

       22
        
       

     

       23
        
         propagatedBuildInputs = [

+2 -2

pkgs/development/python-modules/python-ipmi/default.nix

···

       10
        
       

     

       11
        
       buildPythonPackage rec {

     

       12
        
         pname = "python-ipmi";

     

       13
       -
         version = "0.5.2";

     

       14
        
         disabled = pythonOlder "3.6";

     

       15
        
       

     

       16
        
         src = fetchFromGitHub {

     

       17
        
           owner = "kontron";

     

       18
        
           repo = pname;

     

       19
        
           rev = version;

     

       20
       -
           sha256 = "sha256-VXWSoVRfgJWf9rOT4SE1mTJdeNmzR3TRc2pc6Pp1M5U=";

     

       21
        
         };

     

       22
        
       

     

       23
        
         propagatedBuildInputs = [

···

       10
        
       

     

       11
        
       buildPythonPackage rec {

     

       12
        
         pname = "python-ipmi";

     

       13
       +
         version = "0.5.3";

     

       14
        
         disabled = pythonOlder "3.6";

     

       15
        
       

     

       16
        
         src = fetchFromGitHub {

     

       17
        
           owner = "kontron";

     

       18
        
           repo = pname;

     

       19
        
           rev = version;

     

       20
       +
           sha256 = "sha256-Y8HJ7MXYHJRUWPTcw8p+GGSFswuRI7u+/bIaJpKy7lY=";

     

       21
        
         };

     

       22
        
       

     

       23
        
         propagatedBuildInputs = [

+2 -2

pkgs/development/python-modules/roonapi/default.nix

···

       11
        
       

     

       12
        
       buildPythonPackage rec {

     

       13
        
         pname = "roonapi";

     

       14
       -
         version = "0.1.2";

     

       15
        
         format = "pyproject";

     

       16
        
       

     

       17
        
         disabled = pythonOlder "3.7";

     
···

       20
        
           owner = "pavoni";

     

       21
        
           repo = "pyroon";

     

       22
        
           rev = version;

     

       23
       -
           hash = "sha256-HcHs9UhRbSKTxW5qEvmMrQ+kWIBAqVpyldapx635uNM=";

     

       24
        
         };

     

       25
        
       

     

       26
        
         nativeBuildInputs = [

···

       11
        
       

     

       12
        
       buildPythonPackage rec {

     

       13
        
         pname = "roonapi";

     

       14
       +
         version = "0.1.3";

     

       15
        
         format = "pyproject";

     

       16
        
       

     

       17
        
         disabled = pythonOlder "3.7";

     
···

       20
        
           owner = "pavoni";

     

       21
        
           repo = "pyroon";

     

       22
        
           rev = version;

     

       23
       +
           hash = "sha256-QOFBNTz8g3f6C8Vjkblrd3QFCRrA1WqOCv6xS4GbFC4=";

     

       24
        
         };

     

       25
        
       

     

       26
        
         nativeBuildInputs = [

+2 -2

pkgs/development/python-modules/skodaconnect/default.nix

···

       12
        
       

     

       13
        
       buildPythonPackage rec {

     

       14
        
         pname = "skodaconnect";

     

       15
       -
         version = "1.2.5";

     

       16
        
         format = "setuptools";

     

       17
        
       

     

       18
        
         disabled = pythonOlder "3.8";

     
···

       21
        
           owner = "lendy007";

     

       22
        
           repo = pname;

     

       23
        
           rev = "refs/tags/${version}";

     

       24
       -
           hash = "sha256-Re6ECMaDmg007XHw9Kpa46+oEs+01CzOZzszKzKS4WA=";

     

       25
        
         };

     

       26
        
       

     

       27
        
         SETUPTOOLS_SCM_PRETEND_VERSION = version;

···

       12
        
       

     

       13
        
       buildPythonPackage rec {

     

       14
        
         pname = "skodaconnect";

     

       15
       +
         version = "1.3.0";

     

       16
        
         format = "setuptools";

     

       17
        
       

     

       18
        
         disabled = pythonOlder "3.8";

     
···

       21
        
           owner = "lendy007";

     

       22
        
           repo = pname;

     

       23
        
           rev = "refs/tags/${version}";

     

       24
       +
           hash = "sha256-1x1TQNhKL3RgoeYSB8l607mHt0VrHwOU1CFemoaTCt8=";

     

       25
        
         };

     

       26
        
       

     

       27
        
         SETUPTOOLS_SCM_PRETEND_VERSION = version;

+4 -3

pkgs/development/python-modules/socialscan/default.nix

···

       9
        
       

     

       10
        
       buildPythonPackage rec {

     

       11
        
         pname = "socialscan";

     

       12
       -
         version = "1.4.2";

     

       13
        
         format = "setuptools";

     

       14
        
       

     

       15
        
         disabled = pythonOlder "3.8";

     
···

       17
        
         src = fetchFromGitHub {

     

       18
        
           owner = "iojw";

     

       19
        
           repo = pname;

     

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

     

       21
       -
           sha256 = "rT+/j6UqDOzuNBdN3I74YIxS6qkhd7BjHCGX+gGjprc=";

     

       22
        
         };

     

       23
        
       

     

       24
        
         propagatedBuildInputs = [

     
···

       37
        
         meta = with lib; {

     

       38
        
           description = "Python library and CLI for accurately querying username and email usage on online platforms";

     

       39
        
           homepage = "https://github.com/iojw/socialscan";

     

       0
        
       
     

       40
        
           license = with licenses; [ mpl20 ];

     

       41
        
           maintainers = with maintainers; [ fab ];

     

       42
        
         };

···

       9
        
       

     

       10
        
       buildPythonPackage rec {

     

       11
        
         pname = "socialscan";

     

       12
       +
         version = "2.0.0";

     

       13
        
         format = "setuptools";

     

       14
        
       

     

       15
        
         disabled = pythonOlder "3.8";

     
···

       17
        
         src = fetchFromGitHub {

     

       18
        
           owner = "iojw";

     

       19
        
           repo = pname;

     

       20
       +
           rev = "refs/tags/v${version}";

     

       21
       +
           sha256 = "sha256-jiyTcpJ00DvfweChawj1ugdCVHHAdwDbHEp9jivH7gs=";

     

       22
        
         };

     

       23
        
       

     

       24
        
         propagatedBuildInputs = [

     
···

       37
        
         meta = with lib; {

     

       38
        
           description = "Python library and CLI for accurately querying username and email usage on online platforms";

     

       39
        
           homepage = "https://github.com/iojw/socialscan";

     

       40
       +
           changelog = "https://github.com/iojw/socialscan/releases/tag/v${version}";

     

       41
        
           license = with licenses; [ mpl20 ];

     

       42
        
           maintainers = with maintainers; [ fab ];

     

       43
        
         };

+18 -7

pkgs/development/python-modules/tubeup/default.nix

···

       4
        
       , fetchPypi

     

       5
        
       , yt-dlp

     

       6
        
       , docopt

     

       7
       -
       , isPy27

     

       0
        
       
     

       8
        
       }:

     

       9
        
       

     

       10
        
       buildPythonPackage rec {

     

       11
        
         pname = "tubeup";

     

       12
       -
         version = "0.0.34";

     

       13
        
         format = "setuptools";

     

       14
        
       

     

       15
       -
         disabled = isPy27;

     

       16
        
       

     

       17
        
         src = fetchPypi {

     

       18
        
           inherit pname version;

     

       19
       -
           sha256 = "ae1e606b243fd70742f8b5871c497628d258ee9f416caa46544aca9a5fbfbca0";

     

       20
        
         };

     

       21
        
       

     

       22
        
         postPatch = ''

     

       23
        
           substituteInPlace setup.py \

     

       0
        
       
     

       0
        
       
     

       24
        
             --replace "docopt==0.6.2" "docopt"

     

       25
        
         '';

     

       26
        
       

     

       27
       -
         propagatedBuildInputs = [ internetarchive docopt yt-dlp ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       28
        
       

     

       29
       -
         pythonImportsCheck = [ "tubeup" ];

     

       0
        
       
     

       0
        
       
     

       30
        
       

     

       31
        
         # Tests failing upstream

     

       32
        
         doCheck = false;

     
···

       34
        
         meta = with lib; {

     

       35
        
           description = "Youtube (and other video site) to Internet Archive Uploader";

     

       36
        
           homepage = "https://github.com/bibanon/tubeup";

     

       0
        
       
     

       37
        
           license = licenses.gpl3Only;

     

       38
       -
           maintainers = [ maintainers.marsam ];

     

       39
        
         };

     

       40
        
       }

···

       4
        
       , fetchPypi

     

       5
        
       , yt-dlp

     

       6
        
       , docopt

     

       7
       +
       , pythonOlder

     

       8
       +
       , urllib3

     

       9
        
       }:

     

       10
        
       

     

       11
        
       buildPythonPackage rec {

     

       12
        
         pname = "tubeup";

     

       13
       +
         version = "0.0.35";

     

       14
        
         format = "setuptools";

     

       15
        
       

     

       16
       +
         disabled = pythonOlder "3.7";

     

       17
        
       

     

       18
        
         src = fetchPypi {

     

       19
        
           inherit pname version;

     

       20
       +
           sha256 = "006aea68bb8d967a7427c58ee7862e3f2481dae667c2bbcfb1a1f2fd80e665d1";

     

       21
        
         };

     

       22
        
       

     

       23
        
         postPatch = ''

     

       24
        
           substituteInPlace setup.py \

     

       25
       +
             --replace "internetarchive==3.0.2" "internetarchive" \

     

       26
       +
             --replace "urllib3==1.26.13" "urllib3" \

     

       27
        
             --replace "docopt==0.6.2" "docopt"

     

       28
        
         '';

     

       29
        
       

     

       30
       +
         propagatedBuildInputs = [

     

       31
       +
           internetarchive

     

       32
       +
           docopt

     

       33
       +
           urllib3

     

       34
       +
           yt-dlp

     

       35
       +
         ];

     

       36
        
       

     

       37
       +
         pythonImportsCheck = [

     

       38
       +
           "tubeup"

     

       39
       +
         ];

     

       40
        
       

     

       41
        
         # Tests failing upstream

     

       42
        
         doCheck = false;

     
···

       44
        
         meta = with lib; {

     

       45
        
           description = "Youtube (and other video site) to Internet Archive Uploader";

     

       46
        
           homepage = "https://github.com/bibanon/tubeup";

     

       47
       +
           changelog = "https://github.com/bibanon/tubeup/releases/tag/${version}";

     

       48
        
           license = licenses.gpl3Only;

     

       49
       +
           maintainers = with maintainers; [ marsam ];

     

       50
        
         };

     

       51
        
       }

+14 -3

pkgs/development/tools/build-managers/tup/default.nix

···

       1
       -
       { lib, stdenv, fetchFromGitHub, fuse3, macfuse-stubs, pkg-config, pcre }:

     

       2
        
       

     

       3
        
       let

     

       4
        
         fuse = if stdenv.isDarwin then macfuse-stubs else fuse3;

     
···

       15
        
         };

     

       16
        
       

     

       17
        
         nativeBuildInputs = [ pkg-config ];

     

       18
       -
         buildInputs = [ fuse pcre ];

     

       19
        
       

     

       20
        
         patches = [ ./fusermount-setuid.patch ];

     

       21
        
       

     

       22
        
         configurePhase = ''

     

       23
        
           substituteInPlace  src/tup/link.sh --replace '`git describe' '`echo ${version}'

     

       24
       -
           substituteInPlace Tuprules.tup --replace 'pcre-config' 'pkg-config libpcre'

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
         '';

     

       26
        
       

     

       27
        
         # Regular tup builds require fusermount to have suid, which nix cannot

···

       1
       +
       { lib, stdenv, fetchFromGitHub, fuse3, macfuse-stubs, pkg-config, sqlite, pcre }:

     

       2
        
       

     

       3
        
       let

     

       4
        
         fuse = if stdenv.isDarwin then macfuse-stubs else fuse3;

     
···

       15
        
         };

     

       16
        
       

     

       17
        
         nativeBuildInputs = [ pkg-config ];

     

       18
       +
         buildInputs = [ fuse pcre sqlite ];

     

       19
        
       

     

       20
        
         patches = [ ./fusermount-setuid.patch ];

     

       21
        
       

     

       22
        
         configurePhase = ''

     

       23
        
           substituteInPlace  src/tup/link.sh --replace '`git describe' '`echo ${version}'

     

       24
       +
       

     

       25
       +
           for f in Tupfile Tuprules.tup src/tup/server/Tupfile build.sh; do

     

       26
       +
             substituteInPlace "$f" \

     

       27
       +
               --replace "pkg-config"  "${stdenv.cc.targetPrefix}pkg-config" \

     

       28
       +
               --replace "pcre-config" "${stdenv.cc.targetPrefix}pkg-config libpcre"

     

       29
       +
           done

     

       30
       +
       

     

       31
       +
           cat << EOF > tup.config

     

       32
       +
           CONFIG_CC=${stdenv.cc.targetPrefix}cc

     

       33
       +
           CONFIG_AR=${stdenv.cc.targetPrefix}ar

     

       34
       +
           CONFIG_TUP_USE_SYSTEM_SQLITE=y

     

       35
       +
           EOF

     

       36
        
         '';

     

       37
        
       

     

       38
        
         # Regular tup builds require fusermount to have suid, which nix cannot

+4 -6

pkgs/development/tools/haskell/vaultenv/default.nix

···

       19
        
       , parser-combinators

     

       20
        
       , retry

     

       21
        
       , lib

     

       0
        
       
     

       22
        
       , text

     

       23
        
       , unix

     

       24
        
       , unordered-containers

     
···

       28
        
       }:

     

       29
        
       mkDerivation rec {

     

       30
        
         pname = "vaultenv";

     

       31
       -
         version = "0.14.0";

     

       32
        
       

     

       33
        
         src = fetchFromGitHub {

     

       34
        
           owner = "channable";

     

       35
        
           repo = "vaultenv";

     

       36
        
           rev = "v${version}";

     

       37
       -
           sha256 = "sha256-sH4iaKQXgwI/WISXzMR7xqh9Dyx61U/gjYn7exgUetI=";

     

       38
        
         };

     

       39
        
       

     

       40
        
         buildTools = [ hpack ];

     
···

       86
        
           optparse-applicative

     

       87
        
           parser-combinators

     

       88
        
           retry

     

       0
        
       
     

       89
        
           text

     

       90
        
           unix

     

       91
        
           unordered-containers

     
···

       96
        
         description = "Runs processes with secrets from HashiCorp Vault";

     

       97
        
         license = lib.licenses.bsd3;

     

       98
        
         maintainers = with lib.maintainers; [ lnl7 manveru ];

     

       99
       -
       

     

       100
       -
         # Does not compile on ghc92

     

       101
       -
         hydraPlatforms = lib.platforms.none;

     

       102
       -
         broken = true;

     

       103
        
       }

···

       19
        
       , parser-combinators

     

       20
        
       , retry

     

       21
        
       , lib

     

       22
       +
       , quickcheck-instances

     

       23
        
       , text

     

       24
        
       , unix

     

       25
        
       , unordered-containers

     
···

       29
        
       }:

     

       30
        
       mkDerivation rec {

     

       31
        
         pname = "vaultenv";

     

       32
       +
         version = "0.15.1";

     

       33
        
       

     

       34
        
         src = fetchFromGitHub {

     

       35
        
           owner = "channable";

     

       36
        
           repo = "vaultenv";

     

       37
        
           rev = "v${version}";

     

       38
       +
           sha256 = "sha256-yoYkAypH+HQSVTvd/qKNFkL5krbB5mZw3ec9ojvy+Pw=";

     

       39
        
         };

     

       40
        
       

     

       41
        
         buildTools = [ hpack ];

     
···

       87
        
           optparse-applicative

     

       88
        
           parser-combinators

     

       89
        
           retry

     

       90
       +
           quickcheck-instances

     

       91
        
           text

     

       92
        
           unix

     

       93
        
           unordered-containers

     
···

       98
        
         description = "Runs processes with secrets from HashiCorp Vault";

     

       99
        
         license = lib.licenses.bsd3;

     

       100
        
         maintainers = with lib.maintainers; [ lnl7 manveru ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       101
        
       }

+11 -4

pkgs/os-specific/linux/systemd/default.nix

···

       70
        
       

     

       71
        
         # the (optional) BPF feature requires bpftool, libbpf, clang and llvm-strip to be available during build time.

     

       72
        
         # Only libbpf should be a runtime dependency.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       73
        
       , bpftools

     

       74
        
       , libbpf

     

       75
       -
       , llvmPackages

     

       76
        
       

     

       77
        
       , withAnalyze ? true

     

       78
        
       , withApparmor ? true

     
···

       86
        
       , withHostnamed ? true

     

       87
        
       , withHwdb ? true

     

       88
        
       , withImportd ? !stdenv.hostPlatform.isMusl

     

       89
       -
       , withLibBPF ? lib.versionAtLeast llvmPackages.clang.version "10.0"

     

       90
        
       , withLocaled ? true

     

       91
        
       , withLogind ? true

     

       92
        
       , withMachined ? true

     
···

       368
        
           ]

     

       369
        
           ++ lib.optionals withLibBPF [

     

       370
        
             bpftools

     

       371
       -
             llvmPackages.clang

     

       372
       -
             llvmPackages.libllvm

     

       373
        
           ]

     

       374
        
         ;

     

       375

···

       70
        
       

     

       71
        
         # the (optional) BPF feature requires bpftool, libbpf, clang and llvm-strip to be available during build time.

     

       72
        
         # Only libbpf should be a runtime dependency.

     

       73
       +
         # Note: llvmPackages is explicitly taken from buildPackages instead of relying

     

       74
       +
         # on splicing. Splicing will evaluate the adjacent (pkgsHostTarget) llvmPackages

     

       75
       +
         # which is sometimes problematic: llvmPackages.clang looks at targetPackages.stdenv.cc

     

       76
       +
         # which, in the unfortunate case of pkgsCross.ghcjs, `throw`s. If we explicitly

     

       77
       +
         # take buildPackages.llvmPackages, this is no problem because

     

       78
       +
         # `buildPackages.targetPackages.stdenv.cc == stdenv.cc` relative to us. Working

     

       79
       +
         # around this is important, because systemd is in the dependency closure of

     

       80
       +
         # GHC via emscripten and jdk.

     

       81
        
       , bpftools

     

       82
        
       , libbpf

     

       0
        
       
     

       83
        
       

     

       84
        
       , withAnalyze ? true

     

       85
        
       , withApparmor ? true

     
···

       93
        
       , withHostnamed ? true

     

       94
        
       , withHwdb ? true

     

       95
        
       , withImportd ? !stdenv.hostPlatform.isMusl

     

       96
       +
       , withLibBPF ? lib.versionAtLeast buildPackages.llvmPackages.clang.version "10.0"

     

       97
        
       , withLocaled ? true

     

       98
        
       , withLogind ? true

     

       99
        
       , withMachined ? true

     
···

       375
        
           ]

     

       376
        
           ++ lib.optionals withLibBPF [

     

       377
        
             bpftools

     

       378
       +
             buildPackages.llvmPackages.clang

     

       379
       +
             buildPackages.llvmPackages.libllvm

     

       380
        
           ]

     

       381
        
         ;

     

       382

pkgs/servers/apcupsd/default.nix

···

       1
        
       { lib, stdenv, fetchurl, pkg-config, systemd, util-linux, coreutils, wall, hostname, man

     

       2
        
       , enableCgiScripts ? true, gd

     

       0
        
       
     

       3
        
       }:

     

       4
        
       

     

       5
        
       assert enableCgiScripts -> gd != null;

     
···

       51
        
                      "$file"

     

       52
        
           done

     

       53
        
         '';

     

       0
        
       
     

       0
        
       
     

       54
        
       

     

       55
        
         meta = with lib; {

     

       56
        
           description = "Daemon for controlling APC UPSes";

···

       1
        
       { lib, stdenv, fetchurl, pkg-config, systemd, util-linux, coreutils, wall, hostname, man

     

       2
        
       , enableCgiScripts ? true, gd

     

       3
       +
       , nixosTests

     

       4
        
       }:

     

       5
        
       

     

       6
        
       assert enableCgiScripts -> gd != null;

     
···

       52
        
                      "$file"

     

       53
        
           done

     

       54
        
         '';

     

       55
       +
       

     

       56
       +
         passthru.tests.smoke = nixosTests.apcupsd;

     

       57
        
       

     

       58
        
         meta = with lib; {

     

       59
        
           description = "Daemon for controlling APC UPSes";

+1 -1

pkgs/servers/home-assistant/component-packages.nix

···

       2
        
       # Do not edit!

     

       3
        
       

     

       4
        
       {

     

       5
       -
         version = "2022.12.8";

     

       6
        
         components = {

     

       7
        
           "3_day_blinds" = ps: with ps; [

     

       8
        
           ];

···

       2
        
       # Do not edit!

     

       3
        
       

     

       4
        
       {

     

       5
       +
         version = "2022.12.9";

     

       6
        
         components = {

     

       7
        
           "3_day_blinds" = ps: with ps; [

     

       8
        
           ];

+2 -2

pkgs/servers/home-assistant/default.nix

···

       190
        
         extraPackagesFile = writeText "home-assistant-packages" (lib.concatMapStringsSep "\n" (pkg: pkg.pname) extraBuildInputs);

     

       191
        
       

     

       192
        
         # Don't forget to run parse-requirements.py after updating

     

       193
       -
         hassVersion = "2022.12.8";

     

       194
        
       

     

       195
        
       in python.pkgs.buildPythonApplication rec {

     

       196
        
         pname = "homeassistant";

     
···

       208
        
           owner = "home-assistant";

     

       209
        
           repo = "core";

     

       210
        
           rev = "refs/tags/${version}";

     

       211
       -
           hash = "sha256-oJwA0YELlgMbnf1XiLDGlMLrvFaLP7WMv9/0KOI4XDI=";

     

       212
        
         };

     

       213
        
       

     

       214
        
         # leave this in, so users don't have to constantly update their downstream patch handling

···

       190
        
         extraPackagesFile = writeText "home-assistant-packages" (lib.concatMapStringsSep "\n" (pkg: pkg.pname) extraBuildInputs);

     

       191
        
       

     

       192
        
         # Don't forget to run parse-requirements.py after updating

     

       193
       +
         hassVersion = "2022.12.9";

     

       194
        
       

     

       195
        
       in python.pkgs.buildPythonApplication rec {

     

       196
        
         pname = "homeassistant";

     
···

       208
        
           owner = "home-assistant";

     

       209
        
           repo = "core";

     

       210
        
           rev = "refs/tags/${version}";

     

       211
       +
           hash = "sha256-tf2H4+79CGTmbKZtJpzYOzAgi90RpSy89hoDNS24m0Q=";

     

       212
        
         };

     

       213
        
       

     

       214
        
         # leave this in, so users don't have to constantly update their downstream patch handling

+17 -6

pkgs/tools/filesystems/gcsfuse/default.nix

···

       1
       -
       { lib, buildGoModule, fetchFromGitHub }:

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       

     

       3
        
       buildGoModule rec {

     

       4
        
         pname = "gcsfuse";

     

       5
       -
         version = "0.41.9";

     

       6
        
       

     

       7
        
         src = fetchFromGitHub {

     

       8
        
           owner = "googlecloudplatform";

     

       9
        
           repo = "gcsfuse";

     

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

     

       11
       -
           sha256 = "sha256-hfdQa0e1S1cIF4V2XPFBl4jzzTWlIxZIJ99PRxCP55s=";

     

       12
        
         };

     

       13
        
       

     

       14
        
         vendorSha256 = null;

     

       15
        
       

     

       16
       -
         subPackages = [ "." "tools/mount_gcsfuse" ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       17
        
       

     

       18
       -
         ldflags = [ "-s" "-w" "-X main.gcsfuseVersion=${version}" ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       19
        
       

     

       20
        
         preCheck =

     

       21
        
           let skippedTests = [

     
···

       35
        
         meta = with lib;{

     

       36
        
           description = "A user-space file system for interacting with Google Cloud Storage";

     

       37
        
           homepage = "https://cloud.google.com/storage/docs/gcs-fuse";

     

       0
        
       
     

       38
        
           license = licenses.asl20;

     

       39
        
           platforms = platforms.unix;

     

       40
        
           maintainers = with maintainers; [ aaronjheng ];

···

       1
       +
       { lib

     

       2
       +
       , buildGoModule

     

       3
       +
       , fetchFromGitHub

     

       4
       +
       }:

     

       5
        
       

     

       6
        
       buildGoModule rec {

     

       7
        
         pname = "gcsfuse";

     

       8
       +
         version = "0.41.10";

     

       9
        
       

     

       10
        
         src = fetchFromGitHub {

     

       11
        
           owner = "googlecloudplatform";

     

       12
        
           repo = "gcsfuse";

     

       13
       +
           rev = "refs/tags/${version}";

     

       14
       +
           hash = "sha256-rtBqXC1CTkbKDP6pzkRQ7GnM5f4xt6eUMW3n9wZu0hc=";

     

       15
        
         };

     

       16
        
       

     

       17
        
         vendorSha256 = null;

     

       18
        
       

     

       19
       +
         subPackages = [

     

       20
       +
           "."

     

       21
       +
           "tools/mount_gcsfuse"

     

       22
       +
         ];

     

       23
        
       

     

       24
       +
         ldflags = [

     

       25
       +
           "-s"

     

       26
       +
           "-w"

     

       27
       +
           "-X main.gcsfuseVersion=${version}"

     

       28
       +
         ];

     

       29
        
       

     

       30
        
         preCheck =

     

       31
        
           let skippedTests = [

     
···

       45
        
         meta = with lib;{

     

       46
        
           description = "A user-space file system for interacting with Google Cloud Storage";

     

       47
        
           homepage = "https://cloud.google.com/storage/docs/gcs-fuse";

     

       48
       +
           changelog = "https://github.com/GoogleCloudPlatform/gcsfuse/releases/tag/v${version}";

     

       49
        
           license = licenses.asl20;

     

       50
        
           platforms = platforms.unix;

     

       51
        
           maintainers = with maintainers; [ aaronjheng ];

+8 -6

pkgs/tools/misc/broot/default.nix

···

       1
        
       { lib

     

       2
        
       , stdenv

     

       3
        
       , rustPlatform

     

       4
       -
       , fetchCrate

     

       5
        
       , installShellFiles

     

       6
        
       , makeWrapper

     

       7
        
       , pkg-config

     
···

       15
        
       

     

       16
        
       rustPlatform.buildRustPackage rec {

     

       17
        
         pname = "broot";

     

       18
       -
         version = "1.18.0";

     

       19
        
       

     

       20
       -
         src = fetchCrate {

     

       21
       -
           inherit pname version;

     

       22
       -
           sha256 = "sha256-GR0a5NDJBcRLoNOeG6S+fP3Fr7r5fVB9oEcjANRYJt4=";

     

       0
        
       
     

       0
        
       
     

       23
        
         };

     

       24
        
       

     

       25
       -
         cargoHash = "sha256-Hk9bc1mo8GxcPICKXc9zDq18S5TZElDncxJ+w2fC2do=";

     

       26
        
       

     

       27
        
         nativeBuildInputs = [

     

       28
        
           installShellFiles

···

       1
        
       { lib

     

       2
        
       , stdenv

     

       3
        
       , rustPlatform

     

       4
       +
       , fetchFromGitHub

     

       5
        
       , installShellFiles

     

       6
        
       , makeWrapper

     

       7
        
       , pkg-config

     
···

       15
        
       

     

       16
        
       rustPlatform.buildRustPackage rec {

     

       17
        
         pname = "broot";

     

       18
       +
         version = "1.19.0";

     

       19
        
       

     

       20
       +
         src = fetchFromGitHub {

     

       21
       +
           owner = "Canop";

     

       22
       +
           repo = pname;

     

       23
       +
           rev = "v${version}";

     

       24
       +
           hash = "sha256-pg+eHmClDd04tWljQUS0IRyMzkHnkpkofuhz/KyQbWo=";

     

       25
        
         };

     

       26
        
       

     

       27
       +
         cargoHash = "sha256-+RUYC39L7yyh1xYPfZn7tDIf1cmmBuGcqTNibFk7s6M=";

     

       28
        
       

     

       29
        
         nativeBuildInputs = [

     

       30
        
           installShellFiles

+3 -5

pkgs/tools/networking/iwgtk/default.nix

···

       12
        
       

     

       13
        
       stdenv.mkDerivation rec {

     

       14
        
         pname = "iwgtk";

     

       15
       -
         version = "0.8";

     

       16
        
       

     

       17
        
         src = fetchFromGitHub {

     

       18
        
           owner = "j-lentz";

     

       19
        
           repo = pname;

     

       20
        
           rev = "v${version}";

     

       21
       -
           sha256 = "sha256-89rzDxalZtQkwAKS6hKPVY87kOWPySwDeZrPs2rGs/k=";

     

       22
        
         };

     

       23
        
       

     

       24
        
         # patch systemd service to pass necessary environments and use absolute paths

     
···

       29
        
         buildInputs = [ gtk4 qrencode ];

     

       30
        
       

     

       31
        
         postInstall = ''

     

       32
       -
           mv $out/share/lib/systemd $out/share

     

       33
       -
           rmdir $out/share/lib

     

       34
       -
           substituteInPlace $out/share/systemd/user/iwgtk.service --subst-var out

     

       35
        
         '';

     

       36
        
       

     

       37
        
         meta = with lib; {

···

       12
        
       

     

       13
        
       stdenv.mkDerivation rec {

     

       14
        
         pname = "iwgtk";

     

       15
       +
         version = "0.9";

     

       16
        
       

     

       17
        
         src = fetchFromGitHub {

     

       18
        
           owner = "j-lentz";

     

       19
        
           repo = pname;

     

       20
        
           rev = "v${version}";

     

       21
       +
           sha256 = "sha256-/Nxti4PfYVLnIiBgtAuR3KGI8dULszuSdTp+2DzBfbs=";

     

       22
        
         };

     

       23
        
       

     

       24
        
         # patch systemd service to pass necessary environments and use absolute paths

     
···

       29
        
         buildInputs = [ gtk4 qrencode ];

     

       30
        
       

     

       31
        
         postInstall = ''

     

       32
       +
           substituteInPlace $out/lib/systemd/user/iwgtk.service --subst-var out

     

       0
        
       
     

       0
        
       
     

       33
        
         '';

     

       34
        
       

     

       35
        
         meta = with lib; {

+31 -12

pkgs/tools/networking/nfdump/default.nix

···

       1
       -
       { lib, stdenv, fetchFromGitHub

     

       2
       -
       , autoconf, automake, libtool, pkg-config

     

       3
       -
       , bzip2, libpcap, flex, bison }:

     

       4
       -
       

     

       5
       -
       let version = "1.7.0.1"; in

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       7
       -
       stdenv.mkDerivation {

     

       8
        
         pname = "nfdump";

     

       9
       -
         inherit version;

     

       10
        
       

     

       11
        
         src = fetchFromGitHub {

     

       12
        
           owner = "phaag";

     

       13
        
           repo = "nfdump";

     

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

     

       15
       -
           sha256 = "sha256-yD/NFGw38ishqQmKhlnHYodXmJuezI09hxNsyObZ1QE=";

     

       16
        
         };

     

       17
        
       

     

       18
       -
         nativeBuildInputs = [ autoconf automake flex libtool pkg-config bison ];

     

       19
       -
         buildInputs = [ bzip2 libpcap ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       20
        
       

     

       21
        
         preConfigure = ''

     

       22
        
           # The script defaults to glibtoolize on darwin, so we pass the correct

     
···

       37
        
             nfdump is a set of tools for working with netflow data.

     

       38
        
           '';

     

       39
        
           homepage = "https://github.com/phaag/nfdump";

     

       0
        
       
     

       40
        
           license = licenses.bsd3;

     

       41
       -
           maintainers = [ maintainers.takikawa ];

     

       42
        
           platforms = platforms.unix;

     

       43
        
         };

     

       44
        
       }

···

       1
       +
       { lib

     

       2
       +
       , stdenv

     

       3
       +
       , fetchFromGitHub

     

       4
       +
       , autoconf

     

       5
       +
       , automake

     

       6
       +
       , libtool

     

       7
       +
       , pkg-config

     

       8
       +
       , bzip2

     

       9
       +
       , libpcap

     

       10
       +
       , flex

     

       11
       +
       , bison

     

       12
       +
       }:

     

       13
        
       

     

       14
       +
       stdenv.mkDerivation rec {

     

       15
        
         pname = "nfdump";

     

       16
       +
         version = "1.7.1";

     

       17
        
       

     

       18
        
         src = fetchFromGitHub {

     

       19
        
           owner = "phaag";

     

       20
        
           repo = "nfdump";

     

       21
       +
           rev =  "refs/tags/v${version}";

     

       22
       +
           hash = "sha256-oCaJPx6+C0NQSuUcsP54sycNLt/zaqe5c81dwHNBcnQ=";

     

       23
        
         };

     

       24
        
       

     

       25
       +
         nativeBuildInputs = [

     

       26
       +
           autoconf

     

       27
       +
           automake

     

       28
       +
           flex

     

       29
       +
           libtool

     

       30
       +
           pkg-config

     

       31
       +
           bison

     

       32
       +
         ];

     

       33
       +
       

     

       34
       +
         buildInputs = [

     

       35
       +
           bzip2

     

       36
       +
           libpcap

     

       37
       +
         ];

     

       38
        
       

     

       39
        
         preConfigure = ''

     

       40
        
           # The script defaults to glibtoolize on darwin, so we pass the correct

     
···

       55
        
             nfdump is a set of tools for working with netflow data.

     

       56
        
           '';

     

       57
        
           homepage = "https://github.com/phaag/nfdump";

     

       58
       +
           changelog = "https://github.com/phaag/nfdump/releases/tag/v${version}";

     

       59
        
           license = licenses.bsd3;

     

       60
       +
           maintainers = with maintainers; [ takikawa ];

     

       61
        
           platforms = platforms.unix;

     

       62
        
         };

     

       63
        
       }

+2 -2

pkgs/tools/security/mitmproxy2swagger/default.nix

···

       5
        
       

     

       6
        
       python3.pkgs.buildPythonApplication rec {

     

       7
        
         pname = "mitmproxy2swagger";

     

       8
       -
         version = "0.7.1";

     

       9
        
         format = "pyproject";

     

       10
        
       

     

       11
        
         src = fetchFromGitHub {

     

       12
        
           owner = "alufers";

     

       13
        
           repo = pname;

     

       14
        
           rev = "refs/tags/${version}";

     

       15
       -
           hash = "sha256-morBtuRZZ/d3ye8aB+m2dSwWoaF3JJ92c+CgF71MqH4=";

     

       16
        
         };

     

       17
        
       

     

       18
        
         nativeBuildInputs = with python3.pkgs; [

···

       5
        
       

     

       6
        
       python3.pkgs.buildPythonApplication rec {

     

       7
        
         pname = "mitmproxy2swagger";

     

       8
       +
         version = "0.7.2";

     

       9
        
         format = "pyproject";

     

       10
        
       

     

       11
        
         src = fetchFromGitHub {

     

       12
        
           owner = "alufers";

     

       13
        
           repo = pname;

     

       14
        
           rev = "refs/tags/${version}";

     

       15
       +
           hash = "sha256-LnH0RDiRYJAGI7ZT6Idu1AqSz0yBRuBJvhIgY72Z4CA=";

     

       16
        
         };

     

       17
        
       

     

       18
        
         nativeBuildInputs = with python3.pkgs; [

+25 -35

pkgs/tools/security/trufflehog/default.nix

···

       1
        
       { lib

     

       2
       -
       , python3Packages

     

       0
        
       
     

       3
        
       }:

     

       4
        
       

     

       5
       -
       let

     

       6
       -
         truffleHogRegexes = python3Packages.buildPythonPackage rec {

     

       7
       -
           pname = "truffleHogRegexes";

     

       8
       -
           version = "0.0.7";

     

       9
       -
           src = python3Packages.fetchPypi {

     

       10
       -
             inherit pname version;

     

       11
       -
             sha256 = "b81dfc60c86c1e353f436a0e201fd88edb72d5a574615a7858485c59edf32405";

     

       12
       -
           };

     

       13
       -
         };

     

       14
       -
       in

     

       15
       -
         python3Packages.buildPythonApplication rec {

     

       16
       -
           pname = "truffleHog";

     

       17
       -
           version = "2.2.1";

     

       18
        
       

     

       19
       -
           src = python3Packages.fetchPypi {

     

       20
       -
             inherit pname version;

     

       21
       -
             hash = "sha256-fw0JyM2iqQrkL4FAXllEozJdkKWELS3eAURx5NZcceQ=";

     

       22
       -
           };

     

       0
        
       
     

       0
        
       
     

       23
        
       

     

       24
       -
           # Relax overly restricted version constraint

     

       25
       -
           postPatch = ''

     

       26
       -
             substituteInPlace setup.py --replace "GitPython ==" "GitPython >= "

     

       27
       -
           '';

     

       28
        
       

     

       29
       -
           propagatedBuildInputs = [

     

       30
       -
             python3Packages.gitpython

     

       31
       -
             truffleHogRegexes

     

       32
       -
           ];

     

       33
        
       

     

       34
       -
           # Test cases run git clone and require network access

     

       35
       -
           doCheck = false;

     

       0
        
       
     

       36
        
       

     

       37
       -
           meta = with lib; {

     

       38
       -
             homepage = "https://github.com/dxa4481/truffleHog";

     

       39
       -
             description = "Searches through git repositories for high entropy strings and secrets, digging deep into commit history";

     

       40
       -
             license = with licenses; [ gpl2 ];

     

       41
       -
             maintainers = with maintainers; [ bhipple ];

     

       42
       -
           };

     

       43
       -
         }

     

       0

···

       1
        
       { lib

     

       2
       +
       , fetchFromGitHub

     

       3
       +
       , buildGoModule

     

       4
        
       }:

     

       5
        
       

     

       6
       +
       buildGoModule rec {

     

       7
       +
         pname = "trufflehog";

     

       8
       +
         version = "3.21.0";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       9
        
       

     

       10
       +
         src = fetchFromGitHub {

     

       11
       +
           owner = "trufflesecurity";

     

       12
       +
           repo = "trufflehog";

     

       13
       +
           rev = "refs/tags/v${version}";

     

       14
       +
           hash = "sha256-rse5uyQ7EUBhs0IyC92B/Z7YCeNIXTlZEqrlcjFekgA=";

     

       15
       +
         };

     

       16
        
       

     

       17
       +
         vendorHash = "sha256-KyyJ7hUWF29L8oB9GkJ918/BQoLMsz+tStT2T9Azunk=";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
       

     

       19
       +
         # Test cases run git clone and require network access

     

       20
       +
         doCheck = false;

     

       0
        
       
     

       0
        
       
     

       21
        
       

     

       22
       +
         postInstall = ''

     

       23
       +
           rm $out/bin/{generate,snifftest}

     

       24
       +
         '';

     

       25
        
       

     

       26
       +
         meta = with lib; {

     

       27
       +
           description = "Find credentials all over the place";

     

       28
       +
           homepage = "https://github.com/trufflesecurity/trufflehog";

     

       29
       +
           changelog = "https://github.com/trufflesecurity/trufflehog/releases/tag/v${version}";

     

       30
       +
           license = with licenses; [ agpl3 ];

     

       31
       +
           maintainers = with maintainers; [ ];

     

       32
       +
         };

     

       33
       +
       }

pkgs/top-level/all-packages.nix

···

       30192
        
       

     

       30193
        
         kdeltachat = libsForQt5.callPackage ../applications/networking/instant-messengers/kdeltachat { };

     

       30194
        
       

     

       0
        
       
     

       0
        
       
     

       30195
        
         kepubify = callPackage ../tools/misc/kepubify { };

     

       30196
        
       

     

       30197
        
         kermit = callPackage ../tools/misc/kermit { };

···

       30192
        
       

     

       30193
        
         kdeltachat = libsForQt5.callPackage ../applications/networking/instant-messengers/kdeltachat { };

     

       30194
        
       

     

       30195
       +
         keet = callPackage ../applications/networking/instant-messengers/keet { };

     

       30196
       +
       

     

       30197
        
         kepubify = callPackage ../tools/misc/kepubify { };

     

       30198
        
       

     

       30199
        
         kermit = callPackage ../tools/misc/kermit { };

+3 -3

pkgs/top-level/haskell-packages.nix

···

       277
        
             # https://github.com/xattr/xattr/issues/44 and

     

       278
        
             # https://github.com/xattr/xattr/issues/55 are solved.

     

       279
        
             inherit (buildPackages.darwin) xattr autoSignDarwinBinariesHook;

     

       280
       -
             # 2022-08-04: Support range >= 10 && < 14

     

       281
       -
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       282
       -
             llvmPackages = pkgs.llvmPackages_12;

     

       283
        
           };

     

       284
        
       

     

       285
        
           ghcjs = compiler.ghcjs810;

···

       277
        
             # https://github.com/xattr/xattr/issues/44 and

     

       278
        
             # https://github.com/xattr/xattr/issues/55 are solved.

     

       279
        
             inherit (buildPackages.darwin) xattr autoSignDarwinBinariesHook;

     

       280
       +
             # 2022-08-04: Support range >= 10 && < 15

     

       281
       +
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_14;

     

       282
       +
             llvmPackages = pkgs.llvmPackages_14;

     

       283
        
           };

     

       284
        
       

     

       285
        
           ghcjs = compiler.ghcjs810;