commit c83cfc58e584b2a84fe6e7668620214d40e256f5 · pyrox.dev/nixpkgs

+1 -1

nixos/modules/misc/locate.nix

···

       157
        
       

     

       158
        
           pruneNames = mkOption {

     

       159
        
             type = listOf str;

     

       160
       -
             default = [];

     

       161
        
             description = ''

     

       162
        
               Directory components which should exclude paths containing them from indexing

     

       163
        
             '';

···

       157
        
       

     

       158
        
           pruneNames = mkOption {

     

       159
        
             type = listOf str;

     

       160
       +
             default = [ ".bzr" ".cache" ".git" ".hg" ".svn" ];

     

       161
        
             description = ''

     

       162
        
               Directory components which should exclude paths containing them from indexing

     

       163
        
             '';

nixos/modules/profiles/base.nix

···

       40
        
           # Tools to create / manipulate filesystems.

     

       41
        
           pkgs.ntfsprogs # for resizing NTFS partitions

     

       42
        
           pkgs.dosfstools

     

       0
        
       
     

       43
        
           pkgs.xfsprogs.bin

     

       44
        
           pkgs.jfsutils

     

       45
        
           pkgs.f2fs-tools

···

       40
        
           # Tools to create / manipulate filesystems.

     

       41
        
           pkgs.ntfsprogs # for resizing NTFS partitions

     

       42
        
           pkgs.dosfstools

     

       43
       +
           pkgs.mtools

     

       44
        
           pkgs.xfsprogs.bin

     

       45
        
           pkgs.jfsutils

     

       46
        
           pkgs.f2fs-tools

nixos/modules/services/monitoring/cadvisor.nix

···

       111
        
               wantedBy = [ "multi-user.target" ];

     

       112
        
               after = [ "network.target" "docker.service" "influxdb.service" ];

     

       113
        
       

     

       0
        
       
     

       0
        
       
     

       114
        
               postStart = mkBefore ''

     

       115
        
                 until ${pkgs.curl.bin}/bin/curl -s -o /dev/null 'http://${cfg.listenAddress}:${toString cfg.port}/containers/'; do

     

       116
        
                   sleep 1;

···

       111
        
               wantedBy = [ "multi-user.target" ];

     

       112
        
               after = [ "network.target" "docker.service" "influxdb.service" ];

     

       113
        
       

     

       114
       +
               path = optionals config.boot.zfs.enabled [ pkgs.zfs ];

     

       115
       +
       

     

       116
        
               postStart = mkBefore ''

     

       117
        
                 until ${pkgs.curl.bin}/bin/curl -s -o /dev/null 'http://${cfg.listenAddress}:${toString cfg.port}/containers/'; do

     

       118
        
                   sleep 1;

+10 -5

nixos/modules/services/x11/hardware/libinput.nix

···

       13
        
               example = "/dev/input/event0";

     

       14
        
               description =

     

       15
        
                 ''

     

       16
       -
                   Path for ${deviceType} device.  Set to null to apply to any

     

       17
        
                   auto-detected ${deviceType}.

     

       18
        
                 '';

     

       19
        
             };

     
···

       24
        
               example = "flat";

     

       25
        
               description =

     

       26
        
                 ''

     

       27
       -
                   Sets  the pointer acceleration profile to the given profile.

     

       28
       -
                   Permitted values are adaptive, flat.

     

       29
        
                   Not all devices support this option or all profiles.

     

       30
        
                   If a profile is unsupported, the default profile for this is used.

     

       31
        
                   <literal>flat</literal>: Pointer motion is accelerated by a constant

     
···

       38
        
             accelSpeed = mkOption {

     

       39
        
               type = types.nullOr types.str;

     

       40
        
               default = null;

     

       0
        
       
     

       41
        
               description = "Cursor acceleration (how fast speed increases from minSpeed to maxSpeed).";

     

       42
        
             };

     

       43
        
       

     

       44
        
             buttonMapping = mkOption {

     

       45
        
               type = types.nullOr types.str;

     

       46
        
               default = null;

     

       0
        
       
     

       47
        
               description =

     

       48
        
                 ''

     

       49
        
                   Sets the logical button mapping for this device, see XSetPointerMapping(3). The string  must

     
···

       58
        
             calibrationMatrix = mkOption {

     

       59
        
               type = types.nullOr types.str;

     

       60
        
               default = null;

     

       0
        
       
     

       61
        
               description =

     

       62
        
                 ''

     

       63
       -
                   A  string  of  9 space-separated floating point numbers.  Sets the calibration matrix to the

     

       64
        
                   3x3 matrix where the first row is (abc), the second row is (def) and the third row is (ghi).

     

       65
        
                 '';

     

       66
        
             };

     
···

       68
        
             clickMethod = mkOption {

     

       69
        
               type = types.nullOr (types.enum [ "none" "buttonareas" "clickfinger" ]);

     

       70
        
               default = null;

     

       0
        
       
     

       71
        
               description =

     

       72
        
                 ''

     

       73
        
                   Enables a click method. Permitted values are <literal>none</literal>,

     
···

       166
        
             transformationMatrix = mkOption {

     

       167
        
               type = types.nullOr types.str;

     

       168
        
               default = null;

     

       0
        
       
     

       169
        
               description = ''

     

       170
       -
                 A  string  of  9 space-separated floating point numbers.  Sets the transformation matrix to

     

       171
        
                 the 3x3 matrix where the first row is (abc), the second row is (def) and the third row is (ghi).

     

       172
        
               '';

     

       173
        
             };

···

       13
        
               example = "/dev/input/event0";

     

       14
        
               description =

     

       15
        
                 ''

     

       16
       +
                   Path for ${deviceType} device.  Set to <literal>null</literal> to apply to any

     

       17
        
                   auto-detected ${deviceType}.

     

       18
        
                 '';

     

       19
        
             };

     
···

       24
        
               example = "flat";

     

       25
        
               description =

     

       26
        
                 ''

     

       27
       +
                   Sets the pointer acceleration profile to the given profile.

     

       28
       +
                   Permitted values are <literal>adaptive</literal>, <literal>flat</literal>.

     

       29
        
                   Not all devices support this option or all profiles.

     

       30
        
                   If a profile is unsupported, the default profile for this is used.

     

       31
        
                   <literal>flat</literal>: Pointer motion is accelerated by a constant

     
···

       38
        
             accelSpeed = mkOption {

     

       39
        
               type = types.nullOr types.str;

     

       40
        
               default = null;

     

       41
       +
               example = "-0.5";

     

       42
        
               description = "Cursor acceleration (how fast speed increases from minSpeed to maxSpeed).";

     

       43
        
             };

     

       44
        
       

     

       45
        
             buttonMapping = mkOption {

     

       46
        
               type = types.nullOr types.str;

     

       47
        
               default = null;

     

       48
       +
               example = "1 6 3 4 5 0 7";

     

       49
        
               description =

     

       50
        
                 ''

     

       51
        
                   Sets the logical button mapping for this device, see XSetPointerMapping(3). The string  must

     
···

       60
        
             calibrationMatrix = mkOption {

     

       61
        
               type = types.nullOr types.str;

     

       62
        
               default = null;

     

       63
       +
               example = "0.5 0 0 0 0.8 0.1 0 0 1";

     

       64
        
               description =

     

       65
        
                 ''

     

       66
       +
                   A string of 9 space-separated floating point numbers. Sets the calibration matrix to the

     

       67
        
                   3x3 matrix where the first row is (abc), the second row is (def) and the third row is (ghi).

     

       68
        
                 '';

     

       69
        
             };

     
···

       71
        
             clickMethod = mkOption {

     

       72
        
               type = types.nullOr (types.enum [ "none" "buttonareas" "clickfinger" ]);

     

       73
        
               default = null;

     

       74
       +
               example = "buttonareas";

     

       75
        
               description =

     

       76
        
                 ''

     

       77
        
                   Enables a click method. Permitted values are <literal>none</literal>,

     
···

       170
        
             transformationMatrix = mkOption {

     

       171
        
               type = types.nullOr types.str;

     

       172
        
               default = null;

     

       173
       +
               example = "0.5 0 0 0 0.8 0.1 0 0 1";

     

       174
        
               description = ''

     

       175
       +
                 A string of 9 space-separated floating point numbers. Sets the transformation matrix to

     

       176
        
                 the 3x3 matrix where the first row is (abc), the second row is (def) and the third row is (ghi).

     

       177
        
               '';

     

       178
        
             };

+1 -1

nixos/modules/virtualisation/qemu-vm.nix

···

       306
        
           virtualisation.msize =

     

       307
        
             mkOption {

     

       308
        
               type = types.ints.positive;

     

       309
       -
               default = 16384;

     

       310
        
               description =

     

       311
        
                 ''

     

       312
        
                   The msize (maximum packet size) option passed to 9p file systems, in

···

       306
        
           virtualisation.msize =

     

       307
        
             mkOption {

     

       308
        
               type = types.ints.positive;

     

       309
       +
               default = pkgs.vmTools.default9PMsizeBytes;

     

       310
        
               description =

     

       311
        
                 ''

     

       312
        
                   The msize (maximum packet size) option passed to 9p file systems, in

+2 -1

nixos/tests/all-tests.nix

···

       228
        
         kubernetes = handleTestOn ["x86_64-linux"] ./kubernetes {};

     

       229
        
         latestKernel.login = handleTest ./login.nix { latestKernel = true; };

     

       230
        
         leaps = handleTest ./leaps.nix {};

     

       0
        
       
     

       231
        
         libreddit = handleTest ./libreddit.nix {};

     

       0
        
       
     

       232
        
         lidarr = handleTest ./lidarr.nix {};

     

       233
       -
         libreswan = handleTest ./libreswan.nix {};

     

       234
        
         lightdm = handleTest ./lightdm.nix {};

     

       235
        
         limesurvey = handleTest ./limesurvey.nix {};

     

       236
        
         litestream = handleTest ./litestream.nix {};

···

       228
        
         kubernetes = handleTestOn ["x86_64-linux"] ./kubernetes {};

     

       229
        
         latestKernel.login = handleTest ./login.nix { latestKernel = true; };

     

       230
        
         leaps = handleTest ./leaps.nix {};

     

       231
       +
         libinput = handleTest ./libinput.nix {};

     

       232
        
         libreddit = handleTest ./libreddit.nix {};

     

       233
       +
         libreswan = handleTest ./libreswan.nix {};

     

       234
        
         lidarr = handleTest ./lidarr.nix {};

     

       0
        
       
     

       235
        
         lightdm = handleTest ./lightdm.nix {};

     

       236
        
         limesurvey = handleTest ./limesurvey.nix {};

     

       237
        
         litestream = handleTest ./litestream.nix {};

+38

nixos/tests/libinput.nix

···

       1
       +
       import ./make-test-python.nix ({ ... }:

     

       2
       +
       

     

       3
       +
       {

     

       4
       +
         name = "libinput";

     

       5
       +
       

     

       6
       +
         machine = { ... }:

     

       7
       +
           {

     

       8
       +
             imports = [

     

       9
       +
               ./common/x11.nix

     

       10
       +
               ./common/user-account.nix

     

       11
       +
             ];

     

       12
       +
       

     

       13
       +
             test-support.displayManager.auto.user = "alice";

     

       14
       +
       

     

       15
       +
             services.xserver.libinput = {

     

       16
       +
               enable = true;

     

       17
       +
               mouse = {

     

       18
       +
                 naturalScrolling = true;

     

       19
       +
                 leftHanded = true;

     

       20
       +
                 middleEmulation = false;

     

       21
       +
                 horizontalScrolling = false;

     

       22
       +
               };

     

       23
       +
             };

     

       24
       +
           };

     

       25
       +
       

     

       26
       +
         testScript = ''

     

       27
       +
           def expect_xserver_option(option, value):

     

       28
       +
               machine.succeed(f"""cat /var/log/X.0.log | grep -F 'Option "{option}" "{value}"'""")

     

       29
       +
       

     

       30
       +
           machine.start()

     

       31
       +
           machine.wait_for_x()

     

       32
       +
           machine.succeed("""cat /var/log/X.0.log | grep -F "Using input driver 'libinput'" """)

     

       33
       +
           expect_xserver_option("NaturalScrolling", "on")

     

       34
       +
           expect_xserver_option("LeftHanded", "on")

     

       35
       +
           expect_xserver_option("MiddleEmulation", "off")

     

       36
       +
           expect_xserver_option("HorizontalScrolling", "off")

     

       37
       +
         '';

     

       38
       +
       })

+2 -4

pkgs/applications/blockchains/clightning/default.nix

···

       39
        
             devtools/sql-rewrite.py

     

       40
        
         '';

     

       41
        
       

     

       42
       -
         configurePhase = ''

     

       43
       -
           ./configure --prefix=$out --disable-developer --disable-valgrind

     

       44
       -
         '';

     

       45
        
       

     

       46
       -
         makeFlags = [ "prefix=$(out) VERSION=v${version}" ];

     

       47
        
       

     

       48
        
         enableParallelBuilding = true;

     

       49

···

       39
        
             devtools/sql-rewrite.py

     

       40
        
         '';

     

       41
        
       

     

       42
       +
         configureFlags = [ "--disable-developer" "--disable-valgrind" ];

     

       0
        
       
     

       0
        
       
     

       43
        
       

     

       44
       +
         makeFlags = [ "VERSION=v${version}" ];

     

       45
        
       

     

       46
        
         enableParallelBuilding = true;

     

       47

+2 -2

pkgs/applications/blockchains/ledger-live-desktop/default.nix

···

       2
        
       

     

       3
        
       let

     

       4
        
         pname = "ledger-live-desktop";

     

       5
       -
         version = "2.35.0";

     

       6
        
         name = "${pname}-${version}";

     

       7
        
       

     

       8
        
         src = fetchurl {

     

       9
        
           url = "https://github.com/LedgerHQ/${pname}/releases/download/v${version}/${pname}-${version}-linux-x86_64.AppImage";

     

       10
       -
           hash = "sha256-o2XGBTqyHqQ/yq54B0GBFEk35Zxt2ZWGZCTjbEbKqiw=";

     

       11
        
         };

     

       12
        
       

     

       13
        
         appimageContents = appimageTools.extractType2 {

···

       2
        
       

     

       3
        
       let

     

       4
        
         pname = "ledger-live-desktop";

     

       5
       +
         version = "2.35.1";

     

       6
        
         name = "${pname}-${version}";

     

       7
        
       

     

       8
        
         src = fetchurl {

     

       9
        
           url = "https://github.com/LedgerHQ/${pname}/releases/download/v${version}/${pname}-${version}-linux-x86_64.AppImage";

     

       10
       +
           hash = "sha256:0z60c4sjq63r5rs95rbv7afliia05l1p9bgfd5zv7i51qxgzfs4a";

     

       11
        
         };

     

       12
        
       

     

       13
        
         appimageContents = appimageTools.extractType2 {

+3 -3

pkgs/applications/misc/gpxsee/default.nix

···

       2
        
       

     

       3
        
       mkDerivation rec {

     

       4
        
         pname = "gpxsee";

     

       5
       -
         version = "9.11";

     

       6
        
       

     

       7
        
         src = fetchFromGitHub {

     

       8
        
           owner = "tumic0";

     

       9
        
           repo = "GPXSee";

     

       10
        
           rev = version;

     

       11
       -
           sha256 = "sha256-5FGdcmkVOxjDngVQIlXnH3OPRMjaixqJ2Xb239usUuo=";

     

       12
        
         };

     

       13
        
       

     

       14
        
         patches = (substituteAll {

     
···

       23
        
           lrelease gpxsee.pro

     

       24
        
         '';

     

       25
        
       

     

       26
       -
         postInstall = with stdenv; lib.optionalString isDarwin ''

     

       27
        
           mkdir -p $out/Applications

     

       28
        
           mv GPXSee.app $out/Applications

     

       29
        
         '';

···

       2
        
       

     

       3
        
       mkDerivation rec {

     

       4
        
         pname = "gpxsee";

     

       5
       +
         version = "9.12";

     

       6
        
       

     

       7
        
         src = fetchFromGitHub {

     

       8
        
           owner = "tumic0";

     

       9
        
           repo = "GPXSee";

     

       10
        
           rev = version;

     

       11
       +
           sha256 = "sha256-hIDphwmS4UNSTvE+Icupipo6AmT2fiPdaufT/I3EeJ4=";

     

       12
        
         };

     

       13
        
       

     

       14
        
         patches = (substituteAll {

     
···

       23
        
           lrelease gpxsee.pro

     

       24
        
         '';

     

       25
        
       

     

       26
       +
         postInstall = lib.optionalString stdenv.isDarwin ''

     

       27
        
           mkdir -p $out/Applications

     

       28
        
           mv GPXSee.app $out/Applications

     

       29
        
         '';

+6 -1

pkgs/applications/misc/ulauncher/default.nix

···

       33
        
           distutils_extra

     

       34
        
           intltool

     

       35
        
           wrapGAppsHook

     

       0
        
       
     

       36
        
         ];

     

       37
        
       

     

       38
        
         buildInputs = [

     
···

       58
        
           pyinotify

     

       59
        
           python-Levenshtein

     

       60
        
           pyxdg

     

       0
        
       
     

       61
        
           requests

     

       62
        
           websocket-client

     

       63
        
         ];

     
···

       105
        
         # do not double wrap

     

       106
        
         dontWrapGApps = true;

     

       107
        
         preFixup = ''

     

       108
       -
           makeWrapperArgs+=("''${gappsWrapperArgs[@]}" --prefix PATH : "${lib.makeBinPath [ wmctrl ]}")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       109
        
         '';

     

       110
        
       

     

       111
        
         passthru = {

···

       33
        
           distutils_extra

     

       34
        
           intltool

     

       35
        
           wrapGAppsHook

     

       36
       +
           gdk-pixbuf

     

       37
        
         ];

     

       38
        
       

     

       39
        
         buildInputs = [

     
···

       59
        
           pyinotify

     

       60
        
           python-Levenshtein

     

       61
        
           pyxdg

     

       62
       +
           pycairo

     

       63
        
           requests

     

       64
        
           websocket-client

     

       65
        
         ];

     
···

       107
        
         # do not double wrap

     

       108
        
         dontWrapGApps = true;

     

       109
        
         preFixup = ''

     

       110
       +
           makeWrapperArgs+=(

     

       111
       +
            "''${gappsWrapperArgs[@]}"

     

       112
       +
            --prefix PATH : "${lib.makeBinPath [ wmctrl ]}"

     

       113
       +
           )

     

       114
        
         '';

     

       115
        
       

     

       116
        
         passthru = {

+19 -14

pkgs/applications/networking/cluster/terraform-providers/providers.json

···

       229
        
           "version": "0.1.0"

     

       230
        
         },

     

       231
        
         "consul": {

     

       232
       -
           "owner": "terraform-providers",

     

       233
        
           "provider-source-address": "registry.terraform.io/hashicorp/consul",

     

       234
        
           "repo": "terraform-provider-consul",

     

       235
       -
           "rev": "v2.8.0",

     

       236
       -
           "sha256": "1brd0fp9ksc3x8cygxm0k2q1sh4v5x89298pnidg6xirn41lvcr4",

     

       237
       -
           "version": "2.8.0"

     

       0
        
       
     

       238
        
         },

     

       239
        
         "ct": {

     

       240
        
           "owner": "poseidon",

     
···

       362
        
           "version": "1.1.0"

     

       363
        
         },

     

       364
        
         "github": {

     

       365
       -
           "owner": "terraform-providers",

     

       0
        
       
     

       366
        
           "repo": "terraform-provider-github",

     

       367
       -
           "rev": "v3.1.0",

     

       368
       -
           "sha256": "1xl4fd1lfbn1vnrdmg2xljnv8hy6rmf0iv7g8pzbnzbvj2pi7w3b",

     

       369
       -
           "version": "3.1.0"

     

       0
        
       
     

       370
        
         },

     

       371
        
         "gitlab": {

     

       372
        
           "owner": "gitlabhq",

     
···

       687
        
           "version": "0.0.1"

     

       688
        
         },

     

       689
        
         "nomad": {

     

       690
       -
           "owner": "terraform-providers",

     

       0
        
       
     

       691
        
           "repo": "terraform-provider-nomad",

     

       692
       -
           "rev": "v1.4.5",

     

       693
       -
           "sha256": "1sccm4mspjn92ky6nscsrmbb573mx53wzsvvapsf2p4119h9s30i",

     

       694
       -
           "version": "1.4.5"

     

       0
        
       
     

       695
        
         },

     

       696
        
         "ns1": {

     

       697
        
           "owner": "terraform-providers",

     
···

       1109
        
           "repo": "terraform-provider-vault",

     

       1110
        
           "rev": "v2.24.1",

     

       1111
        
           "sha256": "1xk14q06js774lqyylkbp53dnlsbgh3vi38mqqmndh80xigs6d99",

     

       1112
       -
           "version": "2.24.1",

     

       1113
       -
           "vendorSha256": "1ksla455qfgxpk2dmq3pg52nyyw3v0bg6fm5s60j6cb0lzvjbq48"

     

       1114
        
         },

     

       1115
        
         "vcd": {

     

       1116
        
           "owner": "terraform-providers",

···

       229
        
           "version": "0.1.0"

     

       230
        
         },

     

       231
        
         "consul": {

     

       232
       +
           "owner": "hashicorp",

     

       233
        
           "provider-source-address": "registry.terraform.io/hashicorp/consul",

     

       234
        
           "repo": "terraform-provider-consul",

     

       235
       +
           "rev": "v2.14.0",

     

       236
       +
           "sha256": "19kmjjg4f74askwwwslbh5wvi5ndcr4wzm0374qr8gc57qiwxkpy",

     

       237
       +
           "vendorSha256": null,

     

       238
       +
           "version": "2.14.0"

     

       239
        
         },

     

       240
        
         "ct": {

     

       241
        
           "owner": "poseidon",

     
···

       363
        
           "version": "1.1.0"

     

       364
        
         },

     

       365
        
         "github": {

     

       366
       +
           "owner": "integrations",

     

       367
       +
           "provider-source-address": "registry.terraform.io/integrations/github",

     

       368
        
           "repo": "terraform-provider-github",

     

       369
       +
           "rev": "v4.18.0",

     

       370
       +
           "sha256": "0vr7vxlpq1lbp85qm2084w7mqkz5yp7gxj5ln29plhm7xjpd87bp",

     

       371
       +
           "vendorSha256": null,

     

       372
       +
           "version": "4.18.0"

     

       373
        
         },

     

       374
        
         "gitlab": {

     

       375
        
           "owner": "gitlabhq",

     
···

       690
        
           "version": "0.0.1"

     

       691
        
         },

     

       692
        
         "nomad": {

     

       693
       +
           "owner": "hashicorp",

     

       694
       +
           "provider-source-address": "registry.terraform.io/hashicorp/nomad",

     

       695
        
           "repo": "terraform-provider-nomad",

     

       696
       +
           "rev": "v1.4.15",

     

       697
       +
           "sha256": "18rrvp7h27f51di8hajl2jb53v7wadqv4241rxdx1d180fas69k1",

     

       698
       +
           "vendorSha256": "1y5wpilnqn17zbi88z23159gx2p57a9c10ajb7gn9isbxfdqj9mb",

     

       699
       +
           "version": "1.4.15"

     

       700
        
         },

     

       701
        
         "ns1": {

     

       702
        
           "owner": "terraform-providers",

     
···

       1114
        
           "repo": "terraform-provider-vault",

     

       1115
        
           "rev": "v2.24.1",

     

       1116
        
           "sha256": "1xk14q06js774lqyylkbp53dnlsbgh3vi38mqqmndh80xigs6d99",

     

       1117
       +
           "vendorSha256": "1ksla455qfgxpk2dmq3pg52nyyw3v0bg6fm5s60j6cb0lzvjbq48",

     

       1118
       +
           "version": "2.24.1"

     

       1119
        
         },

     

       1120
        
         "vcd": {

     

       1121
        
           "owner": "terraform-providers",

+1 -1

pkgs/applications/networking/cluster/terraform-providers/update-provider

···

       165
        
           vendorSha256=$(echo "${BASH_REMATCH[1]#sha256:}" | head -n 1)

     

       166
        
           # Deal with nix unstable

     

       167
        
           if [[ $vendorSha256 = sha256-* ]]; then

     

       168
       -
             vendorSha256=$(nix to-base32 "$vendorSha256")

     

       169
        
           fi

     

       170
        
         fi

     

       171
        
       fi

···

       165
        
           vendorSha256=$(echo "${BASH_REMATCH[1]#sha256:}" | head -n 1)

     

       166
        
           # Deal with nix unstable

     

       167
        
           if [[ $vendorSha256 = sha256-* ]]; then

     

       168
       +
             vendorSha256=$(nix --extra-experimental-features nix-command hash to-base32 "$vendorSha256")

     

       169
        
           fi

     

       170
        
         fi

     

       171
        
       fi

+27

pkgs/applications/networking/instant-messengers/pidgin-plugins/purple-googlechat/default.nix

···

       1
       +
       { lib, stdenv, fetchFromGitHub, pidgin, glib, json-glib, protobuf, protobufc }:

     

       2
       +
       

     

       3
       +
       stdenv.mkDerivation {

     

       4
       +
         pname = "purple-googlechat";

     

       5
       +
         version = "unstable-2021-10-18";

     

       6
       +
       

     

       7
       +
         src = fetchFromGitHub {

     

       8
       +
           owner = "EionRobb";

     

       9
       +
           repo = "purple-googlechat";

     

       10
       +
           rev = "56ba7f79883eca67d37629d365776f6c0b40abdc";

     

       11
       +
           sha256 = "sha256-iTYVgYI9+6rqqBl5goeEAXpK8FgHDv0MmPsV/82reWA=";

     

       12
       +
         };

     

       13
       +
       

     

       14
       +
         nativeBuildInputs = [ protobufc ];

     

       15
       +
         buildInputs = [ pidgin glib json-glib protobuf ];

     

       16
       +
       

     

       17
       +
         PKG_CONFIG_PURPLE_PLUGINDIR = "${placeholder "out"}/lib/purple-2";

     

       18
       +
         PKG_CONFIG_PURPLE_DATADIR = "${placeholder "out"}/share";

     

       19
       +
       

     

       20
       +
         meta = with lib; {

     

       21
       +
           homepage = "https://github.com/EionRobb/purple-googlechat";

     

       22
       +
           description = "Native Google Chat support for pidgin";

     

       23
       +
           license = licenses.gpl3Plus;

     

       24
       +
           platforms = platforms.linux;

     

       25
       +
           maintainers = with maintainers; [ dtzWill ];

     

       26
       +
         };

     

       27
       +
       }

+7 -2

pkgs/build-support/vm/default.nix

···

       110
        
       

     

       111
        
           echo "mounting Nix store..."

     

       112
        
           mkdir -p /fs${storeDir}

     

       113
       -
           mount -t 9p store /fs${storeDir} -o trans=virtio,version=9p2000.L,cache=loose

     

       114
        
       

     

       115
        
           mkdir -p /fs/tmp /fs/run /fs/var

     

       116
        
           mount -t tmpfs -o "mode=1777" none /fs/tmp

     
···

       119
        
       

     

       120
        
           echo "mounting host's temporary directory..."

     

       121
        
           mkdir -p /fs/tmp/xchg

     

       122
       -
           mount -t 9p xchg /fs/tmp/xchg -o trans=virtio,version=9p2000.L

     

       123
        
       

     

       124
        
           mkdir -p /fs/proc

     

       125
        
           mount -t proc none /fs/proc

     
···

       1174
        
            `debDistros' sets. */

     

       1175
        
         diskImages = lib.mapAttrs (name: f: f {}) diskImageFuns;

     

       1176
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1177
        
       }

···

       110
        
       

     

       111
        
           echo "mounting Nix store..."

     

       112
        
           mkdir -p /fs${storeDir}

     

       113
       +
           mount -t 9p store /fs${storeDir} -o trans=virtio,version=9p2000.L,cache=loose,msize=${toString default9PMsizeBytes}

     

       114
        
       

     

       115
        
           mkdir -p /fs/tmp /fs/run /fs/var

     

       116
        
           mount -t tmpfs -o "mode=1777" none /fs/tmp

     
···

       119
        
       

     

       120
        
           echo "mounting host's temporary directory..."

     

       121
        
           mkdir -p /fs/tmp/xchg

     

       122
       +
           mount -t 9p xchg /fs/tmp/xchg -o trans=virtio,version=9p2000.L,msize=${toString default9PMsizeBytes}

     

       123
        
       

     

       124
        
           mkdir -p /fs/proc

     

       125
        
           mount -t proc none /fs/proc

     
···

       1174
        
            `debDistros' sets. */

     

       1175
        
         diskImages = lib.mapAttrs (name: f: f {}) diskImageFuns;

     

       1176
        
       

     

       1177
       +
         # The default 9P msize value is 8 KiB, which according to QEMU is

     

       1178
       +
         # insufficient and would degrade performance.

     

       1179
       +
         # See: https://wiki.qemu.org/Documentation/9psetup#msize

     

       1180
       +
         # Use 500 KiB as a conservative default, see also https://github.com/NixOS/nixpkgs/pull/142577#issuecomment-953848731

     

       1181
       +
         default9PMsizeBytes = 512000;

     

       1182
        
       }

+4 -4

pkgs/data/misc/hackage/pin.json

···

       1
        
       {

     

       2
       -
         "commit": "da98cdcb5ec11aea3b1979174b3b1cab24014908",

     

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

     

       4
       -
         "sha256": "14qdmvlqkaixv331g1lfr8hghrvzdx45xhn69fz1g7zhv4w88jix",

     

       5
       -
         "msg": "Update from Hackage at 2021-11-05T06:34:09Z"

     

       6
        
       }

···

       1
        
       {

     

       2
       +
         "commit": "f38385b8e3e064360be513204f114418ea0206de",

     

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

     

       4
       +
         "sha256": "08yrxx2cslwbbrcrjn13va2vbynjrwfbkc3fs4mf9qc17bdvxmgj",

     

       5
       +
         "msg": "Update from Hackage at 2021-11-12T03:22:57Z"

     

       6
        
       }

+3 -3

pkgs/development/compilers/ghc/head.nix

···

       41
        
       , # Whether to build terminfo.

     

       42
        
         enableTerminfo ? !stdenv.targetPlatform.isWindows

     

       43
        
       

     

       44
       -
       , version ? "9.3.20210913"

     

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

     

       46
        
         # specific flavour and falls back to ghc default values.

     

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

     
···

       160
        
       

     

       161
        
         src = fetchgit {

     

       162
        
           url = "https://gitlab.haskell.org/ghc/ghc.git/";

     

       163
       -
           rev = "64923cf295ea914db458547432237a5ed1eff571";

     

       164
       -
           sha256 = "1s9sm4gf4r71lk0s7h9v217rxfwjf435q1jji90hlxz23wvmhr6d";

     

       165
        
         };

     

       166
        
       

     

       167
        
         enableParallelBuilding = true;

···

       41
        
       , # Whether to build terminfo.

     

       42
        
         enableTerminfo ? !stdenv.targetPlatform.isWindows

     

       43
        
       

     

       44
       +
       , version ? "9.3.20211111"

     

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

     

       46
        
         # specific flavour and falls back to ghc default values.

     

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

     
···

       160
        
       

     

       161
        
         src = fetchgit {

     

       162
        
           url = "https://gitlab.haskell.org/ghc/ghc.git/";

     

       163
       +
           rev = "cc635da167fdec2dead0603b0026cb841f0aa645";

     

       164
       +
           sha256 = "1lj76l546zriwkcn2r7i5a4j35bx9fh5iggwfz2xvhh8aq8j2i46";

     

       165
        
         };

     

       166
        
       

     

       167
        
         enableParallelBuilding = true;

+1 -1

pkgs/development/compilers/ghcjs/8.10/default.nix

···

       3
        
       , callPackage

     

       4
        
       , fetchgit

     

       5
        
       , ghcjsSrcJson ? null

     

       6
       -
       , ghcjsSrc ? fetchgit lib.importJSON ghcjsSrcJson

     

       7
        
       , bootPkgs

     

       8
        
       , stage0

     

       9
        
       , haskellLib

···

       3
        
       , callPackage

     

       4
        
       , fetchgit

     

       5
        
       , ghcjsSrcJson ? null

     

       6
       +
       , ghcjsSrc ? fetchgit (lib.importJSON ghcjsSrcJson)

     

       7
        
       , bootPkgs

     

       8
        
       , stage0

     

       9
        
       , haskellLib

+37 -26

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

···

       15
        
       

     

       16
        
       self: super: {

     

       17
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
         # Arion's test suite needs a Nixpkgs, which is cumbersome to do from Nixpkgs

     

       19
        
         # itself. For instance, pkgs.path has dirty sources and puts a huge .git in the

     

       20
        
         # store. Testing is done upstream.

     
···

       60
        
       

     

       61
        
         # The Hackage tarball is purposefully broken, because it's not intended to be, like, useful.

     

       62
        
         # https://git-annex.branchable.com/bugs/bash_completion_file_is_missing_in_the_6.20160527_tarball_on_hackage/

     

       63
       -
         git-annex = (overrideSrc {

     

       64
        
           src = pkgs.fetchgit {

     

       65
        
             name = "git-annex-${super.git-annex.version}-src";

     

       66
        
             url = "git://git-annex.branchable.com/";

     
···

       74
        
               rm -r $out/doc/?ndroid*

     

       75
        
             '';

     

       76
        
           };

     

       77
       -
         } super.git-annex).override {

     

       78
       -
           dbus = if pkgs.stdenv.isLinux then self.dbus else null;

     

       79
       -
           fdo-notify = if pkgs.stdenv.isLinux then self.fdo-notify else null;

     

       80
       -
           hinotify = if pkgs.stdenv.isLinux then self.hinotify else self.fsnotify;

     

       81
       -
         };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       82
        
       

     

       83
        
         # Fix test trying to access /home directory

     

       84
        
         shell-conduit = overrideCabal (drv: {

     
···

       844
        
       

     

       845
        
         # hledger-lib 1.23 depends on doctest >= 0.18

     

       846
        
         hledger-lib_1_23 = super.hledger-lib_1_23.override {

     

       847
       -
           doctest = self.doctest_0_18_1;

     

       848
        
         };

     

       849
        
       

     

       850
        
         # Copy hledger man pages from data directory into the proper place. This code

     
···

       1338
        
           resource-pool = self.hasura-resource-pool;

     

       1339
        
           ekg-core = self.hasura-ekg-core;

     

       1340
        
           ekg-json = self.hasura-ekg-json;

     

       1341
       -
           hspec = dontCheck self.hspec_2_8_3;

     

       1342
       -
           hspec-core = dontCheck self.hspec-core_2_8_3;

     

       1343
       -
           hspec-discover = dontCheck super.hspec-discover_2_8_3;

     

       1344
        
           tasty-hspec = self.tasty-hspec_1_2;

     

       1345
        
         }));

     

       1346
        
         hasura-ekg-core = super.hasura-ekg-core.overrideScope (self: super: {

     

       1347
       -
           hspec = dontCheck self.hspec_2_8_3;

     

       1348
       -
           hspec-core = dontCheck self.hspec-core_2_8_3;

     

       1349
       -
           hspec-discover = dontCheck super.hspec-discover_2_8_3;

     

       1350
        
         });

     

       1351
        
         hasura-ekg-json = super.hasura-ekg-json.overrideScope (self: super: {

     

       1352
        
           ekg-core = self.hasura-ekg-core;

     

       1353
       -
           hspec = dontCheck self.hspec_2_8_3;

     

       1354
       -
           hspec-core = dontCheck self.hspec-core_2_8_3;

     

       1355
       -
           hspec-discover = dontCheck super.hspec-discover_2_8_3;

     

       1356
        
         });

     

       1357
        
         pg-client = overrideCabal (drv: {

     

       1358
        
           librarySystemDepends = with pkgs; [ postgresql krb5.dev openssl.dev ];

     
···

       1427
        
         # 2021-09-14: Tests are broken because of undeterministic variable names

     

       1428
        
         hls-tactics-plugin = dontCheck super.hls-tactics-plugin;

     

       1429
        
       

     

       1430
       -
         # 2021-03-21 Test hangs

     

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

     

       1432
       -
         ghcide = dontCheck super.ghcide;

     

       0
        
       
     

       1433
        
       

     

       1434
        
         data-tree-print = doJailbreak super.data-tree-print;

     

       1435
        
       

     
···

       2070
        
         # file revision on hackage was gifted CRLF line endings

     

       2071
        
         gogol-core = appendPatch ./patches/gogol-core-144.patch super.gogol-core;

     

       2072
        
       

     

       2073
       -
         # 2021-11-05: patch to permit our language-docker version

     

       2074
       -
         # This is based on c931c0a9689cd6dff4d2083fa002414c1f08a586 from

     

       2075
       -
         # language-docker upstream

     

       2076
       -
         hadolint = appendPatch (pkgs.fetchpatch {

     

       2077
       -
           url = "https://github.com/hadolint/hadolint/commit/c931c0a9689cd6dff4d2083fa002414c1f08a586.patch";

     

       2078
       -
           sha256 = "1kv06hfn7lgrcrg56q8lq0pvdffqvmjbshazg3prlhl3kjs541f8";

     

       2079
       -
           excludes = [ "stack.yaml" "package.yaml" "hadolint.cabal" ];

     

       2080
       -
         }) (super.hadolint.override {

     

       2081
        
           language-docker = self.language-docker_10_3_0;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2082
        
         });

     

       2083
        
       

     

       2084
        
         # These should be updated in lockstep

     

       2085
        
         hledger_1_23 = super.hledger_1_23.override {

     

       2086
        
           hledger-lib = self.hledger-lib_1_23;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2087
        
         };

     

       2088
        
       

     

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

···

       15
        
       

     

       16
        
       self: super: {

     

       17
        
       

     

       18
       +
         # There are numerical tests on random data, that may fail occasionally

     

       19
       +
         lapack = dontCheck super.lapack;

     

       20
       +
       

     

       21
        
         # Arion's test suite needs a Nixpkgs, which is cumbersome to do from Nixpkgs

     

       22
        
         # itself. For instance, pkgs.path has dirty sources and puts a huge .git in the

     

       23
        
         # store. Testing is done upstream.

     
···

       63
        
       

     

       64
        
         # The Hackage tarball is purposefully broken, because it's not intended to be, like, useful.

     

       65
        
         # https://git-annex.branchable.com/bugs/bash_completion_file_is_missing_in_the_6.20160527_tarball_on_hackage/

     

       66
       +
         git-annex = overrideCabal (drv: {

     

       67
        
           src = pkgs.fetchgit {

     

       68
        
             name = "git-annex-${super.git-annex.version}-src";

     

       69
        
             url = "git://git-annex.branchable.com/";

     
···

       77
        
               rm -r $out/doc/?ndroid*

     

       78
        
             '';

     

       79
        
           };

     

       80
       +
           patches = [

     

       81
       +
             # Allows compilation with git-lfs 1.2.0

     

       82
       +
             (pkgs.fetchpatch {

     

       83
       +
               url = "https://git.joeyh.name/index.cgi/git-annex.git/patch/?id=f3326b8b5ae4d1caa5c6e3e192c58c6e064c425a";

     

       84
       +
               sha256 = "1nzg4mna462ndylisyy3nfih49aznhzzf7b3krb4p9p0j1zrcy2s";

     

       85
       +
               excludes = [ "doc/**" "CHANGELOG" ];

     

       86
       +
             })

     

       87
       +
           ] ++ (drv.patches or []);

     

       88
       +
         }) super.git-annex;

     

       89
        
       

     

       90
        
         # Fix test trying to access /home directory

     

       91
        
         shell-conduit = overrideCabal (drv: {

     
···

       851
        
       

     

       852
        
         # hledger-lib 1.23 depends on doctest >= 0.18

     

       853
        
         hledger-lib_1_23 = super.hledger-lib_1_23.override {

     

       854
       +
           doctest = self.doctest_0_18_2;

     

       855
        
         };

     

       856
        
       

     

       857
        
         # Copy hledger man pages from data directory into the proper place. This code

     
···

       1345
        
           resource-pool = self.hasura-resource-pool;

     

       1346
        
           ekg-core = self.hasura-ekg-core;

     

       1347
        
           ekg-json = self.hasura-ekg-json;

     

       1348
       +
           hspec = dontCheck self.hspec_2_8_4;

     

       1349
       +
           hspec-core = dontCheck self.hspec-core_2_8_4;

     

       1350
       +
           hspec-discover = dontCheck super.hspec-discover_2_8_4;

     

       1351
        
           tasty-hspec = self.tasty-hspec_1_2;

     

       1352
        
         }));

     

       1353
        
         hasura-ekg-core = super.hasura-ekg-core.overrideScope (self: super: {

     

       1354
       +
           hspec = dontCheck self.hspec_2_8_4;

     

       1355
       +
           hspec-core = dontCheck self.hspec-core_2_8_4;

     

       1356
       +
           hspec-discover = dontCheck super.hspec-discover_2_8_4;

     

       1357
        
         });

     

       1358
        
         hasura-ekg-json = super.hasura-ekg-json.overrideScope (self: super: {

     

       1359
        
           ekg-core = self.hasura-ekg-core;

     

       1360
       +
           hspec = dontCheck self.hspec_2_8_4;

     

       1361
       +
           hspec-core = dontCheck self.hspec-core_2_8_4;

     

       1362
       +
           hspec-discover = dontCheck super.hspec-discover_2_8_4;

     

       1363
        
         });

     

       1364
        
         pg-client = overrideCabal (drv: {

     

       1365
        
           librarySystemDepends = with pkgs; [ postgresql krb5.dev openssl.dev ];

     
···

       1434
        
         # 2021-09-14: Tests are broken because of undeterministic variable names

     

       1435
        
         hls-tactics-plugin = dontCheck super.hls-tactics-plugin;

     

       1436
        
       

     

       1437
       +
         # 2021-03-21: Test hangs

     

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

     

       1439
       +
         # 2021-11-13: Too strict upper bound on implicit-hie-cradle

     

       1440
       +
         ghcide = doJailbreak (dontCheck super.ghcide);

     

       1441
        
       

     

       1442
        
         data-tree-print = doJailbreak super.data-tree-print;

     

       1443
        
       

     
···

       2078
        
         # file revision on hackage was gifted CRLF line endings

     

       2079
        
         gogol-core = appendPatch ./patches/gogol-core-144.patch super.gogol-core;

     

       2080
        
       

     

       2081
       +
         # Jailbreak isn't sufficient, but this is ok as it's a leaf package.

     

       2082
       +
         hadolint = super.hadolint.overrideScope (self: super: {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2083
        
           language-docker = self.language-docker_10_3_0;

     

       2084
       +
           hspec = dontCheck self.hspec_2_8_4;

     

       2085
       +
           hspec-core = dontCheck self.hspec-core_2_8_4;

     

       2086
       +
           hspec-discover = dontCheck self.hspec-discover_2_8_4;

     

       2087
       +
           colourista = doJailbreak super.colourista;

     

       2088
        
         });

     

       2089
        
       

     

       2090
        
         # These should be updated in lockstep

     

       2091
        
         hledger_1_23 = super.hledger_1_23.override {

     

       2092
        
           hledger-lib = self.hledger-lib_1_23;

     

       2093
       +
         };

     

       2094
       +
       

     

       2095
       +
         # Needs brick > 0.64

     

       2096
       +
         nix-tree = super.nix-tree.override {

     

       2097
       +
           brick = self.brick_0_64_2;

     

       2098
        
         };

     

       2099
        
       

     

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

+1 -1

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

···

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

     

       93
        
           sha256 = "1rzs764a0nhx002v4fadbys98s6qblw4kx4g46galzjf5f7n2dn4";

     

       94
        
         }) (dontCheck super.alex);

     

       95
       -
         doctest = dontCheck (doJailbreak super.doctest_0_18_1);

     

       96
        
         language-haskell-extract = appendPatch (pkgs.fetchpatch {

     

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

     

       98
        
           sha256 = "0rgzrq0513nlc1vw7nw4km4bcwn4ivxcgi33jly4a7n3c1r32v1f";

···

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

     

       93
        
           sha256 = "1rzs764a0nhx002v4fadbys98s6qblw4kx4g46galzjf5f7n2dn4";

     

       94
        
         }) (dontCheck super.alex);

     

       95
       +
         doctest = dontCheck (doJailbreak super.doctest_0_18_2);

     

       96
        
         language-haskell-extract = appendPatch (pkgs.fetchpatch {

     

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

     

       98
        
           sha256 = "0rgzrq0513nlc1vw7nw4km4bcwn4ivxcgi33jly4a7n3c1r32v1f";

+3 -11

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

···

       66
        
           sha256 = "0c8n2krz827cv87p3vb1vpl3v0k255aysjx9lq44gz3z1dhxd64z";

     

       67
        
         }) super.basement);

     

       68
        
       

     

       69
       -
         cereal = appendPatch (pkgs.fetchpatch {

     

       70
       -
           url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/cereal-0.5.8.1.patch";

     

       71
       -
           sha256 = "03v4nxwz9y6viaa8anxcmp4zdf2clczv4pf9fqq6lnpplpz5i128";

     

       72
       -
         }) (doJailbreak super.cereal);

     

       73
       -
       

     

       74
        
         # Tests fail because of typechecking changes

     

       75
        
         conduit = dontCheck super.conduit;

     

       76
        
       

     
···

       84
        
           Cabal = self.Cabal_3_6_2_0;

     

       85
        
         });

     

       86
        
       

     

       87
       -
         doctest = appendPatch (pkgs.fetchpatch {

     

       88
       -
           url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/doctest-0.18.1.patch";

     

       89
       -
           sha256 = "030kdsk0fg08cgdcjpyv6z8ym1vkkrbd34aacs91y5hqzc9g79y1";

     

       90
       -
         }) (dontCheck (doJailbreak super.doctest_0_18_1));

     

       91
        
       

     

       92
        
         # Tests fail in GHC 9.2

     

       93
        
         extra = dontCheck super.extra;

     
···

       115
        
         ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_1;

     

       116
        
         hackage-security = doJailbreak super.hackage-security;

     

       117
        
         hashable = super.hashable_1_4_0_0;

     

       118
       -
         hashable-time = doJailbreak super.hashable-time;

     

       119
        
         hedgehog = doJailbreak super.hedgehog;

     

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

     

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

     
···

       142
        
         tasty-hspec = doJailbreak super.tasty-hspec;

     

       143
        
         th-desugar = self.th-desugar_1_13;

     

       144
        
         these = doJailbreak super.these;

     

       145
       -
         time-compat = doJailbreak super.time-compat;

     

       146
        
         type-equality = doJailbreak super.type-equality;

     

       147
        
         unordered-containers = doJailbreak super.unordered-containers;

     

       148
        
         vector = doJailbreak (dontCheck super.vector);

···

       66
        
           sha256 = "0c8n2krz827cv87p3vb1vpl3v0k255aysjx9lq44gz3z1dhxd64z";

     

       67
        
         }) super.basement);

     

       68
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       69
        
         # Tests fail because of typechecking changes

     

       70
        
         conduit = dontCheck super.conduit;

     

       71
        
       

     
···

       79
        
           Cabal = self.Cabal_3_6_2_0;

     

       80
        
         });

     

       81
        
       

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       83
        
       

     

       84
        
         # Tests fail in GHC 9.2

     

       85
        
         extra = dontCheck super.extra;

     
···

       107
        
         ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_1;

     

       108
        
         hackage-security = doJailbreak super.hackage-security;

     

       109
        
         hashable = super.hashable_1_4_0_0;

     

       110
       +
         hashable-time = doJailbreak super.hashable-time_0_3;

     

       111
        
         hedgehog = doJailbreak super.hedgehog;

     

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

     

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

     
···

       134
        
         tasty-hspec = doJailbreak super.tasty-hspec;

     

       135
        
         th-desugar = self.th-desugar_1_13;

     

       136
        
         these = doJailbreak super.these;

     

       137
       +
         time-compat = doJailbreak super.time-compat_1_9_6_1;

     

       138
        
         type-equality = doJailbreak super.type-equality;

     

       139
        
         unordered-containers = doJailbreak super.unordered-containers;

     

       140
        
         vector = doJailbreak (dontCheck super.vector);

+5 -5

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

···

       834
        
         - contstuff-monads-tf

     

       835
        
         - contstuff-transformers

     

       836
        
         - convert-annotation

     

       0
        
       
     

       837
        
         - copilot-sbv

     

       838
        
         - copr

     

       839
        
         - COrdering

     
···

       1841
        
         - haddock-cheatsheet

     

       1842
        
         - haddock-leksah

     

       1843
        
         - haddock-test

     

       1844
       -
         - hadolint

     

       1845
        
         - hadoop-formats

     

       1846
        
         - hadoop-rpc

     

       1847
        
         - hafar

     
···

       2790
        
         - language-typescript

     

       2791
        
         - language-vhdl

     

       2792
        
         - language-webidl

     

       2793
       -
         - lapack

     

       2794
        
         - LargeCardinalHierarchy

     

       2795
        
         - Lastik

     

       2796
        
         - latest-npm-version

     
···

       2918
        
         - llsd

     

       2919
        
         - llvm-base

     

       2920
        
         - llvm-ffi

     

       2921
       -
         - llvm-ffi-tools

     

       2922
        
         - llvm-general-pure

     

       2923
        
         - llvm-ht

     

       2924
       -
         - llvm-pkg-config

     

       2925
        
         - llvm-pretty

     

       2926
        
         - lmonad

     

       2927
        
         - load-balancing

     
···

       3205
        
         - morfette

     

       3206
        
         - morfeusz

     

       3207
        
         - morpheus-graphql-cli

     

       0
        
       
     

       3208
        
         - morphisms-functors

     

       3209
        
         - morphisms-objects

     

       3210
        
         - morte

     
···

       4034
        
         - read-bounded

     

       4035
        
         - read-ctags

     

       4036
        
         - read-io

     

       0
        
       
     

       4037
        
         - readline-statevar

     

       4038
        
         - readme-lhs

     

       4039
        
         - readshp

     
···

       4792
        
         - syntax-trees

     

       4793
        
         - syntax-trees-fork-bairyn

     

       4794
        
         - synthesizer

     

       4795
       -
         - synthesizer-alsa

     

       4796
        
         - Sysmon

     

       4797
        
         - sys-process

     

       4798
        
         - system-canonicalpath

     
···

       5354
        
         - web-encodings

     

       5355
        
         - WeberLogic

     

       5356
        
         - webfinger-client

     

       0
        
       
     

       5357
        
         - webkit-javascriptcore

     

       5358
        
         - webmention

     

       5359
        
         - web-output

···

       834
        
         - contstuff-monads-tf

     

       835
        
         - contstuff-transformers

     

       836
        
         - convert-annotation

     

       837
       +
         - copilot-core

     

       838
        
         - copilot-sbv

     

       839
        
         - copr

     

       840
        
         - COrdering

     
···

       1842
        
         - haddock-cheatsheet

     

       1843
        
         - haddock-leksah

     

       1844
        
         - haddock-test

     

       0
        
       
     

       1845
        
         - hadoop-formats

     

       1846
        
         - hadoop-rpc

     

       1847
        
         - hafar

     
···

       2790
        
         - language-typescript

     

       2791
        
         - language-vhdl

     

       2792
        
         - language-webidl

     

       2793
       +
         - lapack-hmatrix

     

       2794
        
         - LargeCardinalHierarchy

     

       2795
        
         - Lastik

     

       2796
        
         - latest-npm-version

     
···

       2918
        
         - llsd

     

       2919
        
         - llvm-base

     

       2920
        
         - llvm-ffi

     

       0
        
       
     

       2921
        
         - llvm-general-pure

     

       2922
        
         - llvm-ht

     

       0
        
       
     

       2923
        
         - llvm-pretty

     

       2924
        
         - lmonad

     

       2925
        
         - load-balancing

     
···

       3203
        
         - morfette

     

       3204
        
         - morfeusz

     

       3205
        
         - morpheus-graphql-cli

     

       3206
       +
         - morpheus-graphql-code-gen

     

       3207
        
         - morphisms-functors

     

       3208
        
         - morphisms-objects

     

       3209
        
         - morte

     
···

       4033
        
         - read-bounded

     

       4034
        
         - read-ctags

     

       4035
        
         - read-io

     

       4036
       +
         - readline-in-other-words

     

       4037
        
         - readline-statevar

     

       4038
        
         - readme-lhs

     

       4039
        
         - readshp

     
···

       4792
        
         - syntax-trees

     

       4793
        
         - syntax-trees-fork-bairyn

     

       4794
        
         - synthesizer

     

       0
        
       
     

       4795
        
         - Sysmon

     

       4796
        
         - sys-process

     

       4797
        
         - system-canonicalpath

     
···

       5353
        
         - web-encodings

     

       5354
        
         - WeberLogic

     

       5355
        
         - webfinger-client

     

       5356
       +
         - webkitgtk3

     

       5357
        
         - webkit-javascriptcore

     

       5358
        
         - webmention

     

       5359
        
         - web-output

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

···

       98
        
         - futhark < 0.20.6

     

       99
        
         # 2021-11-09: ghc-bignum is bundled starting with 9.0.1; only 1.0 builds with GHCs prior to 9.2.1

     

       100
        
         - ghc-bignum == 1.0

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       101
        
       

     

       102
        
       extra-packages:

     

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

···

       98
        
         - futhark < 0.20.6

     

       99
        
         # 2021-11-09: ghc-bignum is bundled starting with 9.0.1; only 1.0 builds with GHCs prior to 9.2.1

     

       100
        
         - ghc-bignum == 1.0

     

       101
       +
         # 2021-11-18: lucid-{alpine, htmx} are not in stackage, so we need to downgrade them

     

       102
       +
         - lucid-alpine == 0.1.0.2

     

       103
       +
         - lucid-htmx == 0.1.0.2

     

       104
        
       

     

       105
        
       extra-packages:

     

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

+12 -12

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

···

       1
       -
       # Stackage LTS 18.15

     

       2
        
       # This file is auto-generated by

     

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

     

       4
        
       default-package-overrides:

     
···

       363
        
         - cborg-json ==0.2.3.0

     

       364
        
         - cdar-mBound ==0.1.0.4

     

       365
        
         - c-enum ==0.1.0.1

     

       366
       -
         - cereal ==0.5.8.1

     

       367
        
         - cereal-conduit ==0.8.0

     

       368
        
         - cereal-text ==0.1.0.2

     

       369
        
         - cereal-vector ==0.2.0.1

     
···

       716
        
         - event-list ==0.1.2

     

       717
        
         - eventstore ==1.4.1

     

       718
        
         - every ==0.0.1

     

       719
       -
         - exact-combinatorics ==0.2.0.10

     

       720
        
         - exact-pi ==0.5.0.1

     

       721
        
         - exception-hierarchy ==0.1.0.4

     

       722
        
         - exception-mtl ==0.4.0.1

     
···

       835
        
         - gd ==3000.7.3

     

       836
        
         - gdp ==0.0.3.0

     

       837
        
         - general-games ==1.1.1

     

       838
       -
         - generic-aeson ==0.2.0.12

     

       839
        
         - generic-arbitrary ==0.1.0

     

       840
        
         - generic-constraints ==1.1.1.1

     

       841
        
         - generic-data ==0.9.2.1

     
···

       1090
        
         - hruby ==0.3.8.1

     

       1091
        
         - hsass ==0.8.0

     

       1092
        
         - hs-bibutils ==6.10.0.0

     

       1093
       -
         - hsc2hs ==0.68.7

     

       1094
        
         - hscolour ==1.24.4

     

       1095
        
         - hsdns ==1.8

     

       1096
        
         - hsebaysdk ==0.4.1.0

     
···

       1269
        
         - io-streams-haproxy ==1.0.1.0

     

       1270
        
         - ip6addr ==1.0.2

     

       1271
        
         - ipa ==0.3.1.1

     

       1272
       -
         - iproute ==1.7.11

     

       1273
        
         - IPv6Addr ==2.0.3

     

       1274
        
         - ipynb ==0.1.0.2

     

       1275
        
         - ipython-kernel ==0.10.2.1

     
···

       1313
        
         - jwt ==0.10.0

     

       1314
        
         - kan-extensions ==5.2.3

     

       1315
        
         - kanji ==3.4.1

     

       1316
       -
         - katip ==0.8.6.0

     

       1317
        
         - katip-logstash ==0.1.0.0

     

       1318
        
         - kawhi ==0.3.0

     

       1319
        
         - kazura-queue ==0.1.0.4

     
···

       1458
        
         - mathexpr ==0.3.0.0

     

       1459
        
         - math-extras ==0.1.1.0

     

       1460
        
         - math-functions ==0.3.4.2

     

       1461
       -
         - matplotlib ==0.7.5

     

       1462
        
         - matrices ==0.5.0

     

       1463
        
         - matrix ==0.3.6.1

     

       1464
        
         - matrix-as-xyz ==0.1.2.2

     
···

       1875
        
         - protocol-radius-test ==0.1.0.1

     

       1876
        
         - protolude ==0.3.0

     

       1877
        
         - proxied ==0.3.1

     

       1878
       -
         - psqueues ==0.2.7.2

     

       1879
        
         - ptr-poker ==0.1.1.4

     

       1880
        
         - publicsuffix ==0.20200526

     

       1881
        
         - pulse-simple ==0.1.14

     
···

       1946
        
         - reanimate ==1.1.4.0

     

       1947
        
         - reanimate-svg ==0.13.0.1

     

       1948
        
         - rebase ==1.13.0.1

     

       1949
       -
         - record-dot-preprocessor ==0.2.12

     

       1950
        
         - record-hasfield ==1.0

     

       1951
        
         - records-sop ==0.1.1.0

     

       1952
        
         - record-wrangler ==0.1.1.0

     
···

       2386
        
         - th-constraint-compat ==0.0.1.0

     

       2387
        
         - th-data-compat ==0.1.0.0

     

       2388
        
         - th-desugar ==1.11

     

       2389
       -
         - th-env ==0.1.0.2

     

       2390
        
         - these ==1.1.1.1

     

       2391
        
         - these-lens ==1.0.1.2

     

       2392
        
         - these-optics ==1.0.1.2

     
···

       2520
        
         - universe-reverse-instances ==1.1.1

     

       2521
        
         - universe-some ==1.2.1

     

       2522
        
         - universum ==1.7.2

     

       2523
       -
         - unix-bytestring ==0.3.7.5

     

       2524
        
         - unix-compat ==0.5.3

     

       2525
        
         - unix-time ==0.4.7

     

       2526
        
         - unliftio ==0.2.20

···

       1
       +
       # Stackage LTS 18.16

     

       2
        
       # This file is auto-generated by

     

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

     

       4
        
       default-package-overrides:

     
···

       363
        
         - cborg-json ==0.2.3.0

     

       364
        
         - cdar-mBound ==0.1.0.4

     

       365
        
         - c-enum ==0.1.0.1

     

       366
       +
         - cereal ==0.5.8.2

     

       367
        
         - cereal-conduit ==0.8.0

     

       368
        
         - cereal-text ==0.1.0.2

     

       369
        
         - cereal-vector ==0.2.0.1

     
···

       716
        
         - event-list ==0.1.2

     

       717
        
         - eventstore ==1.4.1

     

       718
        
         - every ==0.0.1

     

       719
       +
         - exact-combinatorics ==0.2.0.11

     

       720
        
         - exact-pi ==0.5.0.1

     

       721
        
         - exception-hierarchy ==0.1.0.4

     

       722
        
         - exception-mtl ==0.4.0.1

     
···

       835
        
         - gd ==3000.7.3

     

       836
        
         - gdp ==0.0.3.0

     

       837
        
         - general-games ==1.1.1

     

       838
       +
         - generic-aeson ==0.2.0.13

     

       839
        
         - generic-arbitrary ==0.1.0

     

       840
        
         - generic-constraints ==1.1.1.1

     

       841
        
         - generic-data ==0.9.2.1

     
···

       1090
        
         - hruby ==0.3.8.1

     

       1091
        
         - hsass ==0.8.0

     

       1092
        
         - hs-bibutils ==6.10.0.0

     

       1093
       +
         - hsc2hs ==0.68.8

     

       1094
        
         - hscolour ==1.24.4

     

       1095
        
         - hsdns ==1.8

     

       1096
        
         - hsebaysdk ==0.4.1.0

     
···

       1269
        
         - io-streams-haproxy ==1.0.1.0

     

       1270
        
         - ip6addr ==1.0.2

     

       1271
        
         - ipa ==0.3.1.1

     

       1272
       +
         - iproute ==1.7.12

     

       1273
        
         - IPv6Addr ==2.0.3

     

       1274
        
         - ipynb ==0.1.0.2

     

       1275
        
         - ipython-kernel ==0.10.2.1

     
···

       1313
        
         - jwt ==0.10.0

     

       1314
        
         - kan-extensions ==5.2.3

     

       1315
        
         - kanji ==3.4.1

     

       1316
       +
         - katip ==0.8.7.0

     

       1317
        
         - katip-logstash ==0.1.0.0

     

       1318
        
         - kawhi ==0.3.0

     

       1319
        
         - kazura-queue ==0.1.0.4

     
···

       1458
        
         - mathexpr ==0.3.0.0

     

       1459
        
         - math-extras ==0.1.1.0

     

       1460
        
         - math-functions ==0.3.4.2

     

       1461
       +
         - matplotlib ==0.7.6

     

       1462
        
         - matrices ==0.5.0

     

       1463
        
         - matrix ==0.3.6.1

     

       1464
        
         - matrix-as-xyz ==0.1.2.2

     
···

       1875
        
         - protocol-radius-test ==0.1.0.1

     

       1876
        
         - protolude ==0.3.0

     

       1877
        
         - proxied ==0.3.1

     

       1878
       +
         - psqueues ==0.2.7.3

     

       1879
        
         - ptr-poker ==0.1.1.4

     

       1880
        
         - publicsuffix ==0.20200526

     

       1881
        
         - pulse-simple ==0.1.14

     
···

       1946
        
         - reanimate ==1.1.4.0

     

       1947
        
         - reanimate-svg ==0.13.0.1

     

       1948
        
         - rebase ==1.13.0.1

     

       1949
       +
         - record-dot-preprocessor ==0.2.13

     

       1950
        
         - record-hasfield ==1.0

     

       1951
        
         - records-sop ==0.1.1.0

     

       1952
        
         - record-wrangler ==0.1.1.0

     
···

       2386
        
         - th-constraint-compat ==0.0.1.0

     

       2387
        
         - th-data-compat ==0.1.0.0

     

       2388
        
         - th-desugar ==1.11

     

       2389
       +
         - th-env ==0.1.0.3

     

       2390
        
         - these ==1.1.1.1

     

       2391
        
         - these-lens ==1.0.1.2

     

       2392
        
         - these-optics ==1.0.1.2

     
···

       2520
        
         - universe-reverse-instances ==1.1.1

     

       2521
        
         - universe-some ==1.2.1

     

       2522
        
         - universum ==1.7.2

     

       2523
       +
         - unix-bytestring ==0.3.7.6

     

       2524
        
         - unix-compat ==0.5.3

     

       2525
        
         - unix-time ==0.4.7

     

       2526
        
         - unliftio ==0.2.20

+10 -8

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

···

       822
        
        - convertible-text

     

       823
        
        - coordinate

     

       824
        
        - copilot

     

       0
        
       
     

       825
        
        - copilot-cbmc

     

       826
        
        - copilot-language

     

       827
        
        - copilot-libraries

     
···

       948
        
        - diagrams-pgf

     

       949
        
        - diagrams-reflex

     

       950
        
        - diagrams-wx

     

       0
        
       
     

       951
        
        - difference-monoid

     

       952
        
        - digestive-functors-hsp

     

       953
        
        - dingo-core

     
···

       1222
        
        - ghc-mod

     

       1223
        
        - ghc-tags-plugin

     

       1224
        
        - ghci-pretty

     

       0
        
       
     

       1225
        
        - ghcjs-hplay

     

       1226
        
        - ght

     

       1227
        
        - gi-cairo-again

     
···

       1485
        
        - hbb

     

       1486
        
        - hbcd

     

       1487
        
        - hbf

     

       0
        
       
     

       0
        
       
     

       1488
        
        - hcg-minus-cairo

     

       1489
        
        - hcheat

     

       1490
        
        - hcheckers

     
···

       1570
        
        - hmeap

     

       1571
        
        - hmeap-utils

     

       1572
        
        - hmep

     

       1573
       -
        - hmm-lapack

     

       1574
        
        - hmm-lapack_0_4_1

     

       1575
        
        - hmt

     

       1576
        
        - hmt-diagrams

     
···

       1917
        
        - language-python-colour

     

       1918
        
        - language-qux

     

       1919
        
        - language-spelling

     

       1920
       -
        - lapack-hmatrix

     

       1921
        
        - lat

     

       1922
        
        - latex-formulae-hakyll

     

       1923
        
        - latex-formulae-pandoc

     
···

       1962
        
        - lightstep-haskell

     

       1963
        
        - lighttpd-conf

     

       1964
        
        - lighttpd-conf-qq

     

       1965
       -
        - linear-circuit

     

       1966
       -
        - linear-circuit_0_1_0_3

     

       1967
        
        - linearmap-category

     

       1968
        
        - linearscan-hoopl

     

       1969
        
        - linkchk

     
···

       2043
        
        - macosx-make-standalone

     

       2044
        
        - magic-wormhole

     

       2045
        
        - magicbane

     

       2046
       -
        - magico

     

       2047
       -
        - magico_0_0_2_2

     

       2048
        
        - mahoro

     

       2049
        
        - maid

     

       2050
        
        - mail-pool

     
···

       2122
        
        - mmark-cli

     

       2123
        
        - mmark-cli_0_0_5_1

     

       2124
        
        - mmark-ext

     

       0
        
       
     

       2125
        
        - mmtl-base

     

       2126
        
        - moan

     

       2127
        
        - modify-fasta

     
···

       2143
        
        - moo-nad

     

       2144
        
        - morley

     

       2145
        
        - morloc

     

       0
        
       
     

       0
        
       
     

       2146
        
        - morphisms-functors-inventory

     

       2147
        
        - mosaico-lib

     

       2148
        
        - motor-diagrams

     
···

       2333
        
        - persona-idp

     

       2334
        
        - peyotls

     

       2335
        
        - peyotls-codec

     

       0
        
       
     

       2336
        
        - pgsql-simple

     

       2337
        
        - phonetic-languages-examples

     

       2338
        
        - phonetic-languages-general

     
···

       2577
        
        - replicant

     

       2578
        
        - repr

     

       2579
        
        - representable-tries

     

       2580
       -
        - resistor-cube

     

       2581
       -
        - resistor-cube_0_0_1_3

     

       2582
        
        - resource-pool-catchio

     

       2583
        
        - resource-simple

     

       2584
        
        - respond

···

       822
        
        - convertible-text

     

       823
        
        - coordinate

     

       824
        
        - copilot

     

       825
       +
        - copilot-c99

     

       826
        
        - copilot-cbmc

     

       827
        
        - copilot-language

     

       828
        
        - copilot-libraries

     
···

       949
        
        - diagrams-pgf

     

       950
        
        - diagrams-reflex

     

       951
        
        - diagrams-wx

     

       952
       +
        - dialog

     

       953
        
        - difference-monoid

     

       954
        
        - digestive-functors-hsp

     

       955
        
        - dingo-core

     
···

       1224
        
        - ghc-mod

     

       1225
        
        - ghc-tags-plugin

     

       1226
        
        - ghci-pretty

     

       1227
       +
        - ghcjs-dom-webkit

     

       1228
        
        - ghcjs-hplay

     

       1229
        
        - ght

     

       1230
        
        - gi-cairo-again

     
···

       1488
        
        - hbb

     

       1489
        
        - hbcd

     

       1490
        
        - hbf

     

       1491
       +
        - hbro

     

       1492
       +
        - hbro-contrib

     

       1493
        
        - hcg-minus-cairo

     

       1494
        
        - hcheat

     

       1495
        
        - hcheckers

     
···

       1575
        
        - hmeap

     

       1576
        
        - hmeap-utils

     

       1577
        
        - hmep

     

       0
        
       
     

       1578
        
        - hmm-lapack_0_4_1

     

       1579
        
        - hmt

     

       1580
        
        - hmt-diagrams

     
···

       1921
        
        - language-python-colour

     

       1922
        
        - language-qux

     

       1923
        
        - language-spelling

     

       1924
       +
        - lapack_0_4

     

       1925
        
        - lat

     

       1926
        
        - latex-formulae-hakyll

     

       1927
        
        - latex-formulae-pandoc

     
···

       1966
        
        - lightstep-haskell

     

       1967
        
        - lighttpd-conf

     

       1968
        
        - lighttpd-conf-qq

     

       0
        
       
     

       0
        
       
     

       1969
        
        - linearmap-category

     

       1970
        
        - linearscan-hoopl

     

       1971
        
        - linkchk

     
···

       2045
        
        - macosx-make-standalone

     

       2046
        
        - magic-wormhole

     

       2047
        
        - magicbane

     

       0
        
       
     

       0
        
       
     

       2048
        
        - mahoro

     

       2049
        
        - maid

     

       2050
        
        - mail-pool

     
···

       2122
        
        - mmark-cli

     

       2123
        
        - mmark-cli_0_0_5_1

     

       2124
        
        - mmark-ext

     

       2125
       +
        - mmark-ext_0_2_1_4

     

       2126
        
        - mmtl-base

     

       2127
        
        - moan

     

       2128
        
        - modify-fasta

     
···

       2144
        
        - moo-nad

     

       2145
        
        - morley

     

       2146
        
        - morloc

     

       2147
       +
        - morpheus-graphql-client_0_18_0

     

       2148
       +
        - morpheus-graphql_0_18_0

     

       2149
        
        - morphisms-functors-inventory

     

       2150
        
        - mosaico-lib

     

       2151
        
        - motor-diagrams

     
···

       2336
        
        - persona-idp

     

       2337
        
        - peyotls

     

       2338
        
        - peyotls-codec

     

       2339
       +
        - pg-entity

     

       2340
        
        - pgsql-simple

     

       2341
        
        - phonetic-languages-examples

     

       2342
        
        - phonetic-languages-general

     
···

       2581
        
        - replicant

     

       2582
        
        - repr

     

       2583
        
        - representable-tries

     

       0
        
       
     

       0
        
       
     

       2584
        
        - resource-pool-catchio

     

       2585
        
        - resource-simple

     

       2586
        
        - respond

+25 -19

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

···

       155
        
         github-types = dontCheck super.github-types;          # http://hydra.cryp.to/build/1114046/nixlog/1/raw

     

       156
        
         hadoop-rpc = dontCheck super.hadoop-rpc;              # http://hydra.cryp.to/build/527461/nixlog/2/raw

     

       157
        
         hasql = dontCheck super.hasql;                        # http://hydra.cryp.to/build/502489/nixlog/4/raw

     

       0
        
       
     

       158
        
         hasql-transaction = dontCheck super.hasql-transaction; # wants to connect to postgresql

     

       159
        
         hjsonschema = overrideCabal (drv: { testTarget = "local"; }) super.hjsonschema;

     

       160
        
         marmalade-upload = dontCheck super.marmalade-upload;  # http://hydra.cryp.to/build/501904/nixlog/1/raw

     
···

       516
        
             })

     

       517
        
             (addBuildTools (with pkgs.buildPackages; [makeWrapper python3Packages.sphinx]) super.futhark);

     

       518
        
       

     

       519
       -
         git-annex = with pkgs;

     

       520
       -
           if (!stdenv.isLinux) then

     

       521
       -
             let path = lib.makeBinPath [ coreutils ];

     

       522
       -
             in overrideCabal (_drv: {

     

       523
       -
               # This is an instance of https://github.com/NixOS/nix/pull/1085

     

       524
       -
               # Fails with:

     

       525
       -
               #   gpg: can't connect to the agent: File name too long

     

       526
       -
               postPatch = lib.optionalString stdenv.isDarwin ''

     

       527
       -
                 substituteInPlace Test.hs \

     

       528
       -
                   --replace ', testCase "crypto" test_crypto' ""

     

       529
       -
               '';

     

       530
       -
               # On Darwin, git-annex mis-detects options to `cp`, so we wrap the

     

       531
       -
               # binary to ensure it uses Nixpkgs' coreutils.

     

       532
       -
               postFixup = ''

     

       533
       -
                 wrapProgram $out/bin/git-annex \

     

       534
       -
                   --prefix PATH : "${path}"

     

       535
       -
               '';

     

       536
       -
             }) (addBuildTool buildPackages.makeWrapper super.git-annex)

     

       537
       -
           else super.git-annex;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       538
        
       

     

       539
        
         # The test suite has undeclared dependencies on git.

     

       540
        
         githash = dontCheck super.githash;

···

       155
        
         github-types = dontCheck super.github-types;          # http://hydra.cryp.to/build/1114046/nixlog/1/raw

     

       156
        
         hadoop-rpc = dontCheck super.hadoop-rpc;              # http://hydra.cryp.to/build/527461/nixlog/2/raw

     

       157
        
         hasql = dontCheck super.hasql;                        # http://hydra.cryp.to/build/502489/nixlog/4/raw

     

       158
       +
         hasql-interpolate = dontCheck super.hasql-interpolate; # wants to connect to postgresql

     

       159
        
         hasql-transaction = dontCheck super.hasql-transaction; # wants to connect to postgresql

     

       160
        
         hjsonschema = overrideCabal (drv: { testTarget = "local"; }) super.hjsonschema;

     

       161
        
         marmalade-upload = dontCheck super.marmalade-upload;  # http://hydra.cryp.to/build/501904/nixlog/1/raw

     
···

       517
        
             })

     

       518
        
             (addBuildTools (with pkgs.buildPackages; [makeWrapper python3Packages.sphinx]) super.futhark);

     

       519
        
       

     

       520
       +
         git-annex = let

     

       521
       +
           pathForDarwin = pkgs.lib.makeBinPath [ pkgs.coreutils ];

     

       522
       +
         in overrideCabal (drv: pkgs.lib.optionalAttrs (!pkgs.stdenv.isLinux) {

     

       523
       +
           # This is an instance of https://github.com/NixOS/nix/pull/1085

     

       524
       +
           # Fails with:

     

       525
       +
           #   gpg: can't connect to the agent: File name too long

     

       526
       +
           postPatch = pkgs.lib.optionalString pkgs.stdenv.isDarwin ''

     

       527
       +
             substituteInPlace Test.hs \

     

       528
       +
               --replace ', testCase "crypto" test_crypto' ""

     

       529
       +
           '' + (drv.postPatch or "");

     

       530
       +
           # On Darwin, git-annex mis-detects options to `cp`, so we wrap the

     

       531
       +
           # binary to ensure it uses Nixpkgs' coreutils.

     

       532
       +
           postFixup = ''

     

       533
       +
             wrapProgram $out/bin/git-annex \

     

       534
       +
               --prefix PATH : "${pathForDarwin}"

     

       535
       +
           '' + (drv.postFixup or "");

     

       536
       +
           buildTools = [

     

       537
       +
             pkgs.buildPackages.makeWrapper

     

       538
       +
           ] ++ (drv.buildTools or []);

     

       539
       +
         }) (super.git-annex.override {

     

       540
       +
           dbus = if pkgs.stdenv.isLinux then self.dbus else null;

     

       541
       +
           fdo-notify = if pkgs.stdenv.isLinux then self.fdo-notify else null;

     

       542
       +
           hinotify = if pkgs.stdenv.isLinux then self.hinotify else self.fsnotify;

     

       543
       +
         });

     

       544
        
       

     

       545
        
         # The test suite has undeclared dependencies on git.

     

       546
        
         githash = dontCheck super.githash;

+1405 -438

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

···

       7320
        
              license = lib.licenses.bsd3;

     

       7321
        
            }) {};

     

       7322
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7323
        
         "GlomeTrace" = callPackage

     

       7324
        
           ({ mkDerivation, array, base, GlomeVec }:

     

       7325
        
            mkDerivation {

     
···

       10906
        
              pname = "HsYAML";

     

       10907
        
              version = "0.2.1.0";

     

       10908
        
              sha256 = "10qzhsg789h37q22hm9p27dx4rhbykcbxp7p3pvkws8fr7ajgxv0";

     

       10909
       -
              revision = "2";

     

       10910
       -
              editedCabalFile = "0f7867jfzlmlqnkv3fjrzjvvfzjlvhbm10kmg7n0qk69ic8grkbc";

     

       10911
        
              isLibrary = true;

     

       10912
        
              isExecutable = true;

     

       10913
        
              libraryHaskellDepends = [

     
···

       10937
        
              ];

     

       10938
        
              description = "JSON to YAML Adapter";

     

       10939
        
              license = lib.licenses.gpl2Plus;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10940
        
            }) {};

     

       10941
        
       

     

       10942
        
         "Hsed" = callPackage

     
···

       17107
        
              license = lib.licenses.bsd3;

     

       17108
        
            }) {};

     

       17109
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       17110
        
         "ReadArgs" = callPackage

     

       17111
        
           ({ mkDerivation, base, hspec, system-filepath, text }:

     

       17112
        
            mkDerivation {

     
···

       17356
        
            }:

     

       17357
        
            mkDerivation {

     

       17358
        
              pname = "RtMidi";

     

       17359
       -
              version = "0.5.0.1";

     

       17360
       -
              sha256 = "13fzqfq47zx3anpc1y9ypfa2h7bxzzj95zd7hpm3niykjrl9zadr";

     

       17361
        
              isLibrary = true;

     

       17362
        
              isExecutable = true;

     

       17363
        
              libraryHaskellDepends = [ base deepseq unliftio-core vector ];

     
···

       18326
        
              license = lib.licenses.gpl3Only;

     

       18327
        
            }) {};

     

       18328
        
       

     

       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
        
       
     

       18329
        
         "Shellac" = callPackage

     

       18330
        
           ({ mkDerivation, base, directory, mtl, unix }:

     

       18331
        
            mkDerivation {

     
···

       20915
        
           ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:

     

       20916
        
            mkDerivation {

     

       20917
        
              pname = "VulkanMemoryAllocator";

     

       20918
       -
              version = "0.7.3";

     

       20919
       -
              sha256 = "0ff8ik1y4cxf408kwpasqrkdimh3afvjhpbsjd40zf8h3aywv10b";

     

       20920
        
              libraryHaskellDepends = [

     

       20921
        
                base bytestring transformers vector vulkan

     

       20922
        
              ];

     
···

       21275
        
              platforms = lib.platforms.none;

     

       21276
        
            }) {};

     

       21277
        
       

     

       21278
       -
         "Win32_2_13_0_0" = callPackage

     

       21279
        
           ({ mkDerivation }:

     

       21280
        
            mkDerivation {

     

       21281
        
              pname = "Win32";

     

       21282
       -
              version = "2.13.0.0";

     

       21283
       -
              sha256 = "0i4ws3d7s94vv6gh3cjj9nr0l88rwx7bwjk9jk0grzvw734dd9a2";

     

       21284
        
              description = "A binding to Windows Win32 API";

     

       21285
        
              license = lib.licenses.bsd3;

     

       21286
        
              platforms = lib.platforms.none;

     
···

       24104
        
              license = lib.licenses.bsd3;

     

       24105
        
            }) {};

     

       24106
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24107
        
         "ad-delcont" = callPackage

     

       24108
        
           ({ mkDerivation, base, transformers }:

     

       24109
        
            mkDerivation {

     
···

       26703
        
            }:

     

       26704
        
            mkDerivation {

     

       26705
        
              pname = "algorithmic-composition-basic";

     

       26706
       -
              version = "0.4.0.0";

     

       26707
       -
              sha256 = "17kajlfr02kq82g281i1bm6x171106wyqz797p6j3iq3jxwp3x91";

     

       26708
        
              libraryHaskellDepends = [

     

       26709
        
                base bytestring directory foldable-ix mmsyn2-array mmsyn3 mmsyn7l

     

       26710
        
                mmsyn7ukr-common process process-sequential

     
···

       30567
        
            }:

     

       30568
        
            mkDerivation {

     

       30569
        
              pname = "ansi-terminal-game";

     

       30570
       -
              version = "1.4.0.0";

     

       30571
       -
              sha256 = "0pxkqjv6xqqyn98y2vpsyyx6n91cjsdwxpx9y636l5n3lk8iq14z";

     

       30572
        
              isLibrary = true;

     

       30573
        
              isExecutable = true;

     

       30574
        
              libraryHaskellDepends = [

     
···

       32772
        
            }:

     

       32773
        
            mkDerivation {

     

       32774
        
              pname = "arduino-copilot";

     

       32775
       -
              version = "1.5.5";

     

       32776
       -
              sha256 = "0g2zw7xngaz5xhp4zrnhrkscnyck0474mngvp2j14p87sc7qn20w";

     

       32777
        
              libraryHaskellDepends = [

     

       32778
        
                base containers copilot copilot-c99 copilot-language directory

     

       32779
        
                filepath mtl optparse-applicative temporary

     
···

       32849
        
            }:

     

       32850
        
            mkDerivation {

     

       32851
        
              pname = "argo";

     

       32852
       -
              version = "0.2021.11.2";

     

       32853
       -
              sha256 = "1jlh8m03ncwx5pckdbi6c620xc45pg1phspp0cmvqgrvy6wkiyjz";

     

       32854
        
              isLibrary = true;

     

       32855
        
              isExecutable = true;

     

       32856
        
              libraryHaskellDepends = [

     
···

       34541
        
              pname = "async";

     

       34542
        
              version = "2.2.4";

     

       34543
        
              sha256 = "09d7w3krfhnmf9dp6yffa9wykinhw541wibnjgnlyv77w1dzhka8";

     

       0
        
       
     

       0
        
       
     

       34544
        
              isLibrary = true;

     

       34545
        
              isExecutable = true;

     

       34546
        
              libraryHaskellDepends = [ base hashable stm ];

     
···

       38262
        
           ({ mkDerivation, base, hspec, HUnit, QuickCheck, time }:

     

       38263
        
            mkDerivation {

     

       38264
        
              pname = "bank-holiday-usa";

     

       38265
       -
              version = "0.1.1";

     

       38266
       -
              sha256 = "12s473bjbv5wgsxwi5vf6ffh9z72dw7fbnih0i9ifry8kim4pgaz";

     

       38267
        
              libraryHaskellDepends = [ base time ];

     

       38268
        
              testHaskellDepends = [ base hspec HUnit QuickCheck time ];

     

       38269
       -
              description = "A library for determining US bank holidays";

     

       38270
        
              license = lib.licenses.mit;

     

       38271
        
              hydraPlatforms = lib.platforms.none;

     

       38272
        
              broken = true;

     
···

       38342
        
              pname = "barbies-th";

     

       38343
        
              version = "0.1.9";

     

       38344
        
              sha256 = "1brikm7qr2yi3426vgwjjxjrvw060sb0v7jbxrhazjps28f6aa3n";

     

       0
        
       
     

       0
        
       
     

       38345
        
              libraryHaskellDepends = [ barbies base split template-haskell ];

     

       38346
        
              testHaskellDepends = [ barbies base ];

     

       38347
        
              description = "Create strippable HKD via TH";

     
···

       40044
        
              broken = true;

     

       40045
        
            }) {};

     

       40046
        
       

     

       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
        
       
     

       40047
        
         "bech32-th" = callPackage

     

       40048
        
           ({ mkDerivation, base, bech32, hspec, hspec-discover

     

       40049
        
            , template-haskell, text

     
···

       42968
        
            }:

     

       42969
        
            mkDerivation {

     

       42970
        
              pname = "bishbosh";

     

       42971
       -
              version = "0.1.1.0";

     

       42972
       -
              sha256 = "0raryshzgahldn03dzpin6hi9vyq4w81dxgmgcq34z7h2salia5m";

     

       42973
        
              isLibrary = true;

     

       42974
        
              isExecutable = true;

     

       42975
        
              enableSeparateDataOutput = true;

     
···

       43511
        
              license = lib.licenses.bsd3;

     

       43512
        
            }) {};

     

       43513
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       43514
        
         "bits-atomic" = callPackage

     

       43515
        
           ({ mkDerivation, base }:

     

       43516
        
            mkDerivation {

     
···

       44846
        
              pname = "bloomfilter";

     

       44847
        
              version = "2.0.1.0";

     

       44848
        
              sha256 = "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc";

     

       0
        
       
     

       0
        
       
     

       44849
        
              libraryHaskellDepends = [ array base bytestring deepseq ];

     

       44850
        
              testHaskellDepends = [

     

       44851
        
                base bytestring QuickCheck random test-framework

     
···

       46002
        
              license = lib.licenses.bsd3;

     

       46003
        
            }) {};

     

       46004
        
       

     

       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
        
       
     

       46005
        
         "bound-extras" = callPackage

     

       46006
        
           ({ mkDerivation, base, bound, containers, deepseq, filepath

     

       46007
        
            , hashable, pretty, tasty, tasty-golden, text-short, transformers

     
···

       48208
        
              pname = "bytes";

     

       48209
        
              version = "0.17.1";

     

       48210
        
              sha256 = "1qmps8vvg98wfm9xm734hwzi56bsk8r1zc6vx20rlhc79krv5s9s";

     

       0
        
       
     

       0
        
       
     

       48211
        
              libraryHaskellDepends = [

     

       48212
        
                base binary binary-orphans bytestring cereal containers hashable

     

       48213
        
                mtl scientific text time transformers transformers-compat

     
···

       49468
        
              license = lib.licenses.bsd3;

     

       49469
        
            }) {};

     

       49470
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       49471
        
         "cabal-edit" = callPackage

     

       49472
        
           ({ mkDerivation, base, bytestring, Cabal, containers, directory

     

       49473
        
            , filepath, Glob, hackage-db, optparse-applicative, process, store

     
···

       52605
        
              pname = "cassava";

     

       52606
        
              version = "0.5.2.0";

     

       52607
        
              sha256 = "01h1zrdqb313cjd4rqm1107azzx4czqi018c2djf66a5i7ajl3dk";

     

       52608
       -
              revision = "4";

     

       52609
       -
              editedCabalFile = "19rkq41r5vj8drnj850b1wqnc54mxpw0x5z54brq0nvyww5f8ai8";

     

       52610
        
              configureFlags = [ "-f-bytestring--lt-0_10_4" ];

     

       52611
        
              libraryHaskellDepends = [

     

       52612
        
                array attoparsec base bytestring containers deepseq hashable Only

     
···

       53492
        
            }:

     

       53493
        
            mkDerivation {

     

       53494
        
              pname = "cereal";

     

       53495
       -
              version = "0.5.8.1";

     

       53496
       -
              sha256 = "1mqvd1iwzr50az4y24332x3g3wsrzw8j1iwph02vr7jbjfn8i7id";

     

       53497
       -
              revision = "1";

     

       53498
       -
              editedCabalFile = "02v1nivac478nzzykjbq3rawnqskxjc4sb54m6s5jcgbigfnb2x0";

     

       53499
       -
              libraryHaskellDepends = [

     

       53500
       -
                array base bytestring containers ghc-prim

     

       53501
       -
              ];

     

       53502
       -
              testHaskellDepends = [

     

       53503
       -
                base bytestring QuickCheck test-framework

     

       53504
       -
                test-framework-quickcheck2

     

       53505
       -
              ];

     

       53506
       -
              description = "A binary serialization library";

     

       53507
       -
              license = lib.licenses.bsd3;

     

       53508
       -
            }) {};

     

       53509
       -
       

     

       53510
       -
         "cereal_0_5_8_2" = callPackage

     

       53511
       -
           ({ mkDerivation, array, base, bytestring, containers, ghc-prim

     

       53512
       -
            , QuickCheck, test-framework, test-framework-quickcheck2

     

       53513
       -
            }:

     

       53514
       -
            mkDerivation {

     

       53515
       -
              pname = "cereal";

     

       53516
        
              version = "0.5.8.2";

     

       53517
        
              sha256 = "0kvnlm22qdmb7g2jz7imsvh799q4nvms1ni0cbba5vigp5ai64hp";

     

       53518
        
              libraryHaskellDepends = [

     
···

       53524
        
              ];

     

       53525
        
              description = "A binary serialization library";

     

       53526
        
              license = lib.licenses.bsd3;

     

       53527
       -
              hydraPlatforms = lib.platforms.none;

     

       53528
        
            }) {};

     

       53529
        
       

     

       53530
        
         "cereal-conduit" = callPackage

     
···

       54011
        
            }) {};

     

       54012
        
       

     

       54013
        
         "chakra" = callPackage

     

       54014
       -
           ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cryptonite

     

       54015
       -
            , data-default, data-has, dotenv, envy, fast-logger, hspec

     

       54016
       -
            , http-types, iproute, jose, lens, mtl, network, network-uri

     

       54017
       -
            , options, optparse-simple, prometheus-client

     

       54018
        
            , prometheus-metrics-ghc, rio, servant-auth, servant-auth-server

     

       54019
       -
            , servant-server, streaming-commons, string-conversions, text, time

     

       54020
       -
            , transformers, unordered-containers, wai, wai-cli, wai-extra

     

       54021
       -
            , wai-middleware-prometheus, warp

     

       54022
        
            }:

     

       54023
        
            mkDerivation {

     

       54024
        
              pname = "chakra";

     

       54025
       -
              version = "0.1.0";

     

       54026
       -
              sha256 = "00ygnyvif8z8x9xasa3s9yahsawdmkjg43afczd5i0p3clfg6385";

     

       54027
        
              isLibrary = true;

     

       54028
        
              isExecutable = true;

     

       54029
        
              libraryHaskellDepends = [

     

       54030
       -
                aeson ansi-terminal base bytestring cryptonite data-default

     

       54031
       -
                data-has dotenv envy fast-logger http-types iproute jose lens mtl

     

       54032
       -
                network network-uri options prometheus-client

     

       54033
       -
                prometheus-metrics-ghc rio servant-auth servant-auth-server

     

       54034
       -
                servant-server streaming-commons string-conversions text time

     

       54035
       -
                transformers unordered-containers wai wai-cli wai-extra

     

       54036
       -
                wai-middleware-prometheus warp

     

       54037
        
              ];

     

       54038
        
              executableHaskellDepends = [

     

       54039
       -
                aeson ansi-terminal base bytestring cryptonite data-default

     

       54040
       -
                data-has dotenv envy fast-logger http-types iproute jose lens mtl

     

       54041
       -
                network network-uri options optparse-simple prometheus-client

     

       54042
       -
                prometheus-metrics-ghc rio servant-auth servant-auth-server

     

       54043
       -
                servant-server streaming-commons string-conversions text time

     

       54044
       -
                transformers unordered-containers wai wai-cli wai-extra

     

       54045
        
                wai-middleware-prometheus warp

     

       54046
        
              ];

     

       54047
        
              testHaskellDepends = [

     

       54048
       -
                aeson ansi-terminal base bytestring cryptonite data-default

     

       54049
       -
                data-has dotenv envy fast-logger hspec http-types iproute jose lens

     

       54050
       -
                mtl network network-uri options prometheus-client

     

       54051
       -
                prometheus-metrics-ghc rio servant-auth servant-auth-server

     

       54052
       -
                servant-server streaming-commons string-conversions text time

     

       54053
       -
                transformers unordered-containers wai wai-cli wai-extra

     

       54054
       -
                wai-middleware-prometheus warp

     

       54055
        
              ];

     

       54056
        
              description = "A REST Web Api server template for building (micro)services";

     

       54057
        
              license = lib.licenses.mit;

     
···

       56734
        
              pname = "classy-prelude";

     

       56735
        
              version = "1.5.0";

     

       56736
        
              sha256 = "1nm4lygxqb1wq503maki6dsah2gpn5rd22jmbwjxfwyzgyqy9fnk";

     

       0
        
       
     

       0
        
       
     

       56737
        
              libraryHaskellDepends = [

     

       56738
        
                async base basic-prelude bifunctors bytestring chunked-data

     

       56739
        
                containers deepseq dlist ghc-prim hashable mono-traversable

     
···

       63848
        
              pname = "constraints";

     

       63849
        
              version = "0.13.1";

     

       63850
        
              sha256 = "0j10sn0i1pk0dsxnf728v0mjg9bcxblkhd8f4fm8rgi32v2sby6k";

     

       0
        
       
     

       0
        
       
     

       63851
        
              libraryHaskellDepends = [

     

       63852
        
                base binary deepseq ghc-prim hashable mtl transformers

     

       63853
        
                transformers-compat type-equality

     
···

       63856
        
              testToolDepends = [ hspec-discover ];

     

       63857
        
              description = "Constraint manipulation";

     

       63858
        
              license = lib.licenses.bsd2;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63859
        
            }) {};

     

       63860
        
       

     

       63861
        
         "constraints-deriving" = callPackage

     
···

       63952
        
            }:

     

       63953
        
            mkDerivation {

     

       63954
        
              pname = "constructible";

     

       63955
       -
              version = "0.1.1";

     

       63956
       -
              sha256 = "19g62i3cv39fww55xcayrzh1v7flghg43ygj41g9cq6qsbq345wr";

     

       63957
        
              libraryHaskellDepends = [

     

       63958
        
                base binary-search complex-generic integer-roots

     

       63959
        
              ];

     
···

       65017
        
            }:

     

       65018
        
            mkDerivation {

     

       65019
        
              pname = "copilot";

     

       65020
       -
              version = "3.5";

     

       65021
       -
              sha256 = "1cia936fm14bzkd8qh8g8zri2lfx7n0jfbjqiqwpwhpgmxvfhznj";

     

       65022
        
              isLibrary = true;

     

       65023
        
              isExecutable = true;

     

       65024
        
              libraryHaskellDepends = [

     
···

       65037
        
            }:

     

       65038
        
            mkDerivation {

     

       65039
        
              pname = "copilot-c99";

     

       65040
       -
              version = "3.5";

     

       65041
       -
              sha256 = "1svcshxqrqp9m7pj7k77vfxzmzkanj0zyjq4ry985zzhcqgzcank";

     

       65042
        
              libraryHaskellDepends = [

     

       65043
        
                base containers copilot-core directory filepath language-c99

     

       65044
        
                language-c99-simple language-c99-util mtl pretty

     

       65045
        
              ];

     

       65046
        
              description = "A compiler for Copilot targeting C99";

     

       65047
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       65048
        
            }) {};

     

       65049
        
       

     

       65050
        
         "copilot-cbmc" = callPackage

     
···

       65065
        
            }) {};

     

       65066
        
       

     

       65067
        
         "copilot-core" = callPackage

     

       65068
       -
           ({ mkDerivation, base, dlist, mtl, pretty }:

     

       0
        
       
     

       0
        
       
     

       65069
        
            mkDerivation {

     

       65070
        
              pname = "copilot-core";

     

       65071
       -
              version = "3.5";

     

       65072
       -
              sha256 = "0i5jj4hzk0gqsjx24xswjna9cdwxbyv5hln5jsmhdhgw05c4z5g4";

     

       65073
        
              libraryHaskellDepends = [ base dlist mtl pretty ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       65074
        
              description = "An intermediate representation for Copilot";

     

       65075
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       65076
        
            }) {};

     

       65077
        
       

     

       65078
        
         "copilot-language" = callPackage

     
···

       65081
        
            }:

     

       65082
        
            mkDerivation {

     

       65083
        
              pname = "copilot-language";

     

       65084
       -
              version = "3.5";

     

       65085
       -
              sha256 = "0s1yn4la8pbdwlcfrlx79031anagp235dbapm3c715mv67dgcs2b";

     

       65086
        
              libraryHaskellDepends = [

     

       65087
        
                array base containers copilot-core copilot-theorem data-reify mtl

     

       65088
        
              ];

     
···

       65097
        
            }:

     

       65098
        
            mkDerivation {

     

       65099
        
              pname = "copilot-libraries";

     

       65100
       -
              version = "3.5";

     

       65101
       -
              sha256 = "1glz1x00abyavyca7kz19ji7jipl5fjxwqi47mql4b3wr9ksc0y4";

     

       65102
        
              libraryHaskellDepends = [

     

       65103
        
                array base containers copilot-language data-reify mtl parsec

     

       65104
        
              ];

     
···

       65132
        
            }:

     

       65133
        
            mkDerivation {

     

       65134
        
              pname = "copilot-theorem";

     

       65135
       -
              version = "3.5";

     

       65136
       -
              sha256 = "0cb22695jp502iilyjkfhr8lzl97rdrpjvs9fbknrr0zbwn1m7p9";

     

       65137
        
              libraryHaskellDepends = [

     

       65138
        
                ansi-terminal base bimap bv-sized containers copilot-core

     

       65139
        
                data-default directory filepath libBF mtl panic parameterized-utils

     
···

       65296
        
              license = lib.licenses.mit;

     

       65297
        
            }) {};

     

       65298
        
       

     

       65299
       -
         "core-program_0_3_4_0" = callPackage

     

       65300
        
           ({ mkDerivation, async, base, bytestring, chronologique, core-data

     

       65301
        
            , core-text, directory, exceptions, filepath, fsnotify, hashable

     

       65302
        
            , hourglass, mtl, prettyprinter, safe-exceptions, stm

     
···

       65305
        
            }:

     

       65306
        
            mkDerivation {

     

       65307
        
              pname = "core-program";

     

       65308
       -
              version = "0.3.4.0";

     

       65309
       -
              sha256 = "079wiijdgr2vy7i8n4590p0rfakrmsxk4vx50dg992r2gfjlfzfa";

     

       65310
        
              libraryHaskellDepends = [

     

       65311
        
                async base bytestring chronologique core-data core-text directory

     

       65312
        
                exceptions filepath fsnotify hashable hourglass mtl prettyprinter

     
···

       69285
        
              license = lib.licenses.bsd3;

     

       69286
        
            }) {};

     

       69287
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       69288
        
         "d-bus" = callPackage

     

       69289
        
           ({ mkDerivation, async, attoparsec, base, binary, blaze-builder

     

       69290
        
            , bytestring, conduit, conduit-extra, containers

     
···

       73488
        
              hydraPlatforms = lib.platforms.none;

     

       73489
        
            }) {};

     

       73490
        
       

     

       73491
       -
         "deepseq_1_4_5_0" = callPackage

     

       73492
        
           ({ mkDerivation, array, base, ghc-prim, HUnit, test-framework

     

       73493
        
            , test-framework-hunit

     

       73494
        
            }:

     

       73495
        
            mkDerivation {

     

       73496
        
              pname = "deepseq";

     

       73497
       -
              version = "1.4.5.0";

     

       73498
       -
              sha256 = "0d3yw95xkyx7wwx3anfj1fqb10080xykqic483xpl7rvi1mik6js";

     

       73499
        
              libraryHaskellDepends = [ array base ];

     

       73500
        
              testHaskellDepends = [

     

       73501
        
                array base ghc-prim HUnit test-framework test-framework-hunit

     
···

       74132
        
       

     

       74133
        
         "dependent-literals" = callPackage

     

       74134
        
           ({ mkDerivation, base, fin-int, numeric-kinds, sint, snumber

     

       74135
       -
            , tagged, wrapped

     

       74136
        
            }:

     

       74137
        
            mkDerivation {

     

       74138
        
              pname = "dependent-literals";

     

       74139
       -
              version = "0.1.1.0";

     

       74140
       -
              sha256 = "0dw2xc5l8cmhsmr2akyyhyfj8m3qx02pz81fn52ii9mkhzs6rcjb";

     

       74141
       -
              revision = "5";

     

       74142
       -
              editedCabalFile = "1z2afnvgdkw6swvc1mavd8rzqcq1s124n0j13n7zd9pcjha9i4nb";

     

       74143
        
              libraryHaskellDepends = [

     

       74144
       -
                base fin-int numeric-kinds sint snumber tagged wrapped

     

       74145
        
              ];

     

       74146
        
              description = "Library for dependent-literals-plugin";

     

       74147
        
              license = lib.licenses.asl20;

     
···

       74153
        
            }:

     

       74154
        
            mkDerivation {

     

       74155
        
              pname = "dependent-literals-plugin";

     

       74156
       -
              version = "0.1.0.1";

     

       74157
       -
              sha256 = "1rpjlcv3g150rcmxidn48n25xxv2ghdz4x9jnap1swkz0fb10i3a";

     

       74158
       -
              revision = "4";

     

       74159
       -
              editedCabalFile = "1330hiqvcvl73y8pd3wpsqicvysl8l0mizkr8my7a628fwh6018p";

     

       74160
        
              libraryHaskellDepends = [ base ghc syb ];

     

       74161
        
              testHaskellDepends = [

     

       74162
        
                base dependent-literals fin-int numeric-kinds short-vec sint

     
···

       74637
        
              license = lib.licenses.bsd3;

     

       74638
        
            }) {};

     

       74639
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       74640
        
         "deriving-compat" = callPackage

     

       74641
        
           ({ mkDerivation, base, base-compat, base-orphans, containers

     

       74642
        
            , ghc-boot-th, ghc-prim, hspec, hspec-discover, QuickCheck, tagged

     
···

       75339
        
              pname = "dhall";

     

       75340
        
              version = "1.40.1";

     

       75341
        
              sha256 = "0m2fw9ak9l6fz8ylpbi0cdihf2j66jlnd5j3vf56r7wlqgbkxhi1";

     

       75342
       -
              revision = "2";

     

       75343
       -
              editedCabalFile = "0vywq222wyy8rs4114d0pq70yji7xh440i0ilqbmfywjfj2gm1pj";

     

       75344
        
              isLibrary = true;

     

       75345
        
              isExecutable = true;

     

       75346
        
              enableSeparateDataOutput = true;

     
···

       75710
        
              pname = "dhall-nixpkgs";

     

       75711
        
              version = "1.0.6";

     

       75712
        
              sha256 = "12sfxz7n86m69m1xbnrrr1ybggh70rfwmr4maflq522bhkc2hgvk";

     

       75713
       -
              revision = "1";

     

       75714
       -
              editedCabalFile = "0xy1g9ab355mdkcq30z091rr33sfw98jqjldmawrcq0yxb2gb2s6";

     

       75715
        
              isLibrary = false;

     

       75716
        
              isExecutable = true;

     

       75717
        
              executableHaskellDepends = [

     
···

       75733
        
              pname = "dhall-openapi";

     

       75734
        
              version = "1.0.2";

     

       75735
        
              sha256 = "1p678nn1gfj2xp0kmw8i5pzsv6s5bpnsmyng45adb9pnpiyxbcyj";

     

       75736
       -
              revision = "1";

     

       75737
       -
              editedCabalFile = "1mbl9ximmblz1cdm07sk8lwsxdxknhlipx91amd155xpqs72i8jg";

     

       75738
        
              isLibrary = true;

     

       75739
        
              isExecutable = true;

     

       75740
        
              libraryHaskellDepends = [

     
···

       75885
        
              pname = "dhall-yaml";

     

       75886
        
              version = "1.2.8";

     

       75887
        
              sha256 = "1p766ybwib3f2i5h7m1hh71vc255ahvf7237bpprdapqw3ag8nak";

     

       0
        
       
     

       0
        
       
     

       75888
        
              isLibrary = true;

     

       75889
        
              isExecutable = true;

     

       75890
        
              libraryHaskellDepends = [

     
···

       76310
        
            }:

     

       76311
        
            mkDerivation {

     

       76312
        
              pname = "diagrams-haddock";

     

       76313
       -
              version = "0.4.1";

     

       76314
       -
              sha256 = "0p978saxsfad6d8wkjnp6i300cf58ps02yw7a1zzhjfgk5ih2qlb";

     

       76315
       -
              revision = "1";

     

       76316
       -
              editedCabalFile = "063j6drlybzbm6bf9yfix86hs3hvgb98sgh4rzgrqkq9kvarj2ij";

     

       76317
        
              isLibrary = true;

     

       76318
        
              isExecutable = true;

     

       76319
        
              libraryHaskellDepends = [

     
···

       80053
        
              license = lib.licenses.mit;

     

       80054
        
            }) {};

     

       80055
        
       

     

       80056
       -
         "doctest_0_18_1" = callPackage

     

       80057
        
           ({ mkDerivation, base, base-compat, code-page, deepseq, directory

     

       80058
        
            , exceptions, filepath, ghc, ghc-paths, hspec, hspec-core, HUnit

     

       80059
        
            , mockery, process, QuickCheck, setenv, silently, stringbuilder

     
···

       80061
        
            }:

     

       80062
        
            mkDerivation {

     

       80063
        
              pname = "doctest";

     

       80064
       -
              version = "0.18.1";

     

       80065
       -
              sha256 = "07w77cik8p3kpcl5vx4l3cr93r1dhk3wc98k1g50l9pby5argrzb";

     

       80066
        
              isLibrary = true;

     

       80067
        
              isExecutable = true;

     

       80068
        
              libraryHaskellDepends = [

     
···

       80137
        
              pname = "doctest-driver-gen";

     

       80138
        
              version = "0.3.0.4";

     

       80139
        
              sha256 = "1fbqi4s4ajxhyv4a7nbh3v98limla0z8rfqlh02pwc1a90qpwy1a";

     

       0
        
       
     

       0
        
       
     

       80140
        
              isLibrary = true;

     

       80141
        
              isExecutable = true;

     

       80142
        
              libraryHaskellDepends = [ base ];

     
···

       88762
        
           ({ mkDerivation, base }:

     

       88763
        
            mkDerivation {

     

       88764
        
              pname = "exact-combinatorics";

     

       88765
       -
              version = "0.2.0.10";

     

       88766
       -
              sha256 = "08xdn2dl9r1zkphm9ja3lp4qin9cn889q184lsmk432icbvw5r2h";

     

       88767
       -
              libraryHaskellDepends = [ base ];

     

       88768
       -
              description = "Efficient exact computation of combinatoric functions";

     

       88769
       -
              license = lib.licenses.bsd3;

     

       88770
       -
            }) {};

     

       88771
       -
       

     

       88772
       -
         "exact-combinatorics_0_2_0_11" = callPackage

     

       88773
       -
           ({ mkDerivation, base }:

     

       88774
       -
            mkDerivation {

     

       88775
       -
              pname = "exact-combinatorics";

     

       88776
        
              version = "0.2.0.11";

     

       88777
        
              sha256 = "0qrhgd468ljpnfciaxzimmn1rhvapcrrsy4wb2r08hn3vjflmd3n";

     

       88778
        
              libraryHaskellDepends = [ base ];

     

       88779
        
              description = "Efficient exact computation of combinatoric functions";

     

       88780
        
              license = lib.licenses.bsd3;

     

       88781
       -
              hydraPlatforms = lib.platforms.none;

     

       88782
        
            }) {};

     

       88783
        
       

     

       88784
        
         "exact-cover" = callPackage

     
···

       90399
        
            }:

     

       90400
        
            mkDerivation {

     

       90401
        
              pname = "extralife";

     

       90402
       -
              version = "0.1.1.0";

     

       90403
       -
              sha256 = "0kw5lqfldncl1ci6x6izgs16hl0brrlaxin2yis279a5q4kh8xpz";

     

       90404
        
              libraryHaskellDepends = [

     

       90405
        
                aeson base bytestring http-client http-client-tls text time

     

       90406
        
              ];

     
···

       97526
        
            , http-link-header, http-types, immortal, iproute, lens, lens-aeson

     

       97527
        
            , load-env, monad-control, monad-logger, MonadRandom, mtl, network

     

       97528
        
            , network-uri, persistent, persistent-postgresql, postgresql-simple

     

       97529
       -
            , primitive, process, resource-pool, retry, rio, temporary, text

     

       97530
       -
            , time, transformers, transformers-base, unliftio, unliftio-core

     

       97531
       -
            , unordered-containers, wai, wai-extra, yaml, yesod, yesod-core

     

       0
        
       
     

       97532
        
            }:

     

       97533
        
            mkDerivation {

     

       97534
        
              pname = "freckle-app";

     

       97535
       -
              version = "1.0.1.0";

     

       97536
       -
              sha256 = "1lak6iyid14wxydzs77jlwrayrwcg3n4favrf3qf3yd46306a2f3";

     

       97537
        
              libraryHaskellDepends = [

     

       97538
        
                aeson ansi-terminal base bytestring case-insensitive conduit

     

       97539
        
                data-default datadog doctest ekg-core errors exceptions fast-logger

     
···

       97542
        
                http-types immortal iproute lens load-env monad-control

     

       97543
        
                monad-logger MonadRandom mtl network network-uri persistent

     

       97544
        
                persistent-postgresql postgresql-simple primitive process

     

       97545
       -
                resource-pool retry rio text time transformers transformers-base

     

       97546
       -
                unliftio unliftio-core unordered-containers wai wai-extra yaml

     

       97547
       -
                yesod yesod-core

     

       97548
        
              ];

     

       97549
        
              testHaskellDepends = [

     

       97550
        
                aeson base bytestring directory hspec http-types lens lens-aeson

     
···

       101431
        
            }:

     

       101432
        
            mkDerivation {

     

       101433
        
              pname = "generic-aeson";

     

       101434
       -
              version = "0.2.0.12";

     

       101435
       -
              sha256 = "17br2dl9gd2hyflgp0fzqs5ghp4my4l234pjfvvnhk9n4szxzcr3";

     

       101436
       -
              revision = "1";

     

       101437
       -
              editedCabalFile = "0nd40p8iqr6bk7py9rblpis2s8i4p5wgg6kfp607mpp4y17xq1dr";

     

       101438
       -
              libraryHaskellDepends = [

     

       101439
       -
                aeson attoparsec base generic-deriving mtl tagged text

     

       101440
       -
                unordered-containers vector

     

       101441
       -
              ];

     

       101442
       -
              description = "Derivation of Aeson instances using GHC generics";

     

       101443
       -
              license = lib.licenses.bsd3;

     

       101444
       -
            }) {};

     

       101445
       -
       

     

       101446
       -
         "generic-aeson_0_2_0_13" = callPackage

     

       101447
       -
           ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl

     

       101448
       -
            , tagged, text, unordered-containers, vector

     

       101449
       -
            }:

     

       101450
       -
            mkDerivation {

     

       101451
       -
              pname = "generic-aeson";

     

       101452
        
              version = "0.2.0.13";

     

       101453
        
              sha256 = "0w5xp1rfg3r90ja1f0s48i4x7yyynfv52p6b9ncsdqyrq3y9qvl0";

     

       101454
        
              libraryHaskellDepends = [

     
···

       101457
        
              ];

     

       101458
        
              description = "Derivation of Aeson instances using GHC generics";

     

       101459
        
              license = lib.licenses.bsd3;

     

       101460
       -
              hydraPlatforms = lib.platforms.none;

     

       101461
        
            }) {};

     

       101462
        
       

     

       101463
        
         "generic-arbitrary" = callPackage

     
···

       101915
        
              pname = "generic-random";

     

       101916
        
              version = "1.4.0.0";

     

       101917
        
              sha256 = "12rvb1dzrfjc46n9vdcw3yv773iih8vwhrac3hpzq70yp2z77jdw";

     

       0
        
       
     

       0
        
       
     

       101918
        
              libraryHaskellDepends = [ base QuickCheck ];

     

       101919
        
              testHaskellDepends = [ base deepseq QuickCheck ];

     

       101920
        
              description = "Generic random generators for QuickCheck";

     
···

       101927
        
              pname = "generic-random";

     

       101928
        
              version = "1.5.0.0";

     

       101929
        
              sha256 = "033cs5vkx57ny035ngndhg3n32jbzyp98li9559gyiz8glp79pzg";

     

       0
        
       
     

       0
        
       
     

       101930
        
              libraryHaskellDepends = [ base QuickCheck ];

     

       101931
        
              testHaskellDepends = [ base deepseq QuickCheck ];

     

       101932
        
              description = "Generic random generators for QuickCheck";

     
···

       104932
        
              license = lib.licenses.bsd3;

     

       104933
        
            }) {};

     

       104934
        
       

     

       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
        
       
     

       104935
        
         "ghc-usage" = callPackage

     

       104936
        
           ({ mkDerivation, base, containers, ghc, ghc-paths, unix }:

     

       104937
        
            mkDerivation {

     
···

       107369
        
            }:

     

       107370
        
            mkDerivation {

     

       107371
        
              pname = "git-lfs";

     

       107372
       -
              version = "1.1.2";

     

       107373
       -
              sha256 = "1kfrlpq54s5z84l5sk19vmvlqrybnyqg2nwgh452bdh13z67scmw";

     

       107374
        
              libraryHaskellDepends = [

     

       107375
        
                aeson base bytestring case-insensitive containers http-client

     

       107376
        
                http-types network-uri text

     
···

       113897
        
              license = lib.licenses.bsd3;

     

       113898
        
            }) {};

     

       113899
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       113900
        
         "greskell-core" = callPackage

     

       113901
        
           ({ mkDerivation, aeson, base, bytestring, containers, doctest

     

       113902
        
            , doctest-discover, hashable, hspec, hspec-discover, QuickCheck

     
···

       113919
        
              license = lib.licenses.bsd3;

     

       113920
        
            }) {};

     

       113921
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       113922
        
         "greskell-websocket" = callPackage

     

       113923
        
           ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring

     

       113924
        
            , greskell-core, hashtables, hspec, safe-exceptions, stm, text

     
···

       113939
        
              ];

     

       113940
        
              description = "Haskell client for Gremlin Server using WebSocket serializer";

     

       113941
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       113942
        
            }) {};

     

       113943
        
       

     

       113944
        
         "grid" = callPackage

     
···

       117210
        
       

     

       117211
        
         "hadolint" = callPackage

     

       117212
        
           ({ mkDerivation, aeson, base, bytestring, Cabal, colourista

     

       117213
       -
            , containers, cryptonite, deepseq, directory, email-validate

     

       117214
       -
            , filepath, foldl, gitrev, hspec, HsYAML, HUnit, ilist

     

       117215
       -
            , language-docker, megaparsec, mtl, network-uri

     

       117216
       -
            , optparse-applicative, parallel, parsec, semver, ShellCheck, spdx

     

       117217
       -
            , split, text, time, timerep, void

     

       117218
        
            }:

     

       117219
        
            mkDerivation {

     

       117220
        
              pname = "hadolint";

     

       117221
       -
              version = "2.7.0";

     

       117222
       -
              sha256 = "11jpqx6i7qbg4yjh8rbdz7zqjmp9r9ch9z299h72af48wrwr16fl";

     

       117223
        
              isLibrary = true;

     

       117224
        
              isExecutable = true;

     

       117225
        
              libraryHaskellDepends = [

     

       117226
        
                aeson base bytestring Cabal colourista containers cryptonite

     

       117227
       -
                deepseq directory email-validate filepath foldl HsYAML ilist

     

       117228
       -
                language-docker megaparsec mtl network-uri parallel parsec semver

     

       0
        
       
     

       117229
        
                ShellCheck spdx split text time timerep void

     

       117230
        
              ];

     

       117231
        
              executableHaskellDepends = [

     

       117232
       -
                base containers gitrev language-docker megaparsec

     

       117233
       -
                optparse-applicative text

     

       117234
        
              ];

     

       117235
        
              testHaskellDepends = [

     

       117236
       -
                aeson base bytestring containers foldl hspec HsYAML HUnit

     

       117237
       -
                language-docker megaparsec ShellCheck split text

     

       0
        
       
     

       117238
        
              ];

     

       117239
        
              description = "Dockerfile Linter JavaScript API";

     

       117240
        
              license = lib.licenses.gpl3Only;

     

       117241
       -
              hydraPlatforms = lib.platforms.none;

     

       117242
       -
              broken = true;

     

       117243
        
            }) {};

     

       117244
        
       

     

       117245
        
         "hadoop-formats" = callPackage

     
···

       125052
        
              license = lib.licenses.mit;

     

       125053
        
            }) {};

     

       125054
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       125055
        
         "hasql-migration" = callPackage

     

       125056
        
           ({ mkDerivation, base, bytestring, contravariant, cryptonite

     

       125057
        
            , directory, hasql, hasql-transaction, hspec, memory, text, time

     
···

       126227
        
              platforms = [

     

       126228
        
                "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"

     

       126229
        
              ];

     

       0
        
       
     

       126230
        
            }) {};

     

       126231
        
       

     

       126232
        
         "hbro-contrib" = callPackage

     
···

       126262
        
              platforms = [

     

       126263
        
                "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"

     

       126264
        
              ];

     

       0
        
       
     

       126265
        
            }) {};

     

       126266
        
       

     

       126267
        
         "hburg" = callPackage

     
···

       134309
        
              testHaskellDepends = [ base QuickCheck ];

     

       134310
        
              description = "Hidden Markov Models using LAPACK primitives";

     

       134311
        
              license = lib.licenses.bsd3;

     

       134312
       -
              hydraPlatforms = lib.platforms.none;

     

       134313
        
            }) {};

     

       134314
        
       

     

       134315
        
         "hmm-lapack_0_4_1" = callPackage

     
···

       137064
        
            , cryptohash, deepseq, exceptions, extra, fields-json, hpqtypes

     

       137065
        
            , lifted-base, log-base, monad-control, mtl, QuickCheck, safe

     

       137066
        
            , semigroups, tasty, tasty-bench, tasty-hunit, text, text-show

     

       137067
       -
            , time, transformers, uuid-types

     

       137068
        
            }:

     

       137069
        
            mkDerivation {

     

       137070
        
              pname = "hpqtypes-extras";

     

       137071
       -
              version = "1.12.0.1";

     

       137072
       -
              sha256 = "0qpydy2hg6fmwhwg0azgraxhjijfarns3syrv2an4ynfqcxrds9k";

     

       137073
       -
              revision = "2";

     

       137074
       -
              editedCabalFile = "0xbflhmnibji9sj1yhsm9xzy0rd9k9mhyw41ixlbdvz70jjmjykb";

     

       137075
        
              libraryHaskellDepends = [

     

       137076
        
                base base16-bytestring bytestring containers cryptohash exceptions

     

       137077
        
                extra fields-json hpqtypes lifted-base log-base monad-control mtl

     

       137078
       -
                safe semigroups text text-show

     

       137079
        
              ];

     

       137080
        
              testHaskellDepends = [

     

       137081
        
                base exceptions hpqtypes lifted-base log-base monad-control

     
···

       138931
        
            }) {};

     

       138932
        
       

     

       138933
        
         "hsc2hs" = callPackage

     

       138934
       -
           ({ mkDerivation, base, containers, directory, filepath, process

     

       138935
       -
            , tasty, tasty-hspec

     

       138936
       -
            }:

     

       138937
       -
            mkDerivation {

     

       138938
       -
              pname = "hsc2hs";

     

       138939
       -
              version = "0.68.7";

     

       138940
       -
              sha256 = "0jl94cr2jhjmvz7l9idpr352vwxlsanyiq7ya1vvrlry3vj1aygx";

     

       138941
       -
              revision = "1";

     

       138942
       -
              editedCabalFile = "0nzmlx0kdsq5231m6dbvdb5zssj1h4lkqplp8rb28z3yl5h6h3sa";

     

       138943
       -
              isLibrary = false;

     

       138944
       -
              isExecutable = true;

     

       138945
       -
              enableSeparateDataOutput = true;

     

       138946
       -
              executableHaskellDepends = [

     

       138947
       -
                base containers directory filepath process

     

       138948
       -
              ];

     

       138949
       -
              testHaskellDepends = [ base tasty tasty-hspec ];

     

       138950
       -
              description = "A preprocessor that helps with writing Haskell bindings to C code";

     

       138951
       -
              license = lib.licenses.bsd3;

     

       138952
       -
            }) {};

     

       138953
       -
       

     

       138954
       -
         "hsc2hs_0_68_8" = callPackage

     

       138955
        
           ({ mkDerivation, base, containers, directory, filepath, HUnit

     

       138956
        
            , process, test-framework, test-framework-hunit

     

       138957
        
            }:

     
···

       138970
        
              ];

     

       138971
        
              description = "A preprocessor that helps with writing Haskell bindings to C code";

     

       138972
        
              license = lib.licenses.bsd3;

     

       138973
       -
              hydraPlatforms = lib.platforms.none;

     

       138974
        
            }) {};

     

       138975
        
       

     

       138976
        
         "hsc3" = callPackage

     
···

       141107
        
              license = lib.licenses.mit;

     

       141108
        
            }) {};

     

       141109
        
       

     

       141110
       -
         "hspec_2_8_3" = callPackage

     

       141111
        
           ({ mkDerivation, base, hspec-core, hspec-discover

     

       141112
        
            , hspec-expectations, QuickCheck

     

       141113
        
            }:

     

       141114
        
            mkDerivation {

     

       141115
        
              pname = "hspec";

     

       141116
       -
              version = "2.8.3";

     

       141117
       -
              sha256 = "1ryv1qad2rw40ak6n7agfd0sib1xk2iyqpz0qhgyxwp3kkjhrn49";

     

       141118
        
              libraryHaskellDepends = [

     

       141119
        
                base hspec-core hspec-discover hspec-expectations QuickCheck

     

       141120
        
              ];

     
···

       141205
        
              license = lib.licenses.mit;

     

       141206
        
            }) {};

     

       141207
        
       

     

       141208
       -
         "hspec-core_2_8_3" = callPackage

     

       141209
        
           ({ mkDerivation, ansi-terminal, array, base, call-stack, clock

     

       141210
        
            , deepseq, directory, filepath, hspec-expectations, hspec-meta

     

       141211
        
            , HUnit, process, QuickCheck, quickcheck-io, random, setenv

     
···

       141213
        
            }:

     

       141214
        
            mkDerivation {

     

       141215
        
              pname = "hspec-core";

     

       141216
       -
              version = "2.8.3";

     

       141217
       -
              sha256 = "0khq0xa6agqcvbngzlxnvd9xwh7dmp4rsb2nzvfwsaknw2674i0k";

     

       141218
        
              libraryHaskellDepends = [

     

       141219
        
                ansi-terminal array base call-stack clock deepseq directory

     

       141220
        
                filepath hspec-expectations HUnit QuickCheck quickcheck-io random

     
···

       141271
        
              maintainers = with lib.maintainers; [ maralorn ];

     

       141272
        
            }) {};

     

       141273
        
       

     

       141274
       -
         "hspec-discover_2_8_3" = callPackage

     

       141275
        
           ({ mkDerivation, base, directory, filepath, hspec-meta, mockery

     

       141276
        
            , QuickCheck

     

       141277
        
            }:

     

       141278
        
            mkDerivation {

     

       141279
        
              pname = "hspec-discover";

     

       141280
       -
              version = "2.8.3";

     

       141281
       -
              sha256 = "09rjrq289si08cza48gcp29780rv21rs0b12xglkmbd6vfqzp6cs";

     

       0
        
       
     

       0
        
       
     

       141282
        
              isLibrary = true;

     

       141283
        
              isExecutable = true;

     

       141284
        
              libraryHaskellDepends = [ base directory filepath ];

     
···

       150091
        
            }:

     

       150092
        
            mkDerivation {

     

       150093
        
              pname = "implicit-hie-cradle";

     

       150094
       -
              version = "0.3.0.5";

     

       150095
       -
              sha256 = "0c8pyw5nx8b05wqdczy892n0knsniysrxllg2y8q5905mns8h7pc";

     

       150096
        
              libraryHaskellDepends = [

     

       150097
        
                base base16-bytestring bytestring containers directory extra

     

       150098
        
                filepath hie-bios hslogger implicit-hie process temporary text time

     
···

       150290
        
            }:

     

       150291
        
            mkDerivation {

     

       150292
        
              pname = "in-other-words";

     

       150293
       -
              version = "0.2.0.0";

     

       150294
       -
              sha256 = "0adl539jilc3rnwx9ir39y97f6h60xavzhhc8pa9vc6gqp1v4g20";

     

       150295
        
              libraryHaskellDepends = [

     

       150296
        
                async base exceptions monad-control mtl stm transformers

     

       150297
        
                transformers-base

     
···

       150389
        
              pname = "inchworm";

     

       150390
        
              version = "1.1.1.2";

     

       150391
        
              sha256 = "1dsrx48srmrqcw4y60prgnzxzr7nc7vyzjv0nnr2vaay3j6pxkii";

     

       0
        
       
     

       0
        
       
     

       150392
        
              libraryHaskellDepends = [ base ];

     

       150393
        
              description = "Simple parser combinators for lexical analysis";

     

       150394
        
              license = lib.licenses.mit;

     
···

       151927
        
              ];

     

       151928
        
              description = "Integer roots and perfect powers";

     

       151929
        
              license = lib.licenses.mit;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       151930
        
            }) {};

     

       151931
        
       

     

       151932
        
         "integer-simple" = callPackage

     
···

       152145
        
              pname = "intern";

     

       152146
        
              version = "0.9.4";

     

       152147
        
              sha256 = "00c74apc2ap1pjxmzk1c975zzqrc94p69l7v1fvfakv87mbrg8j0";

     

       0
        
       
     

       0
        
       
     

       152148
        
              libraryHaskellDepends = [

     

       152149
        
                array base bytestring hashable text unordered-containers

     

       152150
        
              ];

     
···

       153364
        
            }:

     

       153365
        
            mkDerivation {

     

       153366
        
              pname = "iproute";

     

       153367
       -
              version = "1.7.11";

     

       153368
       -
              sha256 = "12wa59b1zgjqp8dmygq2x44ml0cb89fhn1k0zkj4aqz7rhkwsp90";

     

       153369
       -
              libraryHaskellDepends = [

     

       153370
       -
                appar base byteorder bytestring containers network

     

       153371
       -
              ];

     

       153372
       -
              testHaskellDepends = [

     

       153373
       -
                appar base byteorder bytestring containers doctest hspec network

     

       153374
       -
                QuickCheck safe

     

       153375
       -
              ];

     

       153376
       -
              description = "IP Routing Table";

     

       153377
       -
              license = lib.licenses.bsd3;

     

       153378
       -
            }) {};

     

       153379
       -
       

     

       153380
       -
         "iproute_1_7_12" = callPackage

     

       153381
       -
           ({ mkDerivation, appar, base, byteorder, bytestring, containers

     

       153382
       -
            , doctest, hspec, network, QuickCheck, safe

     

       153383
       -
            }:

     

       153384
       -
            mkDerivation {

     

       153385
       -
              pname = "iproute";

     

       153386
        
              version = "1.7.12";

     

       153387
        
              sha256 = "0qvb4d7nw8f6j4s09cnpn6z1rdwcwknwklfrhsgivg7wg4aisxgi";

     

       153388
        
              libraryHaskellDepends = [

     
···

       153394
        
              ];

     

       153395
        
              description = "IP Routing Table";

     

       153396
        
              license = lib.licenses.bsd3;

     

       153397
       -
              hydraPlatforms = lib.platforms.none;

     

       153398
        
            }) {};

     

       153399
        
       

     

       153400
        
         "iptables-helpers" = callPackage

     
···

       157459
        
              license = lib.licenses.gpl3Only;

     

       157460
        
            }) {};

     

       157461
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       157462
        
         "jsons-to-schema" = callPackage

     

       157463
        
           ({ mkDerivation, aeson, aeson-pretty, base, bytestring, conduit

     

       157464
        
            , conduit-combinators, containers, Glob, hjsonschema, hspec

     
···

       158463
        
            }:

     

       158464
        
            mkDerivation {

     

       158465
        
              pname = "katip";

     

       158466
       -
              version = "0.8.6.0";

     

       158467
       -
              sha256 = "02rq2rl9cgxfay6bnxzh7r354x20hj8zdc60pfhvh3l8naslyk5z";

     

       158468
        
              libraryHaskellDepends = [

     

       158469
        
                aeson async auto-update base bytestring containers either hostname

     

       158470
        
                microlens microlens-th monad-control mtl old-locale resourcet

     
···

       159564
        
            , blaze-builder, bytestring, case-insensitive, conduit

     

       159565
        
            , conduit-extra, containers, data-default, directory, filepath

     

       159566
        
            , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy

     

       159567
       -
            , http-types, HUnit, lifted-base, mtl, network, process, random

     

       159568
       -
            , regex-tdfa, stm, tar, template-haskell, text, time, tls

     

       159569
       -
            , tls-session-manager, transformers, unix, unix-compat

     

       159570
       -
            , unordered-containers, vector, wai, wai-app-static, wai-extra

     

       159571
       -
            , warp, warp-tls, yaml, zlib

     

       159572
        
            }:

     

       159573
        
            mkDerivation {

     

       159574
        
              pname = "keter";

     

       159575
       -
              version = "1.5";

     

       159576
       -
              sha256 = "0ifz4la1hxv53cz21p3b6cn2mj4ivqj77y5ppyy47dfsbsr1ihal";

     

       159577
        
              isLibrary = true;

     

       159578
        
              isExecutable = true;

     

       159579
        
              libraryHaskellDepends = [

     

       159580
        
                aeson array async attoparsec base blaze-builder bytestring

     

       159581
        
                case-insensitive conduit conduit-extra containers data-default

     

       159582
        
                directory filepath fsnotify http-client http-conduit

     

       159583
       -
                http-reverse-proxy http-types lifted-base mtl network process

     

       159584
       -
                random regex-tdfa stm tar template-haskell text time tls

     

       159585
       -
                tls-session-manager transformers unix unix-compat

     

       159586
       -
                unordered-containers vector wai wai-app-static wai-extra warp

     

       159587
       -
                warp-tls yaml zlib

     

       159588
        
              ];

     

       159589
        
              executableHaskellDepends = [ base data-default filepath ];

     

       159590
        
              testHaskellDepends = [

     
···

       159740
        
              pname = "keys";

     

       159741
        
              version = "3.12.3";

     

       159742
        
              sha256 = "0ik6wsff306dnbz0v3gpiajlj5b558hrk9176fzcb2fclf4447nm";

     

       0
        
       
     

       0
        
       
     

       159743
        
              libraryHaskellDepends = [

     

       159744
        
                array base comonad containers free hashable semigroupoids

     

       159745
        
                semigroups tagged transformers transformers-compat

     
···

       160956
        
           ({ mkDerivation, base }:

     

       160957
        
            mkDerivation {

     

       160958
        
              pname = "lacroix";

     

       160959
       -
              version = "0.1.0.0";

     

       160960
       -
              sha256 = "0d65dqvbfrrvgdnagjyiq8xf7635rd46wda722g85dxzxr1l7mbn";

     

       160961
        
              libraryHaskellDepends = [ base ];

     

       160962
        
              description = "fizzy n dizzy";

     

       160963
        
              license = lib.licenses.mit;

     
···

       163291
        
              ];

     

       163292
        
              description = "Numerical Linear Algebra using LAPACK";

     

       163293
        
              license = lib.licenses.bsd3;

     

       163294
       -
              hydraPlatforms = lib.platforms.none;

     

       163295
       -
              broken = true;

     

       163296
        
            }) {};

     

       163297
        
       

     

       163298
        
         "lapack_0_4" = callPackage

     
···

       163324
        
              description = "Numerical Linear Algebra using LAPACK";

     

       163325
        
              license = lib.licenses.bsd3;

     

       163326
        
              hydraPlatforms = lib.platforms.none;

     

       163327
       -
              broken = true;

     

       163328
        
            }) {};

     

       163329
        
       

     

       163330
        
         "lapack-carray" = callPackage

     
···

       163410
        
              description = "Conversion of objects between 'lapack' and 'hmatrix'";

     

       163411
        
              license = lib.licenses.bsd3;

     

       163412
        
              hydraPlatforms = lib.platforms.none;

     

       0
        
       
     

       163413
        
            }) {};

     

       163414
        
       

     

       163415
        
         "large-hashable" = callPackage

     
···

       165116
        
              license = lib.licenses.bsd3;

     

       165117
        
            }) {};

     

       165118
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       165119
        
         "lens-filesystem" = callPackage

     

       165120
        
           ({ mkDerivation, base, directory, filepath, hspec, lens

     

       165121
        
            , lens-action

     
···

       166040
        
              pname = "libfuse3";

     

       166041
        
              version = "0.1.2.0";

     

       166042
        
              sha256 = "0a59b4xag5vzisrnvf4v1zkdsdzky96h8w2mdj6cip3vgr196frb";

     

       166043
       -
              revision = "3";

     

       166044
       -
              editedCabalFile = "1w59kyc8hvlmbq8n6i7nz8cg8mkzzhfizfpgcm17adxlh6a68ana";

     

       166045
        
              isLibrary = true;

     

       166046
        
              isExecutable = true;

     

       166047
        
              libraryHaskellDepends = [

     
···

       167080
        
              pname = "lift-generics";

     

       167081
        
              version = "0.2.1";

     

       167082
        
              sha256 = "1qkzq8hcb6j15cslv577bmhjcxmljzsrryysdgd7r99kr3q445b4";

     

       0
        
       
     

       0
        
       
     

       167083
        
              libraryHaskellDepends = [

     

       167084
        
                base generic-deriving ghc-prim template-haskell th-compat

     

       167085
        
              ];

     
···

       167260
        
              pname = "lifx-lan";

     

       167261
        
              version = "0.5.0.1";

     

       167262
        
              sha256 = "0rww31gcp5asbc0zb6fz7ddgw3dih6l2mc0rln7nf3qd04hplk6v";

     

       0
        
       
     

       0
        
       
     

       167263
        
              libraryHaskellDepends = [

     

       167264
        
                base binary bytestring composition containers extra monad-loops mtl

     

       167265
        
                network random safe text time transformers

     
···

       167766
        
              ];

     

       167767
        
              description = "Compute resistance of linear electrical circuits";

     

       167768
        
              license = lib.licenses.bsd3;

     

       167769
       -
              hydraPlatforms = lib.platforms.none;

     

       167770
        
            }) {};

     

       167771
        
       

     

       167772
        
         "linear-circuit_0_1_0_3" = callPackage

     
···

       167824
        
            }:

     

       167825
        
            mkDerivation {

     

       167826
        
              pname = "linear-generics";

     

       167827
       -
              version = "0.1.0.1";

     

       167828
       -
              sha256 = "0ck7gx1chrxyyn7lwbv4gn15zxgfgg7ai0i6404jprvvh72j7b8r";

     

       167829
        
              libraryHaskellDepends = [

     

       167830
        
                base containers ghc-prim template-haskell th-abstraction

     

       167831
        
              ];

     
···

       169835
        
              pname = "llvm-ffi-tools";

     

       169836
        
              version = "0.0.0.1";

     

       169837
        
              sha256 = "0nicgcdlywb8w5fr7hi5hgayv9phwslp5s47p2c30kavj7c3f3zk";

     

       0
        
       
     

       0
        
       
     

       169838
        
              isLibrary = false;

     

       169839
        
              isExecutable = true;

     

       169840
        
              executableHaskellDepends = [

     
···

       169842
        
              ];

     

       169843
        
              description = "Tools for maintaining the llvm-ffi package";

     

       169844
        
              license = lib.licenses.bsd3;

     

       169845
       -
              hydraPlatforms = lib.platforms.none;

     

       169846
       -
              broken = true;

     

       169847
        
            }) {};

     

       169848
        
       

     

       169849
        
         "llvm-general" = callPackage

     
···

       170019
        
              ];

     

       170020
        
              description = "Generate Pkg-Config configuration file for LLVM";

     

       170021
        
              license = lib.licenses.bsd3;

     

       170022
       -
              hydraPlatforms = lib.platforms.none;

     

       170023
       -
              broken = true;

     

       170024
        
            }) {};

     

       170025
        
       

     

       170026
        
         "llvm-pretty" = callPackage

     
···

       171915
        
           ({ mkDerivation, base, lua, tasty, tasty-hunit }:

     

       171916
        
            mkDerivation {

     

       171917
        
              pname = "lpeg";

     

       171918
       -
              version = "1.0.0";

     

       171919
       -
              sha256 = "01502izg6fkkp93vc2sr4csx7crqlx7zxgk85rm5kfdx7vh7qjfs";

     

       171920
        
              libraryHaskellDepends = [ base lua ];

     

       171921
        
              testHaskellDepends = [ base lua tasty tasty-hunit ];

     

       171922
        
              description = "LPeg – Parsing Expression Grammars For Lua";

     
···

       172468
        
              license = lib.licenses.bsd3;

     

       172469
        
            }) {};

     

       172470
        
       

     

       172471
       -
         "lucid_2_10_0" = callPackage

     

       172472
        
           ({ mkDerivation, base, bifunctors, blaze-builder, bytestring

     

       172473
        
            , containers, criterion, deepseq, hashable, hspec, HUnit, mmorph

     

       172474
        
            , mtl, parsec, text, transformers, unordered-containers

     

       172475
        
            }:

     

       172476
        
            mkDerivation {

     

       172477
        
              pname = "lucid";

     

       172478
       -
              version = "2.10.0";

     

       172479
       -
              sha256 = "1xzrb31n1kx6ym8za32ggy0cxmm2pcv9vm5czzsip5va6p5411yg";

     

       0
        
       
     

       0
        
       
     

       172480
        
              libraryHaskellDepends = [

     

       172481
        
                base blaze-builder bytestring containers hashable mmorph mtl text

     

       172482
        
                transformers unordered-containers

     
···

       172505
        
              testHaskellDepends = [ base lucid text ];

     

       172506
        
              description = "Use Alpine.js in your lucid templates";

     

       172507
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       172508
        
            }) {};

     

       172509
        
       

     

       172510
        
         "lucid-cdn" = callPackage

     
···

       172574
        
              license = lib.licenses.bsd3;

     

       172575
        
            }) {};

     

       172576
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       172577
        
         "lucid-svg" = callPackage

     

       172578
        
           ({ mkDerivation, base, blaze-builder, lucid, text, transformers }:

     

       172579
        
            mkDerivation {

     
···

       173803
        
              ];

     

       173804
        
              description = "Compute solutions for Magico puzzle";

     

       173805
        
              license = lib.licenses.bsd3;

     

       173806
       -
              hydraPlatforms = lib.platforms.none;

     

       173807
        
            }) {};

     

       173808
        
       

     

       173809
        
         "magico_0_0_2_2" = callPackage

     
···

       176016
        
            }:

     

       176017
        
            mkDerivation {

     

       176018
        
              pname = "matplotlib";

     

       176019
       -
              version = "0.7.5";

     

       176020
       -
              sha256 = "0iyjr6j5jp7lqrk9rqqvxz3rx8221hwz56p82zqkj3aarrvy21cs";

     

       176021
        
              libraryHaskellDepends = [

     

       176022
        
                aeson base bytestring containers deepseq filepath process split

     

       176023
        
                temporary

     
···

       176030
        
              license = lib.licenses.bsd3;

     

       176031
        
            }) {};

     

       176032
        
       

     

       176033
       -
         "matplotlib_0_7_6" = callPackage

     

       176034
        
           ({ mkDerivation, ad, aeson, base, bytestring, containers, deepseq

     

       176035
        
            , directory, filepath, process, random, raw-strings-qq, split

     

       176036
        
            , tasty, tasty-expected-failure, tasty-golden, tasty-hunit

     
···

       176038
        
            }:

     

       176039
        
            mkDerivation {

     

       176040
        
              pname = "matplotlib";

     

       176041
       -
              version = "0.7.6";

     

       176042
       -
              sha256 = "0wykzz4d6a55x3bxn9r01bvgvz26yvldgyrnz87rqncxymdawmd4";

     

       176043
        
              libraryHaskellDepends = [

     

       176044
        
                aeson base bytestring containers deepseq filepath process split

     

       176045
        
                temporary

     
···

       176283
        
            }:

     

       176284
        
            mkDerivation {

     

       176285
        
              pname = "matterhorn";

     

       176286
       -
              version = "50200.14.0";

     

       176287
       -
              sha256 = "0x0f7s4pz0ds1vg8v8qycafmg2i21542p8bmhhrzzwj2m99bgx5d";

     

       176288
        
              isLibrary = true;

     

       176289
        
              isExecutable = true;

     

       176290
        
              enableSeparateDataOutput = true;

     
···

       177858
        
              pname = "mercury-api";

     

       177859
        
              version = "0.1.0.2";

     

       177860
        
              sha256 = "0ybpc1kai85rflgdr80jd8cvwxaxmbphv82nz2p17502jrmdfkhg";

     

       177861
       -
              revision = "6";

     

       177862
       -
              editedCabalFile = "03d71mfq8nvqjr7hcpkh1q25fi1avqj35mfrrf7rkm13fr49bi7i";

     

       177863
        
              isLibrary = true;

     

       177864
        
              isExecutable = true;

     

       177865
        
              libraryHaskellDepends = [

     
···

       178620
        
              pname = "microaeson";

     

       178621
        
              version = "0.1.0.0";

     

       178622
        
              sha256 = "1hbpyz6p9snnd85h2y0pdqp20svxrggavbv0q8z33sc5i4p8b7iz";

     

       178623
       -
              revision = "3";

     

       178624
       -
              editedCabalFile = "09fbsmxlhcjazd99r05n1cla9akficbnfylszg9jkpic7g0p5pa3";

     

       178625
        
              libraryHaskellDepends = [

     

       178626
        
                array base bytestring containers deepseq text

     

       178627
        
              ];

     
···

       178867
        
              license = lib.licenses.bsd3;

     

       178868
        
            }) {};

     

       178869
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       178870
        
         "microlens-process" = callPackage

     

       178871
        
           ({ mkDerivation, base, Cabal, cabal-doctest, doctest, filepath

     

       178872
        
            , microlens, process

     
···

       179208
        
            }:

     

       179209
        
            mkDerivation {

     

       179210
        
              pname = "mighttpd2";

     

       179211
       -
              version = "4.0.1";

     

       179212
       -
              sha256 = "1vgdva68dmkmfchgf3lpa2lrs7di2v3s7snpaxbpyjbr9zrqw6gn";

     

       179213
        
              isLibrary = true;

     

       179214
        
              isExecutable = true;

     

       179215
        
              enableSeparateDataOutput = true;

     
···

       180008
        
              license = lib.licenses.bsd3;

     

       180009
        
            }) {};

     

       180010
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       180011
        
         "mios" = callPackage

     

       180012
        
           ({ mkDerivation, base, bytestring, ghc-prim, gitrev, hspec

     

       180013
        
            , primitive, vector

     
···

       180692
        
              hydraPlatforms = lib.platforms.none;

     

       180693
        
            }) {};

     

       180694
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       180695
        
         "mmorph_1_1_3" = callPackage

     

       180696
        
           ({ mkDerivation, base, mtl, transformers, transformers-compat }:

     

       180697
        
            mkDerivation {

     
···

       180838
        
            }:

     

       180839
        
            mkDerivation {

     

       180840
        
              pname = "mmsyn6ukr-array";

     

       180841
       -
              version = "0.3.0.0";

     

       180842
       -
              sha256 = "16niig3irz25g8lpx4bg6mf3i74n5162pv7555rkraxd91wy7hhw";

     

       180843
        
              isLibrary = true;

     

       180844
        
              isExecutable = true;

     

       180845
        
              enableSeparateDataOutput = true;

     
···

       182679
        
            }) {};

     

       182680
        
       

     

       182681
        
         "monad-tree" = callPackage

     

       182682
       -
           ({ mkDerivation, base }:

     

       182683
        
            mkDerivation {

     

       182684
        
              pname = "monad-tree";

     

       182685
       -
              version = "0.1.0";

     

       182686
       -
              sha256 = "1rjrcai2wqz3qkn3sk1fj6c0vvzk58gmghzwp9w9xvr09kd7zyd2";

     

       182687
       -
              libraryHaskellDepends = [ base ];

     

       182688
        
              description = "Tree data structure for nondeterministic computations";

     

       182689
        
              license = lib.licenses.mit;

     

       182690
        
            }) {};

     
···

       183339
        
              ];

     

       183340
        
              description = "Type-classes for interacting with monomorphic containers with a key";

     

       183341
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       183342
        
            }) {};

     

       183343
        
       

     

       183344
        
         "mono-traversable-wrapper" = callPackage

     
···

       184043
        
              license = lib.licenses.mit;

     

       184044
        
            }) {};

     

       184045
        
       

     

       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
        
       
     

       184046
        
         "morpheus-graphql-app" = callPackage

     

       184047
        
           ({ mkDerivation, aeson, base, bytestring, containers, directory

     

       184048
        
            , hashable, megaparsec, morpheus-graphql-core, mtl, relude

     
···

       184069
        
              license = lib.licenses.mit;

     

       184070
        
            }) {};

     

       184071
        
       

     

       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
        
       
     

       184072
        
         "morpheus-graphql-cli" = callPackage

     

       184073
        
           ({ mkDerivation, base, bytestring, filepath, morpheus-graphql

     

       184074
        
            , optparse-applicative

     
···

       184114
        
              license = lib.licenses.mit;

     

       184115
        
            }) {};

     

       184116
        
       

     

       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
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       184117
        
         "morpheus-graphql-core" = callPackage

     

       184118
        
           ({ mkDerivation, aeson, base, bytestring, containers, directory

     

       184119
        
            , hashable, megaparsec, mtl, relude, scientific, tasty, tasty-hunit

     
···

       184139
        
              license = lib.licenses.mit;

     

       184140
        
            }) {};

     

       184141
        
       

     

       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
        
       
     

       184142
        
         "morpheus-graphql-subscriptions" = callPackage

     

       184143
        
           ({ mkDerivation, aeson, base, bytestring, directory

     

       184144
        
            , morpheus-graphql-app, morpheus-graphql-core, mtl, relude, tasty

     
···

       184163
        
              license = lib.licenses.mit;

     

       184164
        
            }) {};

     

       184165
        
       

     

       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
        
       
     

       0
        
       
     

       0
        
       
     

       184166
        
         "morphisms" = callPackage

     

       184167
        
           ({ mkDerivation }:

     

       184168
        
            mkDerivation {

     
···

       188597
        
              pname = "nats";

     

       188598
        
              version = "1.1.2";

     

       188599
        
              sha256 = "1v40drmhixck3pz3mdfghamh73l4rp71mzcviipv1y8jhrfxilmr";

     

       188600
       -
              revision = "3";

     

       188601
       -
              editedCabalFile = "02ww45nskca28fsbh74iy0z4rm0yshws7lrxld45y053hrn1jdzc";

     

       188602
        
              doHaddock = false;

     

       188603
        
              description = "Natural numbers";

     

       188604
        
              license = lib.licenses.bsd3;

     
···

       190858
        
              pname = "network-transport";

     

       190859
        
              version = "0.5.4";

     

       190860
        
              sha256 = "0izcqi3zl7ynav0qqrrfmiax8vziqwrhflprddhjj6x6nkzhp1sv";

     

       0
        
       
     

       0
        
       
     

       190861
        
              libraryHaskellDepends = [

     

       190862
        
                base binary bytestring deepseq hashable transformers

     

       190863
        
              ];

     
···

       190952
        
              pname = "network-transport-tests";

     

       190953
        
              version = "0.3.0";

     

       190954
        
              sha256 = "1552mgccfyyvvnplhflkfxgg3246jgx9iiv71a0gwblllbsh5y8p";

     

       0
        
       
     

       0
        
       
     

       190955
        
              libraryHaskellDepends = [

     

       190956
        
                ansi-terminal base bytestring containers mtl network-transport

     

       190957
        
                random

     
···

       191984
        
            }) {};

     

       191985
        
       

     

       191986
        
         "nix-diff" = callPackage

     

       191987
       -
           ({ mkDerivation, attoparsec, base, containers, directory, mtl

     

       191988
       -
            , nix-derivation, optparse-applicative, patience, text, unix

     

       191989
       -
            , vector

     

       191990
        
            }:

     

       191991
        
            mkDerivation {

     

       191992
        
              pname = "nix-diff";

     

       191993
       -
              version = "1.0.15";

     

       191994
       -
              sha256 = "0sjnihdhiib45chc04hr38g12sgp9rmjx2fibha9qsqla3rjnx3y";

     

       191995
        
              isLibrary = false;

     

       191996
        
              isExecutable = true;

     

       191997
        
              executableHaskellDepends = [

     

       191998
       -
                attoparsec base containers directory mtl nix-derivation

     

       191999
       -
                optparse-applicative patience text unix vector

     

       192000
        
              ];

     

       192001
        
              description = "Explain why two Nix derivations differ";

     

       192002
        
              license = lib.licenses.bsd3;

     
···

       192174
        
            }:

     

       192175
        
            mkDerivation {

     

       192176
        
              pname = "nix-tree";

     

       192177
       -
              version = "0.1.8";

     

       192178
       -
              sha256 = "0bbisb0n7jg5ng17qyh92rbx1qphvd8w4gr6v773j8m72j24vj0c";

     

       192179
        
              isLibrary = false;

     

       192180
        
              isExecutable = true;

     

       192181
        
              executableHaskellDepends = [

     
···

       193062
        
              pname = "normalization-insensitive";

     

       193063
        
              version = "2.0.2";

     

       193064
        
              sha256 = "1rr12rrij64hi6jkd42h4x2m86k1ra10ykzpzc38n6rfdhyiswpn";

     

       0
        
       
     

       0
        
       
     

       193065
        
              libraryHaskellDepends = [

     

       193066
        
                base bytestring deepseq hashable text unicode-transforms

     

       193067
        
              ];

     
···

       193974
        
            }) {};

     

       193975
        
       

     

       193976
        
         "numeric-kinds" = callPackage

     

       193977
       -
           ({ mkDerivation, base }:

     

       193978
        
            mkDerivation {

     

       193979
        
              pname = "numeric-kinds";

     

       193980
       -
              version = "0.1.0.0";

     

       193981
       -
              sha256 = "0rdx39wa7kklx9a7i5rdwf541fxpz9v3n32rvy2fa6i7n4hr64s4";

     

       193982
       -
              revision = "2";

     

       193983
       -
              editedCabalFile = "1zlgarjmhp9mhlp8l1cygk570l0bc3yabid4c2bi1xm4ckii8cyc";

     

       193984
       -
              libraryHaskellDepends = [ base ];

     

       193985
        
              description = "Type-level numeric types and classes";

     

       193986
        
              license = lib.licenses.asl20;

     

       193987
        
            }) {};

     
···

       196005
        
              license = lib.licenses.bsd3;

     

       196006
        
            }) {};

     

       196007
        
       

     

       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
        
       
     

       196008
        
         "opaleye-classy" = callPackage

     

       196009
        
           ({ mkDerivation, base, bytestring, lens, mtl, opaleye

     

       196010
        
            , postgresql-simple, product-profunctors, transformers

     
···

       196372
        
              pname = "openapi3";

     

       196373
        
              version = "3.1.0";

     

       196374
        
              sha256 = "011754qyxxw5mn06hdmxalvsiff7a4x4k2yb2r6ylzr6zhyz818z";

     

       196375
       -
              revision = "1";

     

       196376
       -
              editedCabalFile = "1rbsfjwraizp0b6j2zaimz63b46k7d8abfxw7jyb7j1cv6jkcll1";

     

       196377
        
              isLibrary = true;

     

       196378
        
              isExecutable = true;

     

       196379
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       197262
        
            }:

     

       197263
        
            mkDerivation {

     

       197264
        
              pname = "opentracing";

     

       197265
       -
              version = "0.2.0";

     

       197266
       -
              sha256 = "1yl3hhg32npj4ncqc9j5gl2jikzvczkpnrwp124nk45mzi13aszq";

     

       197267
        
              libraryHaskellDepends = [

     

       197268
        
                aeson async base base64-bytestring bytestring case-insensitive

     

       197269
        
                clock containers http-types iproute lens mtl mwc-random network

     
···

       197441
        
              license = lib.licenses.bsd3;

     

       197442
        
            }) {};

     

       197443
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       197444
        
         "operational-alacarte" = callPackage

     

       197445
        
           ({ mkDerivation, base, mtl }:

     

       197446
        
            mkDerivation {

     
···

       198005
        
              ];

     

       198006
        
              description = "Auto-generate a command-line parser for your datatype";

     

       198007
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       198008
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       198009
        
            }) {};

     

       198010
        
       

     
···

       198617
        
            }:

     

       198618
        
            mkDerivation {

     

       198619
        
              pname = "orthotope";

     

       198620
       -
              version = "0.1.0.0";

     

       198621
       -
              sha256 = "0nx97r1svhzayf0f4chj8mprqp524hliffnw5y612lwsx41c671k";

     

       198622
        
              libraryHaskellDepends = [

     

       198623
        
                base deepseq dlist pretty QuickCheck vector

     

       198624
        
              ];

     
···

       198627
        
                test-framework-quickcheck2 vector

     

       198628
        
              ];

     

       198629
        
              description = "Multidimensional arrays inspired by APL";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       198630
        
              license = lib.licenses.asl20;

     

       198631
        
            }) {};

     

       198632
        
       

     
···

       199885
        
            }:

     

       199886
        
            mkDerivation {

     

       199887
        
              pname = "pandoc-crossref";

     

       199888
       -
              version = "0.3.12.0";

     

       199889
       -
              sha256 = "0y991lp6bgjiz67b1w6jywhwzwq5kf385pzl91s4g22lfnhwc7sz";

     

       199890
       -
              revision = "2";

     

       199891
       -
              editedCabalFile = "1gms6jaj21sycg3r1yc61xb2p1a5x2cd1z29y6jcjrh02n96g3g4";

     

       199892
        
              isLibrary = true;

     

       199893
        
              isExecutable = true;

     

       199894
        
              enableSeparateDataOutput = true;

     
···

       205714
        
              broken = true;

     

       205715
        
            }) {};

     

       205716
        
       

     

       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
        
       
     

       205717
        
         "pg-extras" = callPackage

     

       205718
        
           ({ mkDerivation, base, bytestring, HUnit, postgresql-simple

     

       205719
        
            , raw-strings-qq, text, time

     
···

       206371
        
            }:

     

       206372
        
            mkDerivation {

     

       206373
        
              pname = "phonetic-languages-simplified-base";

     

       206374
       -
              version = "0.4.0.0";

     

       206375
       -
              sha256 = "1hifw367zc5zkrka4lpjl412ka9zsbdlmn58v2hmbm3j4c09phmj";

     

       206376
        
              libraryHaskellDepends = [

     

       206377
        
                base phonetic-languages-permutations-array subG

     

       206378
        
              ];

     
···

       206409
        
            }:

     

       206410
        
            mkDerivation {

     

       206411
        
              pname = "phonetic-languages-simplified-examples-array";

     

       206412
       -
              version = "0.14.1.0";

     

       206413
       -
              sha256 = "170r88sys7xzdxmrq2l31a6g0pwzpwg601aj827f3gn5c0rm3l2p";

     

       206414
        
              isLibrary = true;

     

       206415
        
              isExecutable = true;

     

       206416
        
              libraryHaskellDepends = [

     
···

       206561
        
            }:

     

       206562
        
            mkDerivation {

     

       206563
        
              pname = "phonetic-languages-simplified-properties-array";

     

       206564
       -
              version = "0.11.0.0";

     

       206565
       -
              sha256 = "1aazfaqvaf7sjidsnvs54nw4bbsnkygv1i3fw0xvcqqzygzns9gk";

     

       206566
        
              libraryHaskellDepends = [

     

       206567
        
                base phonetic-languages-rhythmicity

     

       206568
        
                phonetic-languages-simplified-base ukrainian-phonetics-basic-array

     
···

       209808
        
              pname = "pointed";

     

       209809
        
              version = "5.0.3";

     

       209810
        
              sha256 = "0999bba0gbb2qhk1ydaslmdf7ca17ip751psi4phi1lhb250fl8b";

     

       0
        
       
     

       0
        
       
     

       209811
        
              libraryHaskellDepends = [

     

       209812
        
                base comonad containers data-default-class hashable kan-extensions

     

       209813
        
                semigroupoids semigroups stm tagged transformers

     
···

       210505
        
            }:

     

       210506
        
            mkDerivation {

     

       210507
        
              pname = "polysemy-RandomFu";

     

       210508
       -
              version = "0.4.3.0";

     

       210509
       -
              sha256 = "054v54kwkrg13nx9kznkclnmjnynh9j48bk2fjylwd9xqrj1r63a";

     

       210510
        
              libraryHaskellDepends = [

     

       210511
        
                base polysemy polysemy-plugin polysemy-zoo random-fu random-source

     

       210512
        
              ];

     
···

       212513
        
            }:

     

       212514
        
            mkDerivation {

     

       212515
        
              pname = "postgresql-migration";

     

       212516
       -
              version = "0.2.1.2";

     

       212517
       -
              sha256 = "168da2n2ky17mygrxnh9z95nwscw2b769xhykmg9d398mnz9a188";

     

       212518
       -
              revision = "1";

     

       212519
       -
              editedCabalFile = "09vzsig1jm9n6i6h7ybqlg3ffmgzyg7cpjlwaha9p7w70afjvmgh";

     

       212520
        
              isLibrary = true;

     

       212521
        
              isExecutable = true;

     

       212522
        
              libraryHaskellDepends = [

     
···

       217720
        
              pname = "pseudo-boolean";

     

       217721
        
              version = "0.1.10.0";

     

       217722
        
              sha256 = "1p9w1d80d2kp7wp7wp6xf9dz1iv9knhy8b75mklz7zq3cf5gvnrh";

     

       0
        
       
     

       0
        
       
     

       217723
        
              libraryHaskellDepends = [

     

       217724
        
                attoparsec base bytestring bytestring-builder containers deepseq

     

       217725
        
                dlist hashable megaparsec parsec void

     
···

       217805
        
            }:

     

       217806
        
            mkDerivation {

     

       217807
        
              pname = "psqueues";

     

       217808
       -
              version = "0.2.7.2";

     

       217809
       -
              sha256 = "1yckx2csqswghiy9nfj03cybmza8104nmnpbpcc9ngwlbmakn9i6";

     

       217810
       -
              revision = "1";

     

       217811
       -
              editedCabalFile = "0d0mm3c8x31dasfzp1884r2irkm3c9irvvbahjzfr1bzzxfb7vyv";

     

       217812
        
              libraryHaskellDepends = [ base deepseq ghc-prim hashable ];

     

       217813
        
              testHaskellDepends = [

     

       217814
        
                array base deepseq ghc-prim hashable HUnit QuickCheck tagged tasty

     
···

       218868
        
              license = lib.licenses.mit;

     

       218869
        
            }) {};

     

       218870
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       218871
        
         "pusher-ws" = callPackage

     

       218872
        
           ({ mkDerivation, aeson, base, bytestring, containers, deepseq

     

       218873
        
            , hashable, http-conduit, lens, lens-aeson, network, scientific

     
···

       221254
        
            }:

     

       221255
        
            mkDerivation {

     

       221256
        
              pname = "r-glpk-phonetic-languages-ukrainian-durations";

     

       221257
       -
              version = "0.4.0.0";

     

       221258
       -
              sha256 = "0rw9scbxhk5v61b7d4hwvwv4jxkkglsnzphslwashalhcfxc39p7";

     

       221259
        
              isLibrary = true;

     

       221260
        
              isExecutable = true;

     

       221261
        
              libraryHaskellDepends = [

     
···

       223875
        
            }:

     

       223876
        
            mkDerivation {

     

       223877
        
              pname = "readline-in-other-words";

     

       223878
       -
              version = "0.1.0.0";

     

       223879
       -
              sha256 = "180arjxnwz6gp4ccjk7kjhyhmic4hgcbcc8klrl79c9vqjjp6hnq";

     

       223880
        
              isLibrary = true;

     

       223881
        
              isExecutable = true;

     

       223882
        
              libraryHaskellDepends = [

     
···

       223889
        
              ];

     

       223890
        
              description = "Readline effect for in-other-words";

     

       223891
        
              license = lib.licenses.bsd2;

     

       0
        
       
     

       0
        
       
     

       223892
        
            }) {};

     

       223893
        
       

     

       223894
        
         "readline-statevar" = callPackage

     
···

       224135
        
              license = lib.licenses.mit;

     

       224136
        
            }) {};

     

       224137
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       224138
        
         "rebindable" = callPackage

     

       224139
        
           ({ mkDerivation, base, data-default-class, indexed }:

     

       224140
        
            mkDerivation {

     
···

       224212
        
            }:

     

       224213
        
            mkDerivation {

     

       224214
        
              pname = "record-dot-preprocessor";

     

       224215
       -
              version = "0.2.12";

     

       224216
       -
              sha256 = "02vyfcfanf09nd33q37jmnq0wbncvkfjn4hx4yzr62dkmh47bkkf";

     

       224217
       -
              isLibrary = true;

     

       224218
       -
              isExecutable = true;

     

       224219
       -
              libraryHaskellDepends = [ base extra ghc uniplate ];

     

       224220
       -
              executableHaskellDepends = [ base extra ];

     

       224221
       -
              testHaskellDepends = [ base extra filepath record-hasfield ];

     

       224222
       -
              description = "Preprocessor to allow record.field syntax";

     

       224223
       -
              license = lib.licenses.bsd3;

     

       224224
       -
            }) {};

     

       224225
       -
       

     

       224226
       -
         "record-dot-preprocessor_0_2_13" = callPackage

     

       224227
       -
           ({ mkDerivation, base, extra, filepath, ghc, record-hasfield

     

       224228
       -
            , uniplate

     

       224229
       -
            }:

     

       224230
       -
            mkDerivation {

     

       224231
       -
              pname = "record-dot-preprocessor";

     

       224232
        
              version = "0.2.13";

     

       224233
        
              sha256 = "0kqk8iiqhpqrr0b0bxcy0vqp159cnsf9zri45hbp4npqm2lvcw37";

     

       224234
        
              isLibrary = true;

     
···

       224238
        
              testHaskellDepends = [ base extra filepath record-hasfield ];

     

       224239
        
              description = "Preprocessor to allow record.field syntax";

     

       224240
        
              license = lib.licenses.bsd3;

     

       224241
       -
              hydraPlatforms = lib.platforms.none;

     

       224242
        
            }) {};

     

       224243
        
       

     

       224244
        
         "record-encode" = callPackage

     
···

       224807
        
              pname = "reducers";

     

       224808
        
              version = "3.12.4";

     

       224809
        
              sha256 = "0hsycdir52jdijnnvc77jj971fjrrc722v952wr62ivrvx2zarn0";

     

       0
        
       
     

       0
        
       
     

       224810
        
              libraryHaskellDepends = [

     

       224811
        
                array base bytestring containers fingertree hashable semigroupoids

     

       224812
        
                text transformers unordered-containers

     
···

       228564
        
              license = lib.licenses.mit;

     

       228565
        
            }) {};

     

       228566
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       228567
        
         "reroute" = callPackage

     

       228568
        
           ({ mkDerivation, base, criterion, deepseq, graph-core, hashable

     

       228569
        
            , hspec, http-api-data, hvect, mtl, random, regex-compat, text

     
···

       228682
        
              executableHaskellDepends = [ base comfort-array lapack ];

     

       228683
        
              description = "Compute total resistance of a cube of resistors";

     

       228684
        
              license = lib.licenses.bsd3;

     

       228685
       -
              hydraPlatforms = lib.platforms.none;

     

       228686
        
            }) {};

     

       228687
        
       

     

       228688
        
         "resistor-cube_0_0_1_3" = callPackage

     
···

       233712
        
              pname = "salak";

     

       233713
        
              version = "0.3.6";

     

       233714
        
              sha256 = "00qyd09az0ldfidfgcki8z3r9gcpxmss3iyr99as5bky29rlz9n3";

     

       233715
       -
              revision = "5";

     

       233716
       -
              editedCabalFile = "1dqanr95rrmjxfw882fa6as7n999883gfsy2765f3rprl7wlmigl";

     

       233717
        
              libraryHaskellDepends = [

     

       233718
        
                base bytestring containers data-default directory dlist exceptions

     

       233719
        
                filepath hashable heaps megaparsec mtl scientific text time

     
···

       234466
        
            }:

     

       234467
        
            mkDerivation {

     

       234468
        
              pname = "satyros";

     

       234469
       -
              version = "0.2.0.0";

     

       234470
       -
              sha256 = "12mk86a46i5k4ng8r3f7s3ccs2p9kz345v3b8p8hrmmcgksimkds";

     

       234471
        
              libraryHaskellDepends = [

     

       234472
        
                base containers extra free lens mtl random vector

     

       234473
        
              ];

     
···

       237765
        
              pname = "semigroupoids";

     

       237766
        
              version = "5.3.6";

     

       237767
        
              sha256 = "0glhqc9x8i5z3bdg23xvl2lfns95msid3h3x0jksna7i6c8j869n";

     

       237768
       -
              revision = "1";

     

       237769
       -
              editedCabalFile = "0inbks8x588bpcw7kyap69iy0zrkygycp8hwgrd9yhbxlvj9hmh9";

     

       237770
        
              libraryHaskellDepends = [

     

       237771
        
                base base-orphans bifunctors comonad containers contravariant

     

       237772
        
                distributive hashable tagged template-haskell transformers

     
···

       238014
        
            }:

     

       238015
        
            mkDerivation {

     

       238016
        
              pname = "sensei";

     

       238017
       -
              version = "0.5.0";

     

       238018
       -
              sha256 = "011lck879q12npszqf2cjsxyjrcyfhrs77dh8kbififm53dfglf4";

     

       238019
        
              isLibrary = false;

     

       238020
        
              isExecutable = true;

     

       238021
        
              executableHaskellDepends = [

     
···

       240010
        
            }:

     

       240011
        
            mkDerivation {

     

       240012
        
              pname = "servant-lucid";

     

       240013
       -
              version = "0.9.0.2";

     

       240014
       -
              sha256 = "0l68dffx746j3p2l5x59cj5cdng2dw6vjq5x5h44m0ccbsmlckpz";

     

       240015
        
              libraryHaskellDepends = [ base http-media lucid servant text ];

     

       240016
        
              testHaskellDepends = [ base lucid servant-server wai warp ];

     

       240017
        
              description = "Servant support for lucid";

     
···

       244417
        
              license = lib.licenses.bsd3;

     

       244418
        
            }) {};

     

       244419
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       244420
        
         "silkscreen" = callPackage

     

       244421
        
           ({ mkDerivation, base, prettyprinter }:

     

       244422
        
            mkDerivation {

     
···

       245936
        
              license = lib.licenses.bsd3;

     

       245937
        
            }) {};

     

       245938
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       245939
        
         "singletons-th" = callPackage

     

       245940
        
           ({ mkDerivation, base, containers, ghc-boot-th, mtl, singletons

     

       245941
        
            , syb, template-haskell, th-desugar, th-orphans, transformers

     
···

       249704
        
            }) {};

     

       249705
        
       

     

       249706
        
         "snumber" = callPackage

     

       249707
       -
           ({ mkDerivation, base, numeric-kinds }:

     

       249708
        
            mkDerivation {

     

       249709
        
              pname = "snumber";

     

       249710
       -
              version = "0.2.0";

     

       249711
       -
              sha256 = "0q1xswnh1rymnyi3jpn4fn6fwj36haamwri7ifd4f7jm2a9v1isx";

     

       249712
       -
              revision = "1";

     

       249713
       -
              editedCabalFile = "1ai6syqkwa0rl23f23hv6wkqg274lrdsh6jqyy9xiklcl8j3bz5w";

     

       249714
       -
              libraryHaskellDepends = [ base numeric-kinds ];

     

       249715
        
              description = "Integer singletons with flexible representation";

     

       249716
        
              license = lib.licenses.asl20;

     

       249717
        
            }) {};

     
···

       251185
        
              pname = "special-values";

     

       251186
        
              version = "0.1.0.0";

     

       251187
        
              sha256 = "1kkdw2c4d2hha99v9f89ahmifjxp7fxmxyfwq9a8xk6s0h9xs51w";

     

       0
        
       
     

       0
        
       
     

       251188
        
              libraryHaskellDepends = [

     

       251189
        
                base bytestring ieee754 scientific text

     

       251190
        
              ];

     
···

       256205
        
              license = lib.licenses.mit;

     

       256206
        
            }) {};

     

       256207
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       256208
        
         "streaming-concurrency" = callPackage

     

       256209
        
           ({ mkDerivation, base, exceptions, hspec, HUnit, lifted-async

     

       256210
        
            , monad-control, QuickCheck, quickcheck-instances, stm, streaming

     
···

       259669
        
              license = lib.licenses.bsd3;

     

       259670
        
            }) {};

     

       259671
        
       

     

       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
        
       
     

       259672
        
         "swapper" = callPackage

     

       259673
        
           ({ mkDerivation, base, binary, bytestring, deepseq, happstack-data

     

       259674
        
            , happstack-state, parallel, tokyocabinet

     
···

       259786
        
              license = lib.licenses.lgpl21Only;

     

       259787
        
            }) {};

     

       259788
        
       

     

       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
        
       
     

       259789
        
         "swiss-ephemeris" = callPackage

     

       259790
        
           ({ mkDerivation, base, directory, hspec, hspec-discover, QuickCheck

     

       0
        
       
     

       259791
        
            }:

     

       259792
        
            mkDerivation {

     

       259793
        
              pname = "swiss-ephemeris";

     

       259794
       -
              version = "1.3.0.2";

     

       259795
       -
              sha256 = "0p8fzkd4wqvmc5fjlsb0ri6645n1rg304m8nm9085ipy1svi7sn0";

     

       259796
       -
              libraryHaskellDepends = [ base ];

     

       259797
       -
              testHaskellDepends = [ base directory hspec QuickCheck ];

     

       0
        
       
     

       0
        
       
     

       259798
        
              testToolDepends = [ hspec-discover ];

     

       259799
        
              description = "Haskell bindings for the Swiss Ephemeris C library";

     

       259800
        
              license = lib.licenses.agpl3Only;

     
···

       261283
        
              platforms = [

     

       261284
        
                "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"

     

       261285
        
              ];

     

       261286
       -
              hydraPlatforms = lib.platforms.none;

     

       261287
       -
              broken = true;

     

       261288
        
            }) {};

     

       261289
        
       

     

       261290
        
         "synthesizer-core" = callPackage

     
···

       262890
        
            }) {};

     

       262891
        
       

     

       262892
        
         "tangle" = callPackage

     

       262893
       -
           ({ mkDerivation, base, transformers }:

     

       262894
        
            mkDerivation {

     

       262895
        
              pname = "tangle";

     

       262896
       -
              version = "0";

     

       262897
       -
              sha256 = "1ylv73v6ydf39zfks9762dsz27sxr7sbmmk7k628yqc9czj3nj60";

     

       262898
       -
              libraryHaskellDepends = [ base transformers ];

     

       262899
       -
              description = "HKD record builder";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       262900
        
              license = lib.licenses.bsd3;

     

       262901
        
            }) {};

     

       262902
        
       

     
···

       267436
        
              license = lib.licenses.bsd3;

     

       267437
        
            }) {};

     

       267438
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       267439
        
         "text-regex-replace" = callPackage

     

       267440
        
           ({ mkDerivation, attoparsec, base, hspec, QuickCheck, smallcheck

     

       267441
        
            , text, text-icu

     
···

       268230
        
            }) {};

     

       268231
        
       

     

       268232
        
         "th-env" = callPackage

     

       268233
       -
           ({ mkDerivation, base, markdown-unlit, template-haskell }:

     

       268234
       -
            mkDerivation {

     

       268235
       -
              pname = "th-env";

     

       268236
       -
              version = "0.1.0.2";

     

       268237
       -
              sha256 = "13rs6p5mq92am9i80c829dcmsrpbihdq8ds6ad7rdl2d23i9pln0";

     

       268238
       -
              libraryHaskellDepends = [ base template-haskell ];

     

       268239
       -
              testHaskellDepends = [ base markdown-unlit ];

     

       268240
       -
              testToolDepends = [ markdown-unlit ];

     

       268241
       -
              description = "Template Haskell splice that expands to an environment variable";

     

       268242
       -
              license = lib.licenses.bsd3;

     

       268243
       -
            }) {};

     

       268244
       -
       

     

       268245
       -
         "th-env_0_1_0_3" = callPackage

     

       268246
        
           ({ mkDerivation, base, markdown-unlit, template-haskell, th-compat

     

       268247
        
            }:

     

       268248
        
            mkDerivation {

     
···

       268254
        
              testToolDepends = [ markdown-unlit ];

     

       268255
        
              description = "Template Haskell splice that expands to an environment variable";

     

       268256
        
              license = lib.licenses.bsd3;

     

       268257
       -
              hydraPlatforms = lib.platforms.none;

     

       268258
        
            }) {};

     

       268259
        
       

     

       268260
        
         "th-expand-syns" = callPackage

     
···

       268641
        
              license = lib.licenses.bsd3;

     

       268642
        
            }) {};

     

       268643
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       268644
        
         "th-to-exp" = callPackage

     

       268645
        
           ({ mkDerivation, base, hspec, template-haskell }:

     

       268646
        
            mkDerivation {

     
···

       269269
        
              pname = "threepenny-gui";

     

       269270
        
              version = "0.9.1.0";

     

       269271
        
              sha256 = "00sjkfa9qfnnwqfdw68yb8hq6nm1y5qv9896rzn5aachr7mlfpx2";

     

       269272
       -
              revision = "2";

     

       269273
       -
              editedCabalFile = "0pbdkl9gvs6jrwfhrkfyrzra5mw8zy8pycp49czbhghwck51bf8i";

     

       269274
        
              isLibrary = true;

     

       269275
        
              isExecutable = true;

     

       269276
        
              enableSeparateDataOutput = true;

     
···

       270589
        
            }) {};

     

       270590
        
       

     

       270591
        
         "timers-tick" = callPackage

     

       270592
       -
           ({ mkDerivation, base, hspec }:

     

       270593
        
            mkDerivation {

     

       270594
        
              pname = "timers-tick";

     

       270595
       -
              version = "0.4.3.0";

     

       270596
       -
              sha256 = "02qsla7az60ch515hns1nychpdb35xlz2g4iy7jp2d5ak6jzma5r";

     

       270597
        
              libraryHaskellDepends = [ base ];

     

       270598
       -
              testHaskellDepends = [ base hspec ];

     

       270599
        
              description = "tick based timers";

     

       270600
        
              license = lib.licenses.bsd3;

     

       270601
        
            }) {};

     
···

       272095
        
              license = lib.licenses.mpl20;

     

       272096
        
            }) {};

     

       272097
        
       

     

       272098
       -
         "tomland_1_3_3_0" = callPackage

     

       272099
        
           ({ mkDerivation, base, bytestring, containers, deepseq, directory

     

       272100
        
            , hashable, hedgehog, hspec, hspec-hedgehog, hspec-megaparsec

     

       272101
       -
            , markdown-unlit, megaparsec, mtl, parser-combinators, text, time

     

       272102
       -
            , transformers, unordered-containers, validation-selective

     

       272103
        
            }:

     

       272104
        
            mkDerivation {

     

       272105
        
              pname = "tomland";

     

       272106
       -
              version = "1.3.3.0";

     

       272107
       -
              sha256 = "1masnbr5x75727k2rmgcmxqm91139v9wy434ml5a4c3dsry7xyhv";

     

       272108
        
              isLibrary = true;

     

       272109
        
              isExecutable = true;

     

       272110
        
              libraryHaskellDepends = [

     
···

       272112
        
                parser-combinators text time transformers unordered-containers

     

       272113
        
                validation-selective

     

       272114
        
              ];

     

       272115
       -
              executableHaskellDepends = [

     

       272116
       -
                base bytestring containers hashable text time unordered-containers

     

       272117
       -
              ];

     

       272118
       -
              executableToolDepends = [ markdown-unlit ];

     

       272119
        
              testHaskellDepends = [

     

       272120
        
                base bytestring containers directory hashable hedgehog hspec

     

       272121
        
                hspec-hedgehog hspec-megaparsec megaparsec text time

     
···

       276318
        
              hydraPlatforms = lib.platforms.none;

     

       276319
        
            }) {};

     

       276320
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       276321
        
         "type-digits" = callPackage

     

       276322
        
           ({ mkDerivation, base, template-haskell, type-spine }:

     

       276323
        
            mkDerivation {

     
···

       277448
        
            }:

     

       277449
        
            mkDerivation {

     

       277450
        
              pname = "typesafe-precure";

     

       277451
       -
              version = "0.8.0.1";

     

       277452
       -
              sha256 = "05rsyiksmw3gilr944hr1q12alinsy842qwzvc444iwyvc4f0i17";

     

       277453
        
              libraryHaskellDepends = [

     

       277454
        
                aeson aeson-pretty autoexporter base bytestring dlist

     

       277455
        
                monad-skeleton template-haskell text th-data-compat

     
···

       278147
        
           ({ mkDerivation, base, bytestring, mmsyn2-array, mmsyn5 }:

     

       278148
        
            mkDerivation {

     

       278149
        
              pname = "ukrainian-phonetics-basic-array";

     

       278150
       -
              version = "0.4.1.0";

     

       278151
       -
              sha256 = "09gs3d37njv5acr6nqcw899y0pycy4qxnqc36d7f4r8ny4w8lvp5";

     

       278152
        
              libraryHaskellDepends = [ base bytestring mmsyn2-array mmsyn5 ];

     

       278153
        
              description = "A library to work with the basic Ukrainian phonetics and syllable segmentation";

     

       278154
        
              license = lib.licenses.mit;

     
···

       278769
        
              license = lib.licenses.bsd2;

     

       278770
        
            }) {};

     

       278771
        
       

     

       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
        
       
     

       278772
        
         "unicode-data" = callPackage

     

       278773
        
           ({ mkDerivation, base }:

     

       278774
        
            mkDerivation {

     
···

       278856
        
              pname = "unicode-show";

     

       278857
        
              version = "0.1.0.4";

     

       278858
        
              sha256 = "158vnv6d7s1ahm3fr5s8ns585bcds8pf19rsglsyfk33qps3il9i";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       278859
        
              libraryHaskellDepends = [ base ];

     

       278860
        
              testHaskellDepends = [ base hspec QuickCheck ];

     

       278861
        
              description = "print and show in unicode";

     
···

       279134
        
              pname = "union";

     

       279135
        
              version = "0.1.2";

     

       279136
        
              sha256 = "1i4fvlwkw1wx64a6l8342aqfqsdq7fqa4p24g3i5gn5704lxrsb3";

     

       279137
       -
              revision = "6";

     

       279138
       -
              editedCabalFile = "1n1innjiqksancaazsczryyjfr7905q1iq9radwqq5ngl8xi83wz";

     

       279139
        
              libraryHaskellDepends = [

     

       279140
        
                base deepseq hashable profunctors tagged vinyl

     

       279141
        
              ];

     
···

       279262
        
              pname = "unique";

     

       279263
        
              version = "0.0.1";

     

       279264
        
              sha256 = "1dgln2dr64ma1isqskj1qnjslg9smmr7jssg8hmk68wp36i3rwkd";

     

       0
        
       
     

       0
        
       
     

       279265
        
              libraryHaskellDepends = [ base hashable ];

     

       279266
        
              description = "Fully concurrent unique identifiers";

     

       279267
        
              license = lib.licenses.bsd3;

     
···

       279896
        
           ({ mkDerivation, base, bytestring }:

     

       279897
        
            mkDerivation {

     

       279898
        
              pname = "unix-bytestring";

     

       279899
       -
              version = "0.3.7.5";

     

       279900
       -
              sha256 = "003003nh00aww2k8wdygjp0z7f61z8nz8840iinww83xph5wsih5";

     

       279901
       -
              libraryHaskellDepends = [ base bytestring ];

     

       279902
       -
              description = "Unix/Posix-specific functions for ByteStrings";

     

       279903
       -
              license = lib.licenses.bsd3;

     

       279904
       -
            }) {};

     

       279905
       -
       

     

       279906
       -
         "unix-bytestring_0_3_7_6" = callPackage

     

       279907
       -
           ({ mkDerivation, base, bytestring }:

     

       279908
       -
            mkDerivation {

     

       279909
       -
              pname = "unix-bytestring";

     

       279910
        
              version = "0.3.7.6";

     

       279911
        
              sha256 = "1f9hf7blxy8ckakd0klrs16q0hfvxfarbjgyrc7azgbb86m1skb3";

     

       279912
        
              libraryHaskellDepends = [ base bytestring ];

     

       279913
        
              description = "Unix/Posix-specific functions for ByteStrings";

     

       279914
        
              license = lib.licenses.bsd3;

     

       279915
       -
              hydraPlatforms = lib.platforms.none;

     

       279916
        
            }) {};

     

       279917
        
       

     

       279918
        
         "unix-compat" = callPackage

     
···

       280319
        
              ];

     

       280320
        
              description = "Efficient hashing-based container types";

     

       280321
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       280322
        
            }) {};

     

       280323
        
       

     

       280324
        
         "unordered-containers-rematch" = callPackage

     
···

       283963
        
              license = lib.licenses.bsd3;

     

       283964
        
            }) {};

     

       283965
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       283966
        
         "vectortiles" = callPackage

     

       283967
        
           ({ mkDerivation, base, bytestring, containers, criterion, deepseq

     

       283968
        
            , hashable, microlens, microlens-platform, mtl, protocol-buffers

     
···

       284016
        
            }:

     

       284017
        
            mkDerivation {

     

       284018
        
              pname = "venzone";

     

       284019
       -
              version = "1.0.0.6";

     

       284020
       -
              sha256 = "1x0034ww13apr1g6mscncacri3nvnmjll7spsip1dnc70ilffk77";

     

       284021
        
              isLibrary = false;

     

       284022
        
              isExecutable = true;

     

       284023
        
              enableSeparateDataOutput = true;

     
···

       285421
        
            }:

     

       285422
        
            mkDerivation {

     

       285423
        
              pname = "vulkan";

     

       285424
       -
              version = "3.13.1";

     

       285425
       -
              sha256 = "1z5a7flk0c68p70l4mqc8ws45l4yqj4rfrcqshbbfqq54dwc5nlx";

     

       285426
        
              libraryHaskellDepends = [ base bytestring transformers vector ];

     

       285427
        
              libraryPkgconfigDepends = [ vulkan ];

     

       285428
        
              testHaskellDepends = [

     
···

       289014
        
              description = "Binding to the Webkit library";

     

       289015
        
              license = lib.licenses.lgpl21Only;

     

       289016
        
              hydraPlatforms = lib.platforms.none;

     

       0
        
       
     

       289017
        
            }) {inherit (pkgs) webkitgtk;};

     

       289018
        
       

     

       289019
        
         "webkitgtk3-javascriptcore" = callPackage

     
···

       290266
        
              pname = "witherable";

     

       290267
        
              version = "0.4.2";

     

       290268
        
              sha256 = "0121ic4xkv3k568j23zp22a5lrv0k11h94fq7cbijd18fjr2n3br";

     

       0
        
       
     

       0
        
       
     

       290269
        
              libraryHaskellDepends = [

     

       290270
        
                base base-orphans containers hashable indexed-traversable

     

       290271
        
                indexed-traversable-instances transformers unordered-containers

     
···

       293832
        
            }:

     

       293833
        
            mkDerivation {

     

       293834
        
              pname = "xmobar";

     

       293835
       -
              version = "0.39";

     

       293836
       -
              sha256 = "1k1n3ff0ikdmfq0mi8r2vpqg1iq6hsw1drvxps6k98rvvn87pws6";

     

       293837
        
              configureFlags = [

     

       293838
        
                "-fwith_alsa" "-fwith_conduit" "-fwith_datezone" "-fwith_dbus"

     

       293839
        
                "-fwith_inotify" "-fwith_iwlib" "-fwith_mpd" "-fwith_mpris"

···

       7320
        
              license = lib.licenses.bsd3;

     

       7321
        
            }) {};

     

       7322
        
       

     

       7323
       +
         "Glob_0_10_2" = callPackage

     

       7324
       +
           ({ mkDerivation, base, containers, directory, dlist, filepath

     

       7325
       +
            , HUnit, QuickCheck, test-framework, test-framework-hunit

     

       7326
       +
            , test-framework-quickcheck2, transformers, transformers-compat

     

       7327
       +
            }:

     

       7328
       +
            mkDerivation {

     

       7329
       +
              pname = "Glob";

     

       7330
       +
              version = "0.10.2";

     

       7331
       +
              sha256 = "1h3kh46qds4nqvixm4myy1kb5slg53f44hfn8aymrlr7hjn75xka";

     

       7332
       +
              libraryHaskellDepends = [

     

       7333
       +
                base containers directory dlist filepath transformers

     

       7334
       +
                transformers-compat

     

       7335
       +
              ];

     

       7336
       +
              testHaskellDepends = [

     

       7337
       +
                base containers directory dlist filepath HUnit QuickCheck

     

       7338
       +
                test-framework test-framework-hunit test-framework-quickcheck2

     

       7339
       +
                transformers transformers-compat

     

       7340
       +
              ];

     

       7341
       +
              description = "Globbing library";

     

       7342
       +
              license = lib.licenses.bsd3;

     

       7343
       +
              hydraPlatforms = lib.platforms.none;

     

       7344
       +
            }) {};

     

       7345
       +
       

     

       7346
        
         "GlomeTrace" = callPackage

     

       7347
        
           ({ mkDerivation, array, base, GlomeVec }:

     

       7348
        
            mkDerivation {

     
···

       10929
        
              pname = "HsYAML";

     

       10930
        
              version = "0.2.1.0";

     

       10931
        
              sha256 = "10qzhsg789h37q22hm9p27dx4rhbykcbxp7p3pvkws8fr7ajgxv0";

     

       10932
       +
              revision = "3";

     

       10933
       +
              editedCabalFile = "0qj6180459mx08v3m8x8nw2a8a7srw2q48dh4d9qgwd1rl499a5i";

     

       10934
        
              isLibrary = true;

     

       10935
        
              isExecutable = true;

     

       10936
        
              libraryHaskellDepends = [

     
···

       10960
        
              ];

     

       10961
        
              description = "JSON to YAML Adapter";

     

       10962
        
              license = lib.licenses.gpl2Plus;

     

       10963
       +
            }) {};

     

       10964
       +
       

     

       10965
       +
         "HsYAML-aeson_0_2_0_1" = callPackage

     

       10966
       +
           ({ mkDerivation, aeson, base, bytestring, containers, HsYAML, mtl

     

       10967
       +
            , scientific, text, unordered-containers, vector

     

       10968
       +
            }:

     

       10969
       +
            mkDerivation {

     

       10970
       +
              pname = "HsYAML-aeson";

     

       10971
       +
              version = "0.2.0.1";

     

       10972
       +
              sha256 = "139hqd07hkr8ykvrgmcshh9f3vp9dnrj6ks5nl8hgrpi990jsy5r";

     

       10973
       +
              isLibrary = true;

     

       10974
       +
              isExecutable = true;

     

       10975
       +
              libraryHaskellDepends = [

     

       10976
       +
                aeson base bytestring containers HsYAML mtl scientific text

     

       10977
       +
                unordered-containers vector

     

       10978
       +
              ];

     

       10979
       +
              description = "JSON to YAML Adapter";

     

       10980
       +
              license = lib.licenses.gpl2Plus;

     

       10981
       +
              hydraPlatforms = lib.platforms.none;

     

       10982
        
            }) {};

     

       10983
        
       

     

       10984
        
         "Hsed" = callPackage

     
···

       17149
        
              license = lib.licenses.bsd3;

     

       17150
        
            }) {};

     

       17151
        
       

     

       17152
       +
         "Rattus_0_5_0_1" = callPackage

     

       17153
       +
           ({ mkDerivation, base, Cabal, containers, ghc, ghc-prim

     

       17154
       +
            , simple-affine-space, transformers

     

       17155
       +
            }:

     

       17156
       +
            mkDerivation {

     

       17157
       +
              pname = "Rattus";

     

       17158
       +
              version = "0.5.0.1";

     

       17159
       +
              sha256 = "1rj29wbhk9bn7mazhrqcgas8m7rnfcak10krimsn08v2nzw2af79";

     

       17160
       +
              setupHaskellDepends = [ base Cabal ];

     

       17161
       +
              libraryHaskellDepends = [

     

       17162
       +
                base containers ghc ghc-prim simple-affine-space transformers

     

       17163
       +
              ];

     

       17164
       +
              testHaskellDepends = [ base containers ];

     

       17165
       +
              description = "A modal FRP language";

     

       17166
       +
              license = lib.licenses.bsd3;

     

       17167
       +
              hydraPlatforms = lib.platforms.none;

     

       17168
       +
            }) {};

     

       17169
       +
       

     

       17170
        
         "ReadArgs" = callPackage

     

       17171
        
           ({ mkDerivation, base, hspec, system-filepath, text }:

     

       17172
        
            mkDerivation {

     
···

       17416
        
            }:

     

       17417
        
            mkDerivation {

     

       17418
        
              pname = "RtMidi";

     

       17419
       +
              version = "0.5.0.2";

     

       17420
       +
              sha256 = "1mlb611ilamjd884da57zy5c2jga4d5nbjy2yphnn0fcn7lzymyk";

     

       17421
        
              isLibrary = true;

     

       17422
        
              isExecutable = true;

     

       17423
        
              libraryHaskellDepends = [ base deepseq unliftio-core vector ];

     
···

       18386
        
              license = lib.licenses.gpl3Only;

     

       18387
        
            }) {};

     

       18388
        
       

     

       18389
       +
         "ShellCheck_0_8_0" = callPackage

     

       18390
       +
           ({ mkDerivation, aeson, array, base, bytestring, containers

     

       18391
       +
            , deepseq, Diff, directory, filepath, mtl, parsec, process

     

       18392
       +
            , QuickCheck, regex-tdfa

     

       18393
       +
            }:

     

       18394
       +
            mkDerivation {

     

       18395
       +
              pname = "ShellCheck";

     

       18396
       +
              version = "0.8.0";

     

       18397
       +
              sha256 = "05jlapp4m997w36h2wszdxz9gvczdczaylypsbn14jqpb650w232";

     

       18398
       +
              isLibrary = true;

     

       18399
       +
              isExecutable = true;

     

       18400
       +
              libraryHaskellDepends = [

     

       18401
       +
                aeson array base bytestring containers deepseq Diff directory

     

       18402
       +
                filepath mtl parsec process QuickCheck regex-tdfa

     

       18403
       +
              ];

     

       18404
       +
              executableHaskellDepends = [

     

       18405
       +
                aeson array base bytestring containers deepseq Diff directory

     

       18406
       +
                filepath mtl parsec QuickCheck regex-tdfa

     

       18407
       +
              ];

     

       18408
       +
              testHaskellDepends = [

     

       18409
       +
                aeson array base bytestring containers deepseq Diff directory

     

       18410
       +
                filepath mtl parsec QuickCheck regex-tdfa

     

       18411
       +
              ];

     

       18412
       +
              description = "Shell script analysis tool";

     

       18413
       +
              license = lib.licenses.gpl3Only;

     

       18414
       +
              hydraPlatforms = lib.platforms.none;

     

       18415
       +
            }) {};

     

       18416
       +
       

     

       18417
        
         "Shellac" = callPackage

     

       18418
        
           ({ mkDerivation, base, directory, mtl, unix }:

     

       18419
        
            mkDerivation {

     
···

       21003
        
           ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:

     

       21004
        
            mkDerivation {

     

       21005
        
              pname = "VulkanMemoryAllocator";

     

       21006
       +
              version = "0.7.4";

     

       21007
       +
              sha256 = "0rzvishkjp4vjwc64a12knj1kr7c793ncpgf9x54l2xj6q7a9mrj";

     

       21008
        
              libraryHaskellDepends = [

     

       21009
        
                base bytestring transformers vector vulkan

     

       21010
        
              ];

     
···

       21363
        
              platforms = lib.platforms.none;

     

       21364
        
            }) {};

     

       21365
        
       

     

       21366
       +
         "Win32_2_13_1_0" = callPackage

     

       21367
        
           ({ mkDerivation }:

     

       21368
        
            mkDerivation {

     

       21369
        
              pname = "Win32";

     

       21370
       +
              version = "2.13.1.0";

     

       21371
       +
              sha256 = "1a86hmkba4gd1qqfanl06vi2r77ip53l3dcbgvjp7wlp6rjampvc";

     

       21372
        
              description = "A binding to Windows Win32 API";

     

       21373
        
              license = lib.licenses.bsd3;

     

       21374
        
              platforms = lib.platforms.none;

     
···

       24192
        
              license = lib.licenses.bsd3;

     

       24193
        
            }) {};

     

       24194
        
       

     

       24195
       +
         "ad_4_5" = callPackage

     

       24196
       +
           ({ mkDerivation, adjunctions, array, base, comonad, containers

     

       24197
       +
            , criterion, data-reify, erf, free, nats, reflection, semigroups

     

       24198
       +
            , transformers

     

       24199
       +
            }:

     

       24200
       +
            mkDerivation {

     

       24201
       +
              pname = "ad";

     

       24202
       +
              version = "4.5";

     

       24203
       +
              sha256 = "1v37ckxcav3aicv4vv7y77mmvinfwd8mxzcnm672mmxq1d29vpsc";

     

       24204
       +
              libraryHaskellDepends = [

     

       24205
       +
                adjunctions array base comonad containers data-reify erf free nats

     

       24206
       +
                reflection semigroups transformers

     

       24207
       +
              ];

     

       24208
       +
              benchmarkHaskellDepends = [ base criterion erf ];

     

       24209
       +
              description = "Automatic Differentiation";

     

       24210
       +
              license = lib.licenses.bsd3;

     

       24211
       +
              hydraPlatforms = lib.platforms.none;

     

       24212
       +
            }) {};

     

       24213
       +
       

     

       24214
        
         "ad-delcont" = callPackage

     

       24215
        
           ({ mkDerivation, base, transformers }:

     

       24216
        
            mkDerivation {

     
···

       26810
        
            }:

     

       26811
        
            mkDerivation {

     

       26812
        
              pname = "algorithmic-composition-basic";

     

       26813
       +
              version = "0.4.1.0";

     

       26814
       +
              sha256 = "1k5rsz1c67zzdxh56w9rr1mgnv7jmwbfn4z2ysq1ny1vgyi4m7ry";

     

       26815
        
              libraryHaskellDepends = [

     

       26816
        
                base bytestring directory foldable-ix mmsyn2-array mmsyn3 mmsyn7l

     

       26817
        
                mmsyn7ukr-common process process-sequential

     
···

       30674
        
            }:

     

       30675
        
            mkDerivation {

     

       30676
        
              pname = "ansi-terminal-game";

     

       30677
       +
              version = "1.5.0.0";

     

       30678
       +
              sha256 = "161n02iywllrr49b1mzpa8lav9w41cmng7ca5vfhpxjjydd5rcbx";

     

       30679
        
              isLibrary = true;

     

       30680
        
              isExecutable = true;

     

       30681
        
              libraryHaskellDepends = [

     
···

       32879
        
            }:

     

       32880
        
            mkDerivation {

     

       32881
        
              pname = "arduino-copilot";

     

       32882
       +
              version = "1.5.6";

     

       32883
       +
              sha256 = "06aqavds6lh4iazrlz62dhdxim0q8xqdgafj7y3f8nnmv8w37g41";

     

       32884
        
              libraryHaskellDepends = [

     

       32885
        
                base containers copilot copilot-c99 copilot-language directory

     

       32886
        
                filepath mtl optparse-applicative temporary

     
···

       32956
        
            }:

     

       32957
        
            mkDerivation {

     

       32958
        
              pname = "argo";

     

       32959
       +
              version = "0.2021.11.7";

     

       32960
       +
              sha256 = "1lmx938ydl94rmzifk5jbgmfx0p64chkl7dfp1rfxwvbmlp1aydy";

     

       32961
        
              isLibrary = true;

     

       32962
        
              isExecutable = true;

     

       32963
        
              libraryHaskellDepends = [

     
···

       34648
        
              pname = "async";

     

       34649
        
              version = "2.2.4";

     

       34650
        
              sha256 = "09d7w3krfhnmf9dp6yffa9wykinhw541wibnjgnlyv77w1dzhka8";

     

       34651
       +
              revision = "1";

     

       34652
       +
              editedCabalFile = "1w3hlcaq444qid3iqizb8sdl08jxwjmcfgfxqs2dw81mllsfqgdq";

     

       34653
        
              isLibrary = true;

     

       34654
        
              isExecutable = true;

     

       34655
        
              libraryHaskellDepends = [ base hashable stm ];

     
···

       38371
        
           ({ mkDerivation, base, hspec, HUnit, QuickCheck, time }:

     

       38372
        
            mkDerivation {

     

       38373
        
              pname = "bank-holiday-usa";

     

       38374
       +
              version = "0.2.0";

     

       38375
       +
              sha256 = "03zh4cg7sghryb1d06szvn69c5lsbmsg068j00xbpk3w4xrgphjk";

     

       38376
        
              libraryHaskellDepends = [ base time ];

     

       38377
        
              testHaskellDepends = [ base hspec HUnit QuickCheck time ];

     

       38378
       +
              description = "US bank holidays";

     

       38379
        
              license = lib.licenses.mit;

     

       38380
        
              hydraPlatforms = lib.platforms.none;

     

       38381
        
              broken = true;

     
···

       38451
        
              pname = "barbies-th";

     

       38452
        
              version = "0.1.9";

     

       38453
        
              sha256 = "1brikm7qr2yi3426vgwjjxjrvw060sb0v7jbxrhazjps28f6aa3n";

     

       38454
       +
              revision = "1";

     

       38455
       +
              editedCabalFile = "0iij1y72q28wvj8hfx000cpckl1wlcgj050380lx526cmwavy151";

     

       38456
        
              libraryHaskellDepends = [ barbies base split template-haskell ];

     

       38457
        
              testHaskellDepends = [ barbies base ];

     

       38458
        
              description = "Create strippable HKD via TH";

     
···

       40155
        
              broken = true;

     

       40156
        
            }) {};

     

       40157
        
       

     

       40158
       +
         "bech32_1_1_2" = callPackage

     

       40159
       +
           ({ mkDerivation, array, base, base58-bytestring, bytestring

     

       40160
       +
            , containers, deepseq, extra, hspec, hspec-discover, memory

     

       40161
       +
            , optparse-applicative, process, QuickCheck, text, vector

     

       40162
       +
            }:

     

       40163
       +
            mkDerivation {

     

       40164
       +
              pname = "bech32";

     

       40165
       +
              version = "1.1.2";

     

       40166
       +
              sha256 = "1iyjnyy7l0jf2azbgg6lc5k7n25h1r41fyyqfagyaz79vhi1k7j8";

     

       40167
       +
              isLibrary = true;

     

       40168
       +
              isExecutable = true;

     

       40169
       +
              libraryHaskellDepends = [

     

       40170
       +
                array base bytestring containers extra text

     

       40171
       +
              ];

     

       40172
       +
              executableHaskellDepends = [

     

       40173
       +
                base base58-bytestring bytestring extra memory optparse-applicative

     

       40174
       +
                text

     

       40175
       +
              ];

     

       40176
       +
              testHaskellDepends = [

     

       40177
       +
                base base58-bytestring bytestring containers deepseq extra hspec

     

       40178
       +
                memory process QuickCheck text vector

     

       40179
       +
              ];

     

       40180
       +
              testToolDepends = [ hspec-discover ];

     

       40181
       +
              description = "Implementation of the Bech32 cryptocurrency address format (BIP 0173)";

     

       40182
       +
              license = lib.licenses.asl20;

     

       40183
       +
              hydraPlatforms = lib.platforms.none;

     

       40184
       +
              broken = true;

     

       40185
       +
            }) {};

     

       40186
       +
       

     

       40187
        
         "bech32-th" = callPackage

     

       40188
        
           ({ mkDerivation, base, bech32, hspec, hspec-discover

     

       40189
        
            , template-haskell, text

     
···

       43108
        
            }:

     

       43109
        
            mkDerivation {

     

       43110
        
              pname = "bishbosh";

     

       43111
       +
              version = "0.1.2.0";

     

       43112
       +
              sha256 = "1ldzl2f93nqaxs9wbf3s9w8wjrx1fx69w95y5fz7rla7szhrckdq";

     

       43113
        
              isLibrary = true;

     

       43114
        
              isExecutable = true;

     

       43115
        
              enableSeparateDataOutput = true;

     
···

       43651
        
              license = lib.licenses.bsd3;

     

       43652
        
            }) {};

     

       43653
        
       

     

       43654
       +
         "bits_0_6" = callPackage

     

       43655
       +
           ({ mkDerivation, base, bytes, mtl, transformers }:

     

       43656
       +
            mkDerivation {

     

       43657
       +
              pname = "bits";

     

       43658
       +
              version = "0.6";

     

       43659
       +
              sha256 = "18s2aa99cwcshcws2zl2ll7xgqn9dpznpkv1nplamc9h4vmqqs93";

     

       43660
       +
              libraryHaskellDepends = [ base bytes mtl transformers ];

     

       43661
       +
              description = "Various bit twiddling and bitwise serialization primitives";

     

       43662
       +
              license = lib.licenses.bsd3;

     

       43663
       +
              hydraPlatforms = lib.platforms.none;

     

       43664
       +
            }) {};

     

       43665
       +
       

     

       43666
        
         "bits-atomic" = callPackage

     

       43667
        
           ({ mkDerivation, base }:

     

       43668
        
            mkDerivation {

     
···

       44998
        
              pname = "bloomfilter";

     

       44999
        
              version = "2.0.1.0";

     

       45000
        
              sha256 = "03vrmncg1c10a2wcg5skq30m1yiknn7nwxz2gblyyfaxglshspkc";

     

       45001
       +
              revision = "1";

     

       45002
       +
              editedCabalFile = "1dqlwmmcy7s6gsjqcm4xhk3cgbam0hyzpry2ha4064xvdb4rlks3";

     

       45003
        
              libraryHaskellDepends = [ array base bytestring deepseq ];

     

       45004
        
              testHaskellDepends = [

     

       45005
        
                base bytestring QuickCheck random test-framework

     
···

       46156
        
              license = lib.licenses.bsd3;

     

       46157
        
            }) {};

     

       46158
        
       

     

       46159
       +
         "bound_2_0_4" = callPackage

     

       46160
       +
           ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad

     

       46161
       +
            , deepseq, deriving-compat, hashable, mmorph, profunctors

     

       46162
       +
            , template-haskell, th-abstraction, transformers

     

       46163
       +
            , transformers-compat, vector, void

     

       46164
       +
            }:

     

       46165
       +
            mkDerivation {

     

       46166
       +
              pname = "bound";

     

       46167
       +
              version = "2.0.4";

     

       46168
       +
              sha256 = "06wyjiswi5fnnw7ndjdln3fkfgab5c8qh9v1d1s0f0s6rzlb85xs";

     

       46169
       +
              revision = "1";

     

       46170
       +
              editedCabalFile = "008i9lm53p0vwahrl61lfpv33yjchi6jyby7j37rlw9shr4h06qg";

     

       46171
       +
              libraryHaskellDepends = [

     

       46172
       +
                base bifunctors binary bytes cereal comonad deepseq hashable mmorph

     

       46173
       +
                profunctors template-haskell th-abstraction transformers

     

       46174
       +
                transformers-compat

     

       46175
       +
              ];

     

       46176
       +
              testHaskellDepends = [

     

       46177
       +
                base deriving-compat transformers transformers-compat vector void

     

       46178
       +
              ];

     

       46179
       +
              description = "Making de Bruijn Succ Less";

     

       46180
       +
              license = lib.licenses.bsd3;

     

       46181
       +
              hydraPlatforms = lib.platforms.none;

     

       46182
       +
            }) {};

     

       46183
       +
       

     

       46184
        
         "bound-extras" = callPackage

     

       46185
        
           ({ mkDerivation, base, bound, containers, deepseq, filepath

     

       46186
        
            , hashable, pretty, tasty, tasty-golden, text-short, transformers

     
···

       48387
        
              pname = "bytes";

     

       48388
        
              version = "0.17.1";

     

       48389
        
              sha256 = "1qmps8vvg98wfm9xm734hwzi56bsk8r1zc6vx20rlhc79krv5s9s";

     

       48390
       +
              revision = "2";

     

       48391
       +
              editedCabalFile = "1gayyk4sgd8r48x2cgil8392wlxir0qq059m5k966jrwrqdqg2m4";

     

       48392
        
              libraryHaskellDepends = [

     

       48393
        
                base binary binary-orphans bytestring cereal containers hashable

     

       48394
        
                mtl scientific text time transformers transformers-compat

     
···

       49649
        
              license = lib.licenses.bsd3;

     

       49650
        
            }) {};

     

       49651
        
       

     

       49652
       +
         "cabal-doctest_1_0_9" = callPackage

     

       49653
       +
           ({ mkDerivation, base, Cabal, directory, filepath }:

     

       49654
       +
            mkDerivation {

     

       49655
       +
              pname = "cabal-doctest";

     

       49656
       +
              version = "1.0.9";

     

       49657
       +
              sha256 = "0wxs0xkspc80h0g8ks792lrzldxvcnhc9rja1j0k678ijs20hmjm";

     

       49658
       +
              libraryHaskellDepends = [ base Cabal directory filepath ];

     

       49659
       +
              description = "A Setup.hs helper for running doctests";

     

       49660
       +
              license = lib.licenses.bsd3;

     

       49661
       +
              hydraPlatforms = lib.platforms.none;

     

       49662
       +
            }) {};

     

       49663
       +
       

     

       49664
        
         "cabal-edit" = callPackage

     

       49665
        
           ({ mkDerivation, base, bytestring, Cabal, containers, directory

     

       49666
        
            , filepath, Glob, hackage-db, optparse-applicative, process, store

     
···

       52798
        
              pname = "cassava";

     

       52799
        
              version = "0.5.2.0";

     

       52800
        
              sha256 = "01h1zrdqb313cjd4rqm1107azzx4czqi018c2djf66a5i7ajl3dk";

     

       52801
       +
              revision = "5";

     

       52802
       +
              editedCabalFile = "0d2zfs9a5rzljaz2dr47rypsj7aamgsfqn0gs0pwjhkwi8p1504y";

     

       52803
        
              configureFlags = [ "-f-bytestring--lt-0_10_4" ];

     

       52804
        
              libraryHaskellDepends = [

     

       52805
        
                array attoparsec base bytestring containers deepseq hashable Only

     
···

       53685
        
            }:

     

       53686
        
            mkDerivation {

     

       53687
        
              pname = "cereal";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       53688
        
              version = "0.5.8.2";

     

       53689
        
              sha256 = "0kvnlm22qdmb7g2jz7imsvh799q4nvms1ni0cbba5vigp5ai64hp";

     

       53690
        
              libraryHaskellDepends = [

     
···

       53696
        
              ];

     

       53697
        
              description = "A binary serialization library";

     

       53698
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       53699
        
            }) {};

     

       53700
        
       

     

       53701
        
         "cereal-conduit" = callPackage

     
···

       54182
        
            }) {};

     

       54183
        
       

     

       54184
        
         "chakra" = callPackage

     

       54185
       +
           ({ mkDerivation, aeson, base, bytestring, cryptonite, data-default

     

       54186
       +
            , data-has, dotenv, envy, fast-logger, hspec, http-types, iproute

     

       54187
       +
            , jose, network, network-uri, optparse-simple, prometheus-client

     

       0
        
       
     

       54188
        
            , prometheus-metrics-ghc, rio, servant-auth, servant-auth-server

     

       54189
       +
            , servant-server, transformers, unordered-containers, wai, wai-cli

     

       54190
       +
            , wai-extra, wai-middleware-prometheus, warp

     

       0
        
       
     

       54191
        
            }:

     

       54192
        
            mkDerivation {

     

       54193
        
              pname = "chakra";

     

       54194
       +
              version = "0.1.2";

     

       54195
       +
              sha256 = "0fnq9djvsphnrmlds97mjw9idp2s448vqbk1lhj3m6bfhsdx5mdr";

     

       54196
        
              isLibrary = true;

     

       54197
        
              isExecutable = true;

     

       54198
        
              libraryHaskellDepends = [

     

       54199
       +
                aeson base bytestring cryptonite data-default data-has envy

     

       54200
       +
                fast-logger http-types iproute jose network network-uri

     

       54201
       +
                prometheus-client prometheus-metrics-ghc rio servant-auth

     

       54202
       +
                servant-auth-server servant-server transformers wai wai-cli

     

       54203
       +
                wai-extra wai-middleware-prometheus warp

     

       0
        
       
     

       0
        
       
     

       54204
        
              ];

     

       54205
        
              executableHaskellDepends = [

     

       54206
       +
                aeson base bytestring cryptonite data-default data-has dotenv envy

     

       54207
       +
                fast-logger http-types iproute jose network network-uri

     

       54208
       +
                optparse-simple prometheus-client prometheus-metrics-ghc rio

     

       54209
       +
                servant-auth servant-auth-server servant-server transformers

     

       54210
       +
                unordered-containers wai wai-cli wai-extra

     

       0
        
       
     

       54211
        
                wai-middleware-prometheus warp

     

       54212
        
              ];

     

       54213
        
              testHaskellDepends = [

     

       54214
       +
                aeson base bytestring cryptonite data-default data-has envy

     

       54215
       +
                fast-logger hspec http-types iproute jose network network-uri

     

       54216
       +
                prometheus-client prometheus-metrics-ghc rio servant-auth

     

       54217
       +
                servant-auth-server servant-server transformers wai wai-cli

     

       54218
       +
                wai-extra wai-middleware-prometheus warp

     

       0
        
       
     

       0
        
       
     

       54219
        
              ];

     

       54220
        
              description = "A REST Web Api server template for building (micro)services";

     

       54221
        
              license = lib.licenses.mit;

     
···

       56898
        
              pname = "classy-prelude";

     

       56899
        
              version = "1.5.0";

     

       56900
        
              sha256 = "1nm4lygxqb1wq503maki6dsah2gpn5rd22jmbwjxfwyzgyqy9fnk";

     

       56901
       +
              revision = "1";

     

       56902
       +
              editedCabalFile = "1jivh1bmcvqn6bhh5z8x69v93zjcriklljm7gx342d8k5d5rsf4s";

     

       56903
        
              libraryHaskellDepends = [

     

       56904
        
                async base basic-prelude bifunctors bytestring chunked-data

     

       56905
        
                containers deepseq dlist ghc-prim hashable mono-traversable

     
···

       64014
        
              pname = "constraints";

     

       64015
        
              version = "0.13.1";

     

       64016
        
              sha256 = "0j10sn0i1pk0dsxnf728v0mjg9bcxblkhd8f4fm8rgi32v2sby6k";

     

       64017
       +
              revision = "1";

     

       64018
       +
              editedCabalFile = "115n8pqc26gqxgvvf4h4y1wkf3gw6nb3jfjfmdb4svlnk4jlyjm9";

     

       64019
        
              libraryHaskellDepends = [

     

       64020
        
                base binary deepseq ghc-prim hashable mtl transformers

     

       64021
        
                transformers-compat type-equality

     
···

       64024
        
              testToolDepends = [ hspec-discover ];

     

       64025
        
              description = "Constraint manipulation";

     

       64026
        
              license = lib.licenses.bsd2;

     

       64027
       +
            }) {};

     

       64028
       +
       

     

       64029
       +
         "constraints_0_13_2" = callPackage

     

       64030
       +
           ({ mkDerivation, base, binary, deepseq, ghc-prim, hashable, hspec

     

       64031
       +
            , hspec-discover, mtl, transformers, transformers-compat

     

       64032
       +
            , type-equality

     

       64033
       +
            }:

     

       64034
       +
            mkDerivation {

     

       64035
       +
              pname = "constraints";

     

       64036
       +
              version = "0.13.2";

     

       64037
       +
              sha256 = "1zfijh3jpdfrh8nwn5xv2z05jnxyf0ciqlfaja6g6ls654svrj70";

     

       64038
       +
              libraryHaskellDepends = [

     

       64039
       +
                base binary deepseq ghc-prim hashable mtl transformers

     

       64040
       +
                transformers-compat type-equality

     

       64041
       +
              ];

     

       64042
       +
              testHaskellDepends = [ base hspec ];

     

       64043
       +
              testToolDepends = [ hspec-discover ];

     

       64044
       +
              description = "Constraint manipulation";

     

       64045
       +
              license = lib.licenses.bsd2;

     

       64046
       +
              hydraPlatforms = lib.platforms.none;

     

       64047
        
            }) {};

     

       64048
        
       

     

       64049
        
         "constraints-deriving" = callPackage

     
···

       64140
        
            }:

     

       64141
        
            mkDerivation {

     

       64142
        
              pname = "constructible";

     

       64143
       +
              version = "0.1.2";

     

       64144
       +
              sha256 = "1fdxbw33rjyh0gmknzng8sl8gcbz99ib3ks5rq3kjvqn4ibmyqpf";

     

       64145
        
              libraryHaskellDepends = [

     

       64146
        
                base binary-search complex-generic integer-roots

     

       64147
        
              ];

     
···

       65205
        
            }:

     

       65206
        
            mkDerivation {

     

       65207
        
              pname = "copilot";

     

       65208
       +
              version = "3.6";

     

       65209
       +
              sha256 = "0h43slh084wj7kwn2rdn0s63pqzy930h6z2vk38kn6yqic8d9s9y";

     

       65210
        
              isLibrary = true;

     

       65211
        
              isExecutable = true;

     

       65212
        
              libraryHaskellDepends = [

     
···

       65225
        
            }:

     

       65226
        
            mkDerivation {

     

       65227
        
              pname = "copilot-c99";

     

       65228
       +
              version = "3.6";

     

       65229
       +
              sha256 = "18p7pijx2f7bw61bzfs5994xpkygghf7hvwpklhp72jkshjdjj1m";

     

       65230
        
              libraryHaskellDepends = [

     

       65231
        
                base containers copilot-core directory filepath language-c99

     

       65232
        
                language-c99-simple language-c99-util mtl pretty

     

       65233
        
              ];

     

       65234
        
              description = "A compiler for Copilot targeting C99";

     

       65235
        
              license = lib.licenses.bsd3;

     

       65236
       +
              hydraPlatforms = lib.platforms.none;

     

       65237
        
            }) {};

     

       65238
        
       

     

       65239
        
         "copilot-cbmc" = callPackage

     
···

       65254
        
            }) {};

     

       65255
        
       

     

       65256
        
         "copilot-core" = callPackage

     

       65257
       +
           ({ mkDerivation, base, dlist, HUnit, mtl, pretty, QuickCheck

     

       65258
       +
            , test-framework, test-framework-hunit, test-framework-quickcheck2

     

       65259
       +
            }:

     

       65260
        
            mkDerivation {

     

       65261
        
              pname = "copilot-core";

     

       65262
       +
              version = "3.6";

     

       65263
       +
              sha256 = "00v8la4q15qj27wyqcbsv0h7m5k5ln98y4zkdzpng3z5gw4mpkm9";

     

       65264
        
              libraryHaskellDepends = [ base dlist mtl pretty ];

     

       65265
       +
              testHaskellDepends = [

     

       65266
       +
                base HUnit pretty QuickCheck test-framework test-framework-hunit

     

       65267
       +
                test-framework-quickcheck2

     

       65268
       +
              ];

     

       65269
        
              description = "An intermediate representation for Copilot";

     

       65270
        
              license = lib.licenses.bsd3;

     

       65271
       +
              hydraPlatforms = lib.platforms.none;

     

       65272
       +
              broken = true;

     

       65273
        
            }) {};

     

       65274
        
       

     

       65275
        
         "copilot-language" = callPackage

     
···

       65278
        
            }:

     

       65279
        
            mkDerivation {

     

       65280
        
              pname = "copilot-language";

     

       65281
       +
              version = "3.6";

     

       65282
       +
              sha256 = "0b1cl4v5w54nx007mmnsx49hh3zxjm55ninlzkd78balnyah8nlk";

     

       65283
        
              libraryHaskellDepends = [

     

       65284
        
                array base containers copilot-core copilot-theorem data-reify mtl

     

       65285
        
              ];

     
···

       65294
        
            }:

     

       65295
        
            mkDerivation {

     

       65296
        
              pname = "copilot-libraries";

     

       65297
       +
              version = "3.6";

     

       65298
       +
              sha256 = "0s6y1is91nbvlrb9fdp9xhaq9wx3j5pm67gjrlajiik4029a2dxd";

     

       65299
        
              libraryHaskellDepends = [

     

       65300
        
                array base containers copilot-language data-reify mtl parsec

     

       65301
        
              ];

     
···

       65329
        
            }:

     

       65330
        
            mkDerivation {

     

       65331
        
              pname = "copilot-theorem";

     

       65332
       +
              version = "3.6";

     

       65333
       +
              sha256 = "17l8xq4zd9jfih5p21l6xkahdgrfbmpy8wxc38w88w98qmz5ix59";

     

       65334
        
              libraryHaskellDepends = [

     

       65335
        
                ansi-terminal base bimap bv-sized containers copilot-core

     

       65336
        
                data-default directory filepath libBF mtl panic parameterized-utils

     
···

       65493
        
              license = lib.licenses.mit;

     

       65494
        
            }) {};

     

       65495
        
       

     

       65496
       +
         "core-program_0_3_4_1" = callPackage

     

       65497
        
           ({ mkDerivation, async, base, bytestring, chronologique, core-data

     

       65498
        
            , core-text, directory, exceptions, filepath, fsnotify, hashable

     

       65499
        
            , hourglass, mtl, prettyprinter, safe-exceptions, stm

     
···

       65502
        
            }:

     

       65503
        
            mkDerivation {

     

       65504
        
              pname = "core-program";

     

       65505
       +
              version = "0.3.4.1";

     

       65506
       +
              sha256 = "01yk1dyr6z1g541v0y7cpnilbnqwvcn5si38r8flzq35svrk1bjn";

     

       65507
        
              libraryHaskellDepends = [

     

       65508
        
                async base bytestring chronologique core-data core-text directory

     

       65509
        
                exceptions filepath fsnotify hashable hourglass mtl prettyprinter

     
···

       69482
        
              license = lib.licenses.bsd3;

     

       69483
        
            }) {};

     

       69484
        
       

     

       69485
       +
         "czipwith_1_0_1_4" = callPackage

     

       69486
       +
           ({ mkDerivation, base, template-haskell, transformers }:

     

       69487
       +
            mkDerivation {

     

       69488
       +
              pname = "czipwith";

     

       69489
       +
              version = "1.0.1.4";

     

       69490
       +
              sha256 = "0zvi7wmbh09ngbyvavvhn6s3vz1pnps59fl1sq3vih6s03s0zmai";

     

       69491
       +
              libraryHaskellDepends = [ base template-haskell ];

     

       69492
       +
              testHaskellDepends = [ base transformers ];

     

       69493
       +
              description = "CZipWith class and deriving via TH";

     

       69494
       +
              license = lib.licenses.bsd3;

     

       69495
       +
              hydraPlatforms = lib.platforms.none;

     

       69496
       +
            }) {};

     

       69497
       +
       

     

       69498
        
         "d-bus" = callPackage

     

       69499
        
           ({ mkDerivation, async, attoparsec, base, binary, blaze-builder

     

       69500
        
            , bytestring, conduit, conduit-extra, containers

     
···

       73698
        
              hydraPlatforms = lib.platforms.none;

     

       73699
        
            }) {};

     

       73700
        
       

     

       73701
       +
         "deepseq_1_4_6_0" = callPackage

     

       73702
        
           ({ mkDerivation, array, base, ghc-prim, HUnit, test-framework

     

       73703
        
            , test-framework-hunit

     

       73704
        
            }:

     

       73705
        
            mkDerivation {

     

       73706
        
              pname = "deepseq";

     

       73707
       +
              version = "1.4.6.0";

     

       73708
       +
              sha256 = "0j6pxm9q3xanhxrdmxgzkfdlnpilnlvnnvazq61szl1q9d3mn6ql";

     

       73709
        
              libraryHaskellDepends = [ array base ];

     

       73710
        
              testHaskellDepends = [

     

       73711
        
                array base ghc-prim HUnit test-framework test-framework-hunit

     
···

       74342
        
       

     

       74343
        
         "dependent-literals" = callPackage

     

       74344
        
           ({ mkDerivation, base, fin-int, numeric-kinds, sint, snumber

     

       74345
       +
            , tagged, type-compare, wrapped

     

       74346
        
            }:

     

       74347
        
            mkDerivation {

     

       74348
        
              pname = "dependent-literals";

     

       74349
       +
              version = "0.2.0";

     

       74350
       +
              sha256 = "1i3mzijqk2pf7am9kh1ydhrw9qj1ijfq8kwvxhrqcx28kaz63rvd";

     

       0
        
       
     

       0
        
       
     

       74351
        
              libraryHaskellDepends = [

     

       74352
       +
                base fin-int numeric-kinds sint snumber tagged type-compare wrapped

     

       74353
        
              ];

     

       74354
        
              description = "Library for dependent-literals-plugin";

     

       74355
        
              license = lib.licenses.asl20;

     
···

       74361
        
            }:

     

       74362
        
            mkDerivation {

     

       74363
        
              pname = "dependent-literals-plugin";

     

       74364
       +
              version = "0.1.0.2";

     

       74365
       +
              sha256 = "0bllcf19psak7sfhlqh78lbrdgx3ylqislrvdhjc9syvhaw5khq1";

     

       0
        
       
     

       0
        
       
     

       74366
        
              libraryHaskellDepends = [ base ghc syb ];

     

       74367
        
              testHaskellDepends = [

     

       74368
        
                base dependent-literals fin-int numeric-kinds short-vec sint

     
···

       74843
        
              license = lib.licenses.bsd3;

     

       74844
        
            }) {};

     

       74845
        
       

     

       74846
       +
         "deriving-aeson_0_2_8" = callPackage

     

       74847
       +
           ({ mkDerivation, aeson, base, bytestring }:

     

       74848
       +
            mkDerivation {

     

       74849
       +
              pname = "deriving-aeson";

     

       74850
       +
              version = "0.2.8";

     

       74851
       +
              sha256 = "0f59ar4cax7g0h6wrk8ckni7i4gw5wls5ybzbrji2a0qpd7q5lrd";

     

       74852
       +
              libraryHaskellDepends = [ aeson base ];

     

       74853
       +
              testHaskellDepends = [ aeson base bytestring ];

     

       74854
       +
              description = "Type driven generic aeson instance customisation";

     

       74855
       +
              license = lib.licenses.bsd3;

     

       74856
       +
              hydraPlatforms = lib.platforms.none;

     

       74857
       +
            }) {};

     

       74858
       +
       

     

       74859
        
         "deriving-compat" = callPackage

     

       74860
        
           ({ mkDerivation, base, base-compat, base-orphans, containers

     

       74861
        
            , ghc-boot-th, ghc-prim, hspec, hspec-discover, QuickCheck, tagged

     
···

       75558
        
              pname = "dhall";

     

       75559
        
              version = "1.40.1";

     

       75560
        
              sha256 = "0m2fw9ak9l6fz8ylpbi0cdihf2j66jlnd5j3vf56r7wlqgbkxhi1";

     

       75561
       +
              revision = "5";

     

       75562
       +
              editedCabalFile = "1dp9byzmjd2kvydc0q5s3mv59a131jqwhc9cl22jgbhp0whq9jgc";

     

       75563
        
              isLibrary = true;

     

       75564
        
              isExecutable = true;

     

       75565
        
              enableSeparateDataOutput = true;

     
···

       75929
        
              pname = "dhall-nixpkgs";

     

       75930
        
              version = "1.0.6";

     

       75931
        
              sha256 = "12sfxz7n86m69m1xbnrrr1ybggh70rfwmr4maflq522bhkc2hgvk";

     

       75932
       +
              revision = "2";

     

       75933
       +
              editedCabalFile = "13i04l52jb8xyhqa48r8rlr0d4p657aarfhsxm407ziph5pi60vk";

     

       75934
        
              isLibrary = false;

     

       75935
        
              isExecutable = true;

     

       75936
        
              executableHaskellDepends = [

     
···

       75952
        
              pname = "dhall-openapi";

     

       75953
        
              version = "1.0.2";

     

       75954
        
              sha256 = "1p678nn1gfj2xp0kmw8i5pzsv6s5bpnsmyng45adb9pnpiyxbcyj";

     

       75955
       +
              revision = "2";

     

       75956
       +
              editedCabalFile = "0gkxzfadkpz4dcmcfbyf66s2xa656lf2vw0n282qnc1rsy74ra85";

     

       75957
        
              isLibrary = true;

     

       75958
        
              isExecutable = true;

     

       75959
        
              libraryHaskellDepends = [

     
···

       76104
        
              pname = "dhall-yaml";

     

       76105
        
              version = "1.2.8";

     

       76106
        
              sha256 = "1p766ybwib3f2i5h7m1hh71vc255ahvf7237bpprdapqw3ag8nak";

     

       76107
       +
              revision = "1";

     

       76108
       +
              editedCabalFile = "06jr2b5zj82zcsq7dp6d8v9rfarkpqkp6m1s61d76vlzv9kc2pp2";

     

       76109
        
              isLibrary = true;

     

       76110
        
              isExecutable = true;

     

       76111
        
              libraryHaskellDepends = [

     
···

       76531
        
            }:

     

       76532
        
            mkDerivation {

     

       76533
        
              pname = "diagrams-haddock";

     

       76534
       +
              version = "0.4.1.1";

     

       76535
       +
              sha256 = "1azc42pr0hb5qamgf8i0kpkvpzxqlgc9npmi21sxnsw66bnzxw7i";

     

       0
        
       
     

       0
        
       
     

       76536
        
              isLibrary = true;

     

       76537
        
              isExecutable = true;

     

       76538
        
              libraryHaskellDepends = [

     
···

       80272
        
              license = lib.licenses.mit;

     

       80273
        
            }) {};

     

       80274
        
       

     

       80275
       +
         "doctest_0_18_2" = callPackage

     

       80276
        
           ({ mkDerivation, base, base-compat, code-page, deepseq, directory

     

       80277
        
            , exceptions, filepath, ghc, ghc-paths, hspec, hspec-core, HUnit

     

       80278
        
            , mockery, process, QuickCheck, setenv, silently, stringbuilder

     
···

       80280
        
            }:

     

       80281
        
            mkDerivation {

     

       80282
        
              pname = "doctest";

     

       80283
       +
              version = "0.18.2";

     

       80284
       +
              sha256 = "0c48dpxa8i3q5xh2shd2p2xxhrsy7wdil6dg4mayr3lkk1dlwbfp";

     

       80285
        
              isLibrary = true;

     

       80286
        
              isExecutable = true;

     

       80287
        
              libraryHaskellDepends = [

     
···

       80356
        
              pname = "doctest-driver-gen";

     

       80357
        
              version = "0.3.0.4";

     

       80358
        
              sha256 = "1fbqi4s4ajxhyv4a7nbh3v98limla0z8rfqlh02pwc1a90qpwy1a";

     

       80359
       +
              revision = "1";

     

       80360
       +
              editedCabalFile = "19xaynf2zzrvls6l57jzzxp3862d0d2q43amsgsch5ri8479m4dn";

     

       80361
        
              isLibrary = true;

     

       80362
        
              isExecutable = true;

     

       80363
        
              libraryHaskellDepends = [ base ];

     
···

       88983
        
           ({ mkDerivation, base }:

     

       88984
        
            mkDerivation {

     

       88985
        
              pname = "exact-combinatorics";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       88986
        
              version = "0.2.0.11";

     

       88987
        
              sha256 = "0qrhgd468ljpnfciaxzimmn1rhvapcrrsy4wb2r08hn3vjflmd3n";

     

       88988
        
              libraryHaskellDepends = [ base ];

     

       88989
        
              description = "Efficient exact computation of combinatoric functions";

     

       88990
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       88991
        
            }) {};

     

       88992
        
       

     

       88993
        
         "exact-cover" = callPackage

     
···

       90608
        
            }:

     

       90609
        
            mkDerivation {

     

       90610
        
              pname = "extralife";

     

       90611
       +
              version = "0.2.0.0";

     

       90612
       +
              sha256 = "0bpaz123qg91rw4b97p528w4l7wbb17x4h61dmy1v2sr01l82q58";

     

       90613
        
              libraryHaskellDepends = [

     

       90614
        
                aeson base bytestring http-client http-client-tls text time

     

       90615
        
              ];

     
···

       97735
        
            , http-link-header, http-types, immortal, iproute, lens, lens-aeson

     

       97736
        
            , load-env, monad-control, monad-logger, MonadRandom, mtl, network

     

       97737
        
            , network-uri, persistent, persistent-postgresql, postgresql-simple

     

       97738
       +
            , primitive, process, resource-pool, retry, rio, template-haskell

     

       97739
       +
            , temporary, text, time, transformers, transformers-base, unliftio

     

       97740
       +
            , unliftio-core, unordered-containers, wai, wai-extra, yaml, yesod

     

       97741
       +
            , yesod-core

     

       97742
        
            }:

     

       97743
        
            mkDerivation {

     

       97744
        
              pname = "freckle-app";

     

       97745
       +
              version = "1.0.2.0";

     

       97746
       +
              sha256 = "060yspa1qb0qp7yf7s71pfkq6jdd7bn9xy5kll45d8rvjazf10y6";

     

       97747
        
              libraryHaskellDepends = [

     

       97748
        
                aeson ansi-terminal base bytestring case-insensitive conduit

     

       97749
        
                data-default datadog doctest ekg-core errors exceptions fast-logger

     
···

       97752
        
                http-types immortal iproute lens load-env monad-control

     

       97753
        
                monad-logger MonadRandom mtl network network-uri persistent

     

       97754
        
                persistent-postgresql postgresql-simple primitive process

     

       97755
       +
                resource-pool retry rio template-haskell text time transformers

     

       97756
       +
                transformers-base unliftio unliftio-core unordered-containers wai

     

       97757
       +
                wai-extra yaml yesod yesod-core

     

       97758
        
              ];

     

       97759
        
              testHaskellDepends = [

     

       97760
        
                aeson base bytestring directory hspec http-types lens lens-aeson

     
···

       101641
        
            }:

     

       101642
        
            mkDerivation {

     

       101643
        
              pname = "generic-aeson";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       101644
        
              version = "0.2.0.13";

     

       101645
        
              sha256 = "0w5xp1rfg3r90ja1f0s48i4x7yyynfv52p6b9ncsdqyrq3y9qvl0";

     

       101646
        
              libraryHaskellDepends = [

     
···

       101649
        
              ];

     

       101650
        
              description = "Derivation of Aeson instances using GHC generics";

     

       101651
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       101652
        
            }) {};

     

       101653
        
       

     

       101654
        
         "generic-arbitrary" = callPackage

     
···

       102106
        
              pname = "generic-random";

     

       102107
        
              version = "1.4.0.0";

     

       102108
        
              sha256 = "12rvb1dzrfjc46n9vdcw3yv773iih8vwhrac3hpzq70yp2z77jdw";

     

       102109
       +
              revision = "1";

     

       102110
       +
              editedCabalFile = "0k8hk2fpm53x5788nvqy8pd1vgpdwidbz5syryf8imhqqq0837w1";

     

       102111
        
              libraryHaskellDepends = [ base QuickCheck ];

     

       102112
        
              testHaskellDepends = [ base deepseq QuickCheck ];

     

       102113
        
              description = "Generic random generators for QuickCheck";

     
···

       102120
        
              pname = "generic-random";

     

       102121
        
              version = "1.5.0.0";

     

       102122
        
              sha256 = "033cs5vkx57ny035ngndhg3n32jbzyp98li9559gyiz8glp79pzg";

     

       102123
       +
              revision = "1";

     

       102124
       +
              editedCabalFile = "0p0im7py1hrarad8pg5vcggz52d702p749nvx3h5glcygzlag14v";

     

       102125
        
              libraryHaskellDepends = [ base QuickCheck ];

     

       102126
        
              testHaskellDepends = [ base deepseq QuickCheck ];

     

       102127
        
              description = "Generic random generators for QuickCheck";

     
···

       105127
        
              license = lib.licenses.bsd3;

     

       105128
        
            }) {};

     

       105129
        
       

     

       105130
       +
         "ghc-typelits-presburger_0_6_1_0" = callPackage

     

       105131
       +
           ({ mkDerivation, base, containers, equational-reasoning, ghc

     

       105132
       +
            , ghc-tcplugins-extra, mtl, pretty, reflection, syb, tasty

     

       105133
       +
            , tasty-discover, tasty-expected-failure, tasty-hunit, text

     

       105134
       +
            , transformers

     

       105135
       +
            }:

     

       105136
       +
            mkDerivation {

     

       105137
       +
              pname = "ghc-typelits-presburger";

     

       105138
       +
              version = "0.6.1.0";

     

       105139
       +
              sha256 = "1k9mh0w1xaz85jkdvwm5pxkqzwzrjmhzn1sj2nmilhbnhgfwm9vd";

     

       105140
       +
              isLibrary = true;

     

       105141
       +
              isExecutable = true;

     

       105142
       +
              libraryHaskellDepends = [

     

       105143
       +
                base containers ghc ghc-tcplugins-extra mtl pretty reflection syb

     

       105144
       +
                transformers

     

       105145
       +
              ];

     

       105146
       +
              testHaskellDepends = [

     

       105147
       +
                base equational-reasoning tasty tasty-discover

     

       105148
       +
                tasty-expected-failure tasty-hunit text

     

       105149
       +
              ];

     

       105150
       +
              testToolDepends = [ tasty-discover ];

     

       105151
       +
              description = "Presburger Arithmetic Solver for GHC Type-level natural numbers";

     

       105152
       +
              license = lib.licenses.bsd3;

     

       105153
       +
              hydraPlatforms = lib.platforms.none;

     

       105154
       +
            }) {};

     

       105155
       +
       

     

       105156
        
         "ghc-usage" = callPackage

     

       105157
        
           ({ mkDerivation, base, containers, ghc, ghc-paths, unix }:

     

       105158
        
            mkDerivation {

     
···

       107590
        
            }:

     

       107591
        
            mkDerivation {

     

       107592
        
              pname = "git-lfs";

     

       107593
       +
              version = "1.2.0";

     

       107594
       +
              sha256 = "1iv3s1c7gwmsima9z3rsphjligpnf7h3vc5c96zgq9b71cx81lba";

     

       107595
        
              libraryHaskellDepends = [

     

       107596
        
                aeson base bytestring case-insensitive containers http-client

     

       107597
        
                http-types network-uri text

     
···

       114118
        
              license = lib.licenses.bsd3;

     

       114119
        
            }) {};

     

       114120
        
       

     

       114121
       +
         "greskell_1_2_0_2" = callPackage

     

       114122
       +
           ({ mkDerivation, aeson, base, bytestring, doctest, doctest-discover

     

       114123
       +
            , exceptions, greskell-core, hashable, hint, hspec, hspec-discover

     

       114124
       +
            , semigroups, text, transformers, unordered-containers, vector

     

       114125
       +
            }:

     

       114126
       +
            mkDerivation {

     

       114127
       +
              pname = "greskell";

     

       114128
       +
              version = "1.2.0.2";

     

       114129
       +
              sha256 = "0zqxln8gcjb3i88b9x156rv3v4d0zlrkca11w1bmbjly8zpgrl4x";

     

       114130
       +
              libraryHaskellDepends = [

     

       114131
       +
                aeson base exceptions greskell-core hashable semigroups text

     

       114132
       +
                transformers unordered-containers vector

     

       114133
       +
              ];

     

       114134
       +
              testHaskellDepends = [

     

       114135
       +
                aeson base bytestring doctest doctest-discover greskell-core hint

     

       114136
       +
                hspec text unordered-containers

     

       114137
       +
              ];

     

       114138
       +
              testToolDepends = [ doctest-discover hspec-discover ];

     

       114139
       +
              description = "Haskell binding for Gremlin graph query language";

     

       114140
       +
              license = lib.licenses.bsd3;

     

       114141
       +
              hydraPlatforms = lib.platforms.none;

     

       114142
       +
            }) {};

     

       114143
       +
       

     

       114144
        
         "greskell-core" = callPackage

     

       114145
        
           ({ mkDerivation, aeson, base, bytestring, containers, doctest

     

       114146
        
            , doctest-discover, hashable, hspec, hspec-discover, QuickCheck

     
···

       114163
        
              license = lib.licenses.bsd3;

     

       114164
        
            }) {};

     

       114165
        
       

     

       114166
       +
         "greskell-core_0_1_3_7" = callPackage

     

       114167
       +
           ({ mkDerivation, aeson, base, bytestring, containers, doctest

     

       114168
       +
            , doctest-discover, hashable, hspec, hspec-discover, QuickCheck

     

       114169
       +
            , scientific, semigroups, text, unordered-containers, uuid, vector

     

       114170
       +
            }:

     

       114171
       +
            mkDerivation {

     

       114172
       +
              pname = "greskell-core";

     

       114173
       +
              version = "0.1.3.7";

     

       114174
       +
              sha256 = "1lffgrc4q9iwfdgn7qfxyhk459x47fl2fg6rvgqr4jqz1xp7x9cy";

     

       114175
       +
              libraryHaskellDepends = [

     

       114176
       +
                aeson base containers hashable scientific semigroups text

     

       114177
       +
                unordered-containers uuid vector

     

       114178
       +
              ];

     

       114179
       +
              testHaskellDepends = [

     

       114180
       +
                aeson base bytestring doctest doctest-discover hspec QuickCheck

     

       114181
       +
                text unordered-containers vector

     

       114182
       +
              ];

     

       114183
       +
              testToolDepends = [ doctest-discover hspec-discover ];

     

       114184
       +
              description = "Haskell binding for Gremlin graph query language - core data types and tools";

     

       114185
       +
              license = lib.licenses.bsd3;

     

       114186
       +
              hydraPlatforms = lib.platforms.none;

     

       114187
       +
            }) {};

     

       114188
       +
       

     

       114189
        
         "greskell-websocket" = callPackage

     

       114190
        
           ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring

     

       114191
        
            , greskell-core, hashtables, hspec, safe-exceptions, stm, text

     
···

       114206
        
              ];

     

       114207
        
              description = "Haskell client for Gremlin Server using WebSocket serializer";

     

       114208
        
              license = lib.licenses.bsd3;

     

       114209
       +
            }) {};

     

       114210
       +
       

     

       114211
       +
         "greskell-websocket_0_1_2_6" = callPackage

     

       114212
       +
           ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring

     

       114213
       +
            , greskell-core, hashtables, hspec, hspec-discover, safe-exceptions

     

       114214
       +
            , stm, text, unordered-containers, uuid, vector, websockets

     

       114215
       +
            }:

     

       114216
       +
            mkDerivation {

     

       114217
       +
              pname = "greskell-websocket";

     

       114218
       +
              version = "0.1.2.6";

     

       114219
       +
              sha256 = "1wjfvx25k603ymsalvgzrpnyw20mliky5mclrx6caxqyh0plqdak";

     

       114220
       +
              libraryHaskellDepends = [

     

       114221
       +
                aeson async base base64-bytestring bytestring greskell-core

     

       114222
       +
                hashtables safe-exceptions stm text unordered-containers uuid

     

       114223
       +
                vector websockets

     

       114224
       +
              ];

     

       114225
       +
              testHaskellDepends = [

     

       114226
       +
                aeson base bytestring greskell-core hspec unordered-containers uuid

     

       114227
       +
                vector

     

       114228
       +
              ];

     

       114229
       +
              testToolDepends = [ hspec-discover ];

     

       114230
       +
              description = "Haskell client for Gremlin Server using WebSocket serializer";

     

       114231
       +
              license = lib.licenses.bsd3;

     

       114232
       +
              hydraPlatforms = lib.platforms.none;

     

       114233
        
            }) {};

     

       114234
        
       

     

       114235
        
         "grid" = callPackage

     
···

       117501
        
       

     

       117502
        
         "hadolint" = callPackage

     

       117503
        
           ({ mkDerivation, aeson, base, bytestring, Cabal, colourista

     

       117504
       +
            , containers, cryptonite, data-default, deepseq, directory

     

       117505
       +
            , email-validate, filepath, foldl, gitrev, hspec, HsYAML, HUnit

     

       117506
       +
            , ilist, language-docker, megaparsec, mtl, network-uri

     

       117507
       +
            , optparse-applicative, parallel, parsec, prettyprinter, semver

     

       117508
       +
            , ShellCheck, silently, spdx, split, text, time, timerep, void

     

       117509
        
            }:

     

       117510
        
            mkDerivation {

     

       117511
        
              pname = "hadolint";

     

       117512
       +
              version = "2.8.0";

     

       117513
       +
              sha256 = "07dqm4jcglshwqyvp17773xd07bhk5mdybn4ax5ff4xrvg4pj9ah";

     

       117514
        
              isLibrary = true;

     

       117515
        
              isExecutable = true;

     

       117516
        
              libraryHaskellDepends = [

     

       117517
        
                aeson base bytestring Cabal colourista containers cryptonite

     

       117518
       +
                data-default deepseq directory email-validate filepath foldl gitrev

     

       117519
       +
                HsYAML ilist language-docker megaparsec mtl network-uri

     

       117520
       +
                optparse-applicative parallel parsec prettyprinter semver

     

       117521
        
                ShellCheck spdx split text time timerep void

     

       117522
        
              ];

     

       117523
        
              executableHaskellDepends = [

     

       117524
       +
                base containers data-default language-docker megaparsec

     

       117525
       +
                optparse-applicative prettyprinter text

     

       117526
        
              ];

     

       117527
        
              testHaskellDepends = [

     

       117528
       +
                aeson base bytestring containers data-default foldl hspec HsYAML

     

       117529
       +
                HUnit language-docker megaparsec optparse-applicative ShellCheck

     

       117530
       +
                silently split text

     

       117531
        
              ];

     

       117532
        
              description = "Dockerfile Linter JavaScript API";

     

       117533
        
              license = lib.licenses.gpl3Only;

     

       0
        
       
     

       0
        
       
     

       117534
        
            }) {};

     

       117535
        
       

     

       117536
        
         "hadoop-formats" = callPackage

     
···

       125343
        
              license = lib.licenses.mit;

     

       125344
        
            }) {};

     

       125345
        
       

     

       125346
       +
         "hasql-interpolate" = callPackage

     

       125347
       +
           ({ mkDerivation, aeson, array, base, bytestring, containers

     

       125348
       +
            , haskell-src-meta, hasql, megaparsec, mtl, scientific, tasty

     

       125349
       +
            , tasty-hunit, template-haskell, text, time, transformers, uuid

     

       125350
       +
            , vector

     

       125351
       +
            }:

     

       125352
       +
            mkDerivation {

     

       125353
       +
              pname = "hasql-interpolate";

     

       125354
       +
              version = "0.1.0.0";

     

       125355
       +
              sha256 = "0l9gpkkwkypvz3020p5khvxzrq6x62z3i1xjrbzal7yj0gic4klg";

     

       125356
       +
              libraryHaskellDepends = [

     

       125357
       +
                aeson array base bytestring containers haskell-src-meta hasql

     

       125358
       +
                megaparsec mtl scientific template-haskell text time transformers

     

       125359
       +
                uuid vector

     

       125360
       +
              ];

     

       125361
       +
              testHaskellDepends = [

     

       125362
       +
                base hasql tasty tasty-hunit template-haskell text

     

       125363
       +
              ];

     

       125364
       +
              description = "QuasiQuoter that supports expression interpolation for hasql";

     

       125365
       +
              license = lib.licenses.bsd3;

     

       125366
       +
            }) {};

     

       125367
       +
       

     

       125368
        
         "hasql-migration" = callPackage

     

       125369
        
           ({ mkDerivation, base, bytestring, contravariant, cryptonite

     

       125370
        
            , directory, hasql, hasql-transaction, hspec, memory, text, time

     
···

       126540
        
              platforms = [

     

       126541
        
                "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"

     

       126542
        
              ];

     

       126543
       +
              hydraPlatforms = lib.platforms.none;

     

       126544
        
            }) {};

     

       126545
        
       

     

       126546
        
         "hbro-contrib" = callPackage

     
···

       126576
        
              platforms = [

     

       126577
        
                "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"

     

       126578
        
              ];

     

       126579
       +
              hydraPlatforms = lib.platforms.none;

     

       126580
        
            }) {};

     

       126581
        
       

     

       126582
        
         "hburg" = callPackage

     
···

       134624
        
              testHaskellDepends = [ base QuickCheck ];

     

       134625
        
              description = "Hidden Markov Models using LAPACK primitives";

     

       134626
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       134627
        
            }) {};

     

       134628
        
       

     

       134629
        
         "hmm-lapack_0_4_1" = callPackage

     
···

       137378
        
            , cryptohash, deepseq, exceptions, extra, fields-json, hpqtypes

     

       137379
        
            , lifted-base, log-base, monad-control, mtl, QuickCheck, safe

     

       137380
        
            , semigroups, tasty, tasty-bench, tasty-hunit, text, text-show

     

       137381
       +
            , time, transformers, transformers-base, uuid-types

     

       137382
        
            }:

     

       137383
        
            mkDerivation {

     

       137384
        
              pname = "hpqtypes-extras";

     

       137385
       +
              version = "1.13.0.0";

     

       137386
       +
              sha256 = "07pma23i8cy8153g3grb1jr4sasaaczlqym1jv9q5vzb03mdqcaw";

     

       0
        
       
     

       0
        
       
     

       137387
        
              libraryHaskellDepends = [

     

       137388
        
                base base16-bytestring bytestring containers cryptohash exceptions

     

       137389
        
                extra fields-json hpqtypes lifted-base log-base monad-control mtl

     

       137390
       +
                safe semigroups text text-show transformers-base

     

       137391
        
              ];

     

       137392
        
              testHaskellDepends = [

     

       137393
        
                base exceptions hpqtypes lifted-base log-base monad-control

     
···

       139243
        
            }) {};

     

       139244
        
       

     

       139245
        
         "hsc2hs" = callPackage

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       139246
        
           ({ mkDerivation, base, containers, directory, filepath, HUnit

     

       139247
        
            , process, test-framework, test-framework-hunit

     

       139248
        
            }:

     
···

       139261
        
              ];

     

       139262
        
              description = "A preprocessor that helps with writing Haskell bindings to C code";

     

       139263
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       139264
        
            }) {};

     

       139265
        
       

     

       139266
        
         "hsc3" = callPackage

     
···

       141397
        
              license = lib.licenses.mit;

     

       141398
        
            }) {};

     

       141399
        
       

     

       141400
       +
         "hspec_2_8_4" = callPackage

     

       141401
        
           ({ mkDerivation, base, hspec-core, hspec-discover

     

       141402
        
            , hspec-expectations, QuickCheck

     

       141403
        
            }:

     

       141404
        
            mkDerivation {

     

       141405
        
              pname = "hspec";

     

       141406
       +
              version = "2.8.4";

     

       141407
       +
              sha256 = "08br1ln5drvw1b9sf9cpxbz31v88p9b7b3hb00qn9vcim5yridz1";

     

       141408
        
              libraryHaskellDepends = [

     

       141409
        
                base hspec-core hspec-discover hspec-expectations QuickCheck

     

       141410
        
              ];

     
···

       141495
        
              license = lib.licenses.mit;

     

       141496
        
            }) {};

     

       141497
        
       

     

       141498
       +
         "hspec-core_2_8_4" = callPackage

     

       141499
        
           ({ mkDerivation, ansi-terminal, array, base, call-stack, clock

     

       141500
        
            , deepseq, directory, filepath, hspec-expectations, hspec-meta

     

       141501
        
            , HUnit, process, QuickCheck, quickcheck-io, random, setenv

     
···

       141503
        
            }:

     

       141504
        
            mkDerivation {

     

       141505
        
              pname = "hspec-core";

     

       141506
       +
              version = "2.8.4";

     

       141507
       +
              sha256 = "11iii063vhsr3qpcadwllmgfhyvykkh1chzpm3bzqfjm1n00vy6d";

     

       141508
        
              libraryHaskellDepends = [

     

       141509
        
                ansi-terminal array base call-stack clock deepseq directory

     

       141510
        
                filepath hspec-expectations HUnit QuickCheck quickcheck-io random

     
···

       141561
        
              maintainers = with lib.maintainers; [ maralorn ];

     

       141562
        
            }) {};

     

       141563
        
       

     

       141564
       +
         "hspec-discover_2_8_4" = callPackage

     

       141565
        
           ({ mkDerivation, base, directory, filepath, hspec-meta, mockery

     

       141566
        
            , QuickCheck

     

       141567
        
            }:

     

       141568
        
            mkDerivation {

     

       141569
        
              pname = "hspec-discover";

     

       141570
       +
              version = "2.8.4";

     

       141571
       +
              sha256 = "0nwayx09i7dfqc56gxq6pq629gnwy10bbn3px7lrq4rkbz3l86y6";

     

       141572
       +
              revision = "1";

     

       141573
       +
              editedCabalFile = "1wi0lq9zhgd5v9zavlw65dhzyw7hyivp8rv3i2ik54pk4j5gp36q";

     

       141574
        
              isLibrary = true;

     

       141575
        
              isExecutable = true;

     

       141576
        
              libraryHaskellDepends = [ base directory filepath ];

     
···

       150383
        
            }:

     

       150384
        
            mkDerivation {

     

       150385
        
              pname = "implicit-hie-cradle";

     

       150386
       +
              version = "0.4.0.1";

     

       150387
       +
              sha256 = "07k0d2lda4kj20121h8lzbjl074s90cnhbins1dvgngxbz0ddxa2";

     

       150388
        
              libraryHaskellDepends = [

     

       150389
        
                base base16-bytestring bytestring containers directory extra

     

       150390
        
                filepath hie-bios hslogger implicit-hie process temporary text time

     
···

       150582
        
            }:

     

       150583
        
            mkDerivation {

     

       150584
        
              pname = "in-other-words";

     

       150585
       +
              version = "0.2.1.0";

     

       150586
       +
              sha256 = "0cm0fxf3snk4ah3jvb9g6f711gs6zg1l7avdj51rgqnlxhsbycqb";

     

       150587
        
              libraryHaskellDepends = [

     

       150588
        
                async base exceptions monad-control mtl stm transformers

     

       150589
        
                transformers-base

     
···

       150681
        
              pname = "inchworm";

     

       150682
        
              version = "1.1.1.2";

     

       150683
        
              sha256 = "1dsrx48srmrqcw4y60prgnzxzr7nc7vyzjv0nnr2vaay3j6pxkii";

     

       150684
       +
              revision = "1";

     

       150685
       +
              editedCabalFile = "0xdak2ngj44p0p40k7pavq52f9x6yfglpixz2dp4a7sjw9hk1cxy";

     

       150686
        
              libraryHaskellDepends = [ base ];

     

       150687
        
              description = "Simple parser combinators for lexical analysis";

     

       150688
        
              license = lib.licenses.mit;

     
···

       152221
        
              ];

     

       152222
        
              description = "Integer roots and perfect powers";

     

       152223
        
              license = lib.licenses.mit;

     

       152224
       +
            }) {};

     

       152225
       +
       

     

       152226
       +
         "integer-roots_1_0_1_0" = callPackage

     

       152227
       +
           ({ mkDerivation, base, doctest, integer-gmp, smallcheck, tasty

     

       152228
       +
            , tasty-hunit, tasty-quickcheck, tasty-smallcheck

     

       152229
       +
            }:

     

       152230
       +
            mkDerivation {

     

       152231
       +
              pname = "integer-roots";

     

       152232
       +
              version = "1.0.1.0";

     

       152233
       +
              sha256 = "13x74gdh5wh9cr1yfx5l57p06aslcb3pncf8rhn6ihsfk2ni1sm4";

     

       152234
       +
              libraryHaskellDepends = [ base integer-gmp ];

     

       152235
       +
              testHaskellDepends = [

     

       152236
       +
                base doctest smallcheck tasty tasty-hunit tasty-quickcheck

     

       152237
       +
                tasty-smallcheck

     

       152238
       +
              ];

     

       152239
       +
              description = "Integer roots and perfect powers";

     

       152240
       +
              license = lib.licenses.mit;

     

       152241
       +
              hydraPlatforms = lib.platforms.none;

     

       152242
        
            }) {};

     

       152243
        
       

     

       152244
        
         "integer-simple" = callPackage

     
···

       152457
        
              pname = "intern";

     

       152458
        
              version = "0.9.4";

     

       152459
        
              sha256 = "00c74apc2ap1pjxmzk1c975zzqrc94p69l7v1fvfakv87mbrg8j0";

     

       152460
       +
              revision = "1";

     

       152461
       +
              editedCabalFile = "0xkv6g1aadm5biiqvbfp8f9jsr75prs5aqbhmcskq7s475p1fglp";

     

       152462
        
              libraryHaskellDepends = [

     

       152463
        
                array base bytestring hashable text unordered-containers

     

       152464
        
              ];

     
···

       153678
        
            }:

     

       153679
        
            mkDerivation {

     

       153680
        
              pname = "iproute";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       153681
        
              version = "1.7.12";

     

       153682
        
              sha256 = "0qvb4d7nw8f6j4s09cnpn6z1rdwcwknwklfrhsgivg7wg4aisxgi";

     

       153683
        
              libraryHaskellDepends = [

     
···

       153689
        
              ];

     

       153690
        
              description = "IP Routing Table";

     

       153691
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       153692
        
            }) {};

     

       153693
        
       

     

       153694
        
         "iptables-helpers" = callPackage

     
···

       157753
        
              license = lib.licenses.gpl3Only;

     

       157754
        
            }) {};

     

       157755
        
       

     

       157756
       +
         "jsonrpc-tinyclient" = callPackage

     

       157757
       +
           ({ mkDerivation, aeson, base, bytestring, exceptions, http-client

     

       157758
       +
            , http-client-tls, mtl, random, text, websockets

     

       157759
       +
            }:

     

       157760
       +
            mkDerivation {

     

       157761
       +
              pname = "jsonrpc-tinyclient";

     

       157762
       +
              version = "1.0.0.0";

     

       157763
       +
              sha256 = "02xhijk3rk4c9yqh1ghs8gvi1r7fwbxba0h21nb23545wflg0bz9";

     

       157764
       +
              libraryHaskellDepends = [

     

       157765
       +
                aeson base bytestring exceptions http-client http-client-tls mtl

     

       157766
       +
                random text websockets

     

       157767
       +
              ];

     

       157768
       +
              description = "Tiny JSON-RPC client for Haskell Web3 library";

     

       157769
       +
              license = lib.licenses.asl20;

     

       157770
       +
            }) {};

     

       157771
       +
       

     

       157772
        
         "jsons-to-schema" = callPackage

     

       157773
        
           ({ mkDerivation, aeson, aeson-pretty, base, bytestring, conduit

     

       157774
        
            , conduit-combinators, containers, Glob, hjsonschema, hspec

     
···

       158773
        
            }:

     

       158774
        
            mkDerivation {

     

       158775
        
              pname = "katip";

     

       158776
       +
              version = "0.8.7.0";

     

       158777
       +
              sha256 = "1m74n6fyxczfgg3swkkgr6864mzji1l0dpwpxk5zd93488zrij9v";

     

       158778
        
              libraryHaskellDepends = [

     

       158779
        
                aeson async auto-update base bytestring containers either hostname

     

       158780
        
                microlens microlens-th monad-control mtl old-locale resourcet

     
···

       159874
        
            , blaze-builder, bytestring, case-insensitive, conduit

     

       159875
        
            , conduit-extra, containers, data-default, directory, filepath

     

       159876
        
            , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy

     

       159877
       +
            , http-types, HUnit, indexed-traversable, lifted-base, mtl, network

     

       159878
       +
            , optparse-applicative, process, random, regex-tdfa, stm, tar

     

       159879
       +
            , template-haskell, text, time, tls, tls-session-manager

     

       159880
       +
            , transformers, unix, unix-compat, unordered-containers, vector

     

       159881
       +
            , wai, wai-app-static, wai-extra, warp, warp-tls, yaml, zlib

     

       159882
        
            }:

     

       159883
        
            mkDerivation {

     

       159884
        
              pname = "keter";

     

       159885
       +
              version = "1.6";

     

       159886
       +
              sha256 = "1adqib4zk0a32hi3i0cxf3z0ljx12hymzxh5mag6sr0mx64qcsr1";

     

       159887
        
              isLibrary = true;

     

       159888
        
              isExecutable = true;

     

       159889
        
              libraryHaskellDepends = [

     

       159890
        
                aeson array async attoparsec base blaze-builder bytestring

     

       159891
        
                case-insensitive conduit conduit-extra containers data-default

     

       159892
        
                directory filepath fsnotify http-client http-conduit

     

       159893
       +
                http-reverse-proxy http-types indexed-traversable lifted-base mtl

     

       159894
       +
                network optparse-applicative process random regex-tdfa stm tar

     

       159895
       +
                template-haskell text time tls tls-session-manager transformers

     

       159896
       +
                unix unix-compat unordered-containers vector wai wai-app-static

     

       159897
       +
                wai-extra warp warp-tls yaml zlib

     

       159898
        
              ];

     

       159899
        
              executableHaskellDepends = [ base data-default filepath ];

     

       159900
        
              testHaskellDepends = [

     
···

       160050
        
              pname = "keys";

     

       160051
        
              version = "3.12.3";

     

       160052
        
              sha256 = "0ik6wsff306dnbz0v3gpiajlj5b558hrk9176fzcb2fclf4447nm";

     

       160053
       +
              revision = "1";

     

       160054
       +
              editedCabalFile = "18fapd53nby46p5103y1m2hwpixn5p12mbyvb8va71pk4b77qlcy";

     

       160055
        
              libraryHaskellDepends = [

     

       160056
        
                array base comonad containers free hashable semigroupoids

     

       160057
        
                semigroups tagged transformers transformers-compat

     
···

       161268
        
           ({ mkDerivation, base }:

     

       161269
        
            mkDerivation {

     

       161270
        
              pname = "lacroix";

     

       161271
       +
              version = "0.2.0.0";

     

       161272
       +
              sha256 = "131h3fnr8wxvbr8b7qqf82zjxnidpq4v6qx1bimcnby366nc7val";

     

       161273
        
              libraryHaskellDepends = [ base ];

     

       161274
        
              description = "fizzy n dizzy";

     

       161275
        
              license = lib.licenses.mit;

     
···

       163603
        
              ];

     

       163604
        
              description = "Numerical Linear Algebra using LAPACK";

     

       163605
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       163606
        
            }) {};

     

       163607
        
       

     

       163608
        
         "lapack_0_4" = callPackage

     
···

       163634
        
              description = "Numerical Linear Algebra using LAPACK";

     

       163635
        
              license = lib.licenses.bsd3;

     

       163636
        
              hydraPlatforms = lib.platforms.none;

     

       0
        
       
     

       163637
        
            }) {};

     

       163638
        
       

     

       163639
        
         "lapack-carray" = callPackage

     
···

       163719
        
              description = "Conversion of objects between 'lapack' and 'hmatrix'";

     

       163720
        
              license = lib.licenses.bsd3;

     

       163721
        
              hydraPlatforms = lib.platforms.none;

     

       163722
       +
              broken = true;

     

       163723
        
            }) {};

     

       163724
        
       

     

       163725
        
         "large-hashable" = callPackage

     
···

       165426
        
              license = lib.licenses.bsd3;

     

       165427
        
            }) {};

     

       165428
        
       

     

       165429
       +
         "lens-family-th_0_5_2_1" = callPackage

     

       165430
       +
           ({ mkDerivation, base, hspec, template-haskell, transformers }:

     

       165431
       +
            mkDerivation {

     

       165432
       +
              pname = "lens-family-th";

     

       165433
       +
              version = "0.5.2.1";

     

       165434
       +
              sha256 = "1w8k68a1lyfd79xkc4fbf6z7p5gpriq4pjgb4n9p58az6awnn7dh";

     

       165435
       +
              libraryHaskellDepends = [ base template-haskell ];

     

       165436
       +
              testHaskellDepends = [ base hspec template-haskell transformers ];

     

       165437
       +
              description = "Generate lens-family style lenses";

     

       165438
       +
              license = lib.licenses.bsd3;

     

       165439
       +
              hydraPlatforms = lib.platforms.none;

     

       165440
       +
            }) {};

     

       165441
       +
       

     

       165442
        
         "lens-filesystem" = callPackage

     

       165443
        
           ({ mkDerivation, base, directory, filepath, hspec, lens

     

       165444
        
            , lens-action

     
···

       166363
        
              pname = "libfuse3";

     

       166364
        
              version = "0.1.2.0";

     

       166365
        
              sha256 = "0a59b4xag5vzisrnvf4v1zkdsdzky96h8w2mdj6cip3vgr196frb";

     

       166366
       +
              revision = "4";

     

       166367
       +
              editedCabalFile = "1ra0c9yaihppggv1qy66iy8lhswlyd58qql49v3gwmzb81cccmjp";

     

       166368
        
              isLibrary = true;

     

       166369
        
              isExecutable = true;

     

       166370
        
              libraryHaskellDepends = [

     
···

       167403
        
              pname = "lift-generics";

     

       167404
        
              version = "0.2.1";

     

       167405
        
              sha256 = "1qkzq8hcb6j15cslv577bmhjcxmljzsrryysdgd7r99kr3q445b4";

     

       167406
       +
              revision = "1";

     

       167407
       +
              editedCabalFile = "0i0qxm2fi34bnpnwk5k61yjx72pc9j8jhbx44xk176pw7y2pinxd";

     

       167408
        
              libraryHaskellDepends = [

     

       167409
        
                base generic-deriving ghc-prim template-haskell th-compat

     

       167410
        
              ];

     
···

       167585
        
              pname = "lifx-lan";

     

       167586
        
              version = "0.5.0.1";

     

       167587
        
              sha256 = "0rww31gcp5asbc0zb6fz7ddgw3dih6l2mc0rln7nf3qd04hplk6v";

     

       167588
       +
              revision = "2";

     

       167589
       +
              editedCabalFile = "0k4lm2qbqq4xb5rxb0nik5sc898g4w7k050j4gs1ri4xbz32z7cn";

     

       167590
        
              libraryHaskellDepends = [

     

       167591
        
                base binary bytestring composition containers extra monad-loops mtl

     

       167592
        
                network random safe text time transformers

     
···

       168093
        
              ];

     

       168094
        
              description = "Compute resistance of linear electrical circuits";

     

       168095
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       168096
        
            }) {};

     

       168097
        
       

     

       168098
        
         "linear-circuit_0_1_0_3" = callPackage

     
···

       168150
        
            }:

     

       168151
        
            mkDerivation {

     

       168152
        
              pname = "linear-generics";

     

       168153
       +
              version = "0.2";

     

       168154
       +
              sha256 = "16l117m3zblla1cn5866mknvhc1s9737qhld6bym4xsyqsgvh2sz";

     

       168155
        
              libraryHaskellDepends = [

     

       168156
        
                base containers ghc-prim template-haskell th-abstraction

     

       168157
        
              ];

     
···

       170161
        
              pname = "llvm-ffi-tools";

     

       170162
        
              version = "0.0.0.1";

     

       170163
        
              sha256 = "0nicgcdlywb8w5fr7hi5hgayv9phwslp5s47p2c30kavj7c3f3zk";

     

       170164
       +
              revision = "1";

     

       170165
       +
              editedCabalFile = "1wmwrhjs732izgbihbbb7l856pgxa1q5f32z06935ykwfwy160x7";

     

       170166
        
              isLibrary = false;

     

       170167
        
              isExecutable = true;

     

       170168
        
              executableHaskellDepends = [

     
···

       170170
        
              ];

     

       170171
        
              description = "Tools for maintaining the llvm-ffi package";

     

       170172
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       170173
        
            }) {};

     

       170174
        
       

     

       170175
        
         "llvm-general" = callPackage

     
···

       170345
        
              ];

     

       170346
        
              description = "Generate Pkg-Config configuration file for LLVM";

     

       170347
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       0
        
       
     

       170348
        
            }) {};

     

       170349
        
       

     

       170350
        
         "llvm-pretty" = callPackage

     
···

       172239
        
           ({ mkDerivation, base, lua, tasty, tasty-hunit }:

     

       172240
        
            mkDerivation {

     

       172241
        
              pname = "lpeg";

     

       172242
       +
              version = "1.0.1";

     

       172243
       +
              sha256 = "0zhg7d85s6rx1dh3mndpjjy3k8b5ixyz28wl6i8zvn2mxyx40y98";

     

       172244
        
              libraryHaskellDepends = [ base lua ];

     

       172245
        
              testHaskellDepends = [ base lua tasty tasty-hunit ];

     

       172246
        
              description = "LPeg – Parsing Expression Grammars For Lua";

     
···

       172792
        
              license = lib.licenses.bsd3;

     

       172793
        
            }) {};

     

       172794
        
       

     

       172795
       +
         "lucid_2_11_0" = callPackage

     

       172796
        
           ({ mkDerivation, base, bifunctors, blaze-builder, bytestring

     

       172797
        
            , containers, criterion, deepseq, hashable, hspec, HUnit, mmorph

     

       172798
        
            , mtl, parsec, text, transformers, unordered-containers

     

       172799
        
            }:

     

       172800
        
            mkDerivation {

     

       172801
        
              pname = "lucid";

     

       172802
       +
              version = "2.11.0";

     

       172803
       +
              sha256 = "1m1f13vxn3pwc7wvhx0czzxlx2ws8lzdgxlxd1707cx79jyib5sl";

     

       172804
       +
              revision = "1";

     

       172805
       +
              editedCabalFile = "0ai0rxiyni9cxzad3ix50vkxqqmgxfd1vpqzfrmmll1swxpicd8q";

     

       172806
        
              libraryHaskellDepends = [

     

       172807
        
                base blaze-builder bytestring containers hashable mmorph mtl text

     

       172808
        
                transformers unordered-containers

     
···

       172831
        
              testHaskellDepends = [ base lucid text ];

     

       172832
        
              description = "Use Alpine.js in your lucid templates";

     

       172833
        
              license = lib.licenses.bsd3;

     

       172834
       +
            }) {};

     

       172835
       +
       

     

       172836
       +
         "lucid-alpine_0_1_0_4" = callPackage

     

       172837
       +
           ({ mkDerivation, base, lucid, text }:

     

       172838
       +
            mkDerivation {

     

       172839
       +
              pname = "lucid-alpine";

     

       172840
       +
              version = "0.1.0.4";

     

       172841
       +
              sha256 = "1pr2fg5r43jvgh694lhqbmwl1dida9ymgw161j16dcj66jx8fjk6";

     

       172842
       +
              isLibrary = true;

     

       172843
       +
              isExecutable = true;

     

       172844
       +
              libraryHaskellDepends = [ base lucid text ];

     

       172845
       +
              executableHaskellDepends = [ base lucid text ];

     

       172846
       +
              testHaskellDepends = [ base lucid text ];

     

       172847
       +
              description = "Use Alpine.js in your lucid templates";

     

       172848
       +
              license = lib.licenses.bsd3;

     

       172849
       +
              hydraPlatforms = lib.platforms.none;

     

       172850
        
            }) {};

     

       172851
        
       

     

       172852
        
         "lucid-cdn" = callPackage

     
···

       172916
        
              license = lib.licenses.bsd3;

     

       172917
        
            }) {};

     

       172918
        
       

     

       172919
       +
         "lucid-htmx_0_1_0_3" = callPackage

     

       172920
       +
           ({ mkDerivation, base, lucid, servant, text }:

     

       172921
       +
            mkDerivation {

     

       172922
       +
              pname = "lucid-htmx";

     

       172923
       +
              version = "0.1.0.3";

     

       172924
       +
              sha256 = "1fgb4gika5f3bbba2as4bkg6m8nn2w25k17m45b389rwmhyg6syj";

     

       172925
       +
              libraryHaskellDepends = [ base lucid servant text ];

     

       172926
       +
              testHaskellDepends = [ base lucid servant text ];

     

       172927
       +
              description = "Use htmx in your lucid templates";

     

       172928
       +
              license = lib.licenses.bsd3;

     

       172929
       +
              hydraPlatforms = lib.platforms.none;

     

       172930
       +
            }) {};

     

       172931
       +
       

     

       172932
        
         "lucid-svg" = callPackage

     

       172933
        
           ({ mkDerivation, base, blaze-builder, lucid, text, transformers }:

     

       172934
        
            mkDerivation {

     
···

       174158
        
              ];

     

       174159
        
              description = "Compute solutions for Magico puzzle";

     

       174160
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       174161
        
            }) {};

     

       174162
        
       

     

       174163
        
         "magico_0_0_2_2" = callPackage

     
···

       176370
        
            }:

     

       176371
        
            mkDerivation {

     

       176372
        
              pname = "matplotlib";

     

       176373
       +
              version = "0.7.6";

     

       176374
       +
              sha256 = "0wykzz4d6a55x3bxn9r01bvgvz26yvldgyrnz87rqncxymdawmd4";

     

       176375
        
              libraryHaskellDepends = [

     

       176376
        
                aeson base bytestring containers deepseq filepath process split

     

       176377
        
                temporary

     
···

       176384
        
              license = lib.licenses.bsd3;

     

       176385
        
            }) {};

     

       176386
        
       

     

       176387
       +
         "matplotlib_0_7_7" = callPackage

     

       176388
        
           ({ mkDerivation, ad, aeson, base, bytestring, containers, deepseq

     

       176389
        
            , directory, filepath, process, random, raw-strings-qq, split

     

       176390
        
            , tasty, tasty-expected-failure, tasty-golden, tasty-hunit

     
···

       176392
        
            }:

     

       176393
        
            mkDerivation {

     

       176394
        
              pname = "matplotlib";

     

       176395
       +
              version = "0.7.7";

     

       176396
       +
              sha256 = "08qwqnsdch7hzyy0jiz6yvirf0gqm9xx24i3ikm5q993prsdpi2h";

     

       176397
        
              libraryHaskellDepends = [

     

       176398
        
                aeson base bytestring containers deepseq filepath process split

     

       176399
        
                temporary

     
···

       176637
        
            }:

     

       176638
        
            mkDerivation {

     

       176639
        
              pname = "matterhorn";

     

       176640
       +
              version = "50200.14.1";

     

       176641
       +
              sha256 = "0bxz54881pypwwr2acxarsk362708vwii2krq1ya0kg2ybhcxh72";

     

       176642
        
              isLibrary = true;

     

       176643
        
              isExecutable = true;

     

       176644
        
              enableSeparateDataOutput = true;

     
···

       178212
        
              pname = "mercury-api";

     

       178213
        
              version = "0.1.0.2";

     

       178214
        
              sha256 = "0ybpc1kai85rflgdr80jd8cvwxaxmbphv82nz2p17502jrmdfkhg";

     

       178215
       +
              revision = "7";

     

       178216
       +
              editedCabalFile = "1qgcph7cmdxijxfgpwwszbyh07kwalnqli4fp85s7z1fxqfwl5n8";

     

       178217
        
              isLibrary = true;

     

       178218
        
              isExecutable = true;

     

       178219
        
              libraryHaskellDepends = [

     
···

       178974
        
              pname = "microaeson";

     

       178975
        
              version = "0.1.0.0";

     

       178976
        
              sha256 = "1hbpyz6p9snnd85h2y0pdqp20svxrggavbv0q8z33sc5i4p8b7iz";

     

       178977
       +
              revision = "4";

     

       178978
       +
              editedCabalFile = "0rrdyk6clik8g3biv40rpg50qzfacb9yrd45ah85xpmk8flbzcfx";

     

       178979
        
              libraryHaskellDepends = [

     

       178980
        
                array base bytestring containers deepseq text

     

       178981
        
              ];

     
···

       179221
        
              license = lib.licenses.bsd3;

     

       179222
        
            }) {};

     

       179223
        
       

     

       179224
       +
         "microlens-platform_0_4_2_1" = callPackage

     

       179225
       +
           ({ mkDerivation, base, hashable, microlens, microlens-ghc

     

       179226
       +
            , microlens-mtl, microlens-th, text, unordered-containers, vector

     

       179227
       +
            }:

     

       179228
       +
            mkDerivation {

     

       179229
       +
              pname = "microlens-platform";

     

       179230
       +
              version = "0.4.2.1";

     

       179231
       +
              sha256 = "0z8snyzy18kqj32fb89mzgscjrg6w2z0jkkj4b9vl2jvbps0gkg6";

     

       179232
       +
              libraryHaskellDepends = [

     

       179233
       +
                base hashable microlens microlens-ghc microlens-mtl microlens-th

     

       179234
       +
                text unordered-containers vector

     

       179235
       +
              ];

     

       179236
       +
              description = "microlens + all batteries included (best for apps)";

     

       179237
       +
              license = lib.licenses.bsd3;

     

       179238
       +
              hydraPlatforms = lib.platforms.none;

     

       179239
       +
            }) {};

     

       179240
       +
       

     

       179241
        
         "microlens-process" = callPackage

     

       179242
        
           ({ mkDerivation, base, Cabal, cabal-doctest, doctest, filepath

     

       179243
        
            , microlens, process

     
···

       179579
        
            }:

     

       179580
        
            mkDerivation {

     

       179581
        
              pname = "mighttpd2";

     

       179582
       +
              version = "4.0.2";

     

       179583
       +
              sha256 = "0q09adyhaa9mxajj5fg3fsdpckdh3icp2bvm1f64l1m3jqxw8k8x";

     

       179584
        
              isLibrary = true;

     

       179585
        
              isExecutable = true;

     

       179586
        
              enableSeparateDataOutput = true;

     
···

       180379
        
              license = lib.licenses.bsd3;

     

       180380
        
            }) {};

     

       180381
        
       

     

       180382
       +
         "mintty_0_1_3" = callPackage

     

       180383
       +
           ({ mkDerivation, base }:

     

       180384
       +
            mkDerivation {

     

       180385
       +
              pname = "mintty";

     

       180386
       +
              version = "0.1.3";

     

       180387
       +
              sha256 = "07gy5w0zbx9q64kdr6rzkwdxrgxh2h188bkdvbbgxwk86m9q9i7x";

     

       180388
       +
              libraryHaskellDepends = [ base ];

     

       180389
       +
              description = "A reliable way to detect the presence of a MinTTY console on Windows";

     

       180390
       +
              license = lib.licenses.bsd3;

     

       180391
       +
              hydraPlatforms = lib.platforms.none;

     

       180392
       +
            }) {};

     

       180393
       +
       

     

       180394
        
         "mios" = callPackage

     

       180395
        
           ({ mkDerivation, base, bytestring, ghc-prim, gitrev, hspec

     

       180396
        
            , primitive, vector

     
···

       181075
        
              hydraPlatforms = lib.platforms.none;

     

       181076
        
            }) {};

     

       181077
        
       

     

       181078
       +
         "mmark-ext_0_2_1_4" = callPackage

     

       181079
       +
           ({ mkDerivation, base, foldl, ghc-syntax-highlighter, hspec

     

       181080
       +
            , hspec-discover, lucid, microlens, mmark, modern-uri, skylighting

     

       181081
       +
            , text

     

       181082
       +
            }:

     

       181083
       +
            mkDerivation {

     

       181084
       +
              pname = "mmark-ext";

     

       181085
       +
              version = "0.2.1.4";

     

       181086
       +
              sha256 = "02ygx0kkp69gd2n4bnqjzbwzhs9ksqm148jf6zfgn3z8w1p9glzh";

     

       181087
       +
              enableSeparateDataOutput = true;

     

       181088
       +
              libraryHaskellDepends = [

     

       181089
       +
                base foldl ghc-syntax-highlighter lucid microlens mmark modern-uri

     

       181090
       +
                skylighting text

     

       181091
       +
              ];

     

       181092
       +
              testHaskellDepends = [ base hspec lucid mmark skylighting text ];

     

       181093
       +
              testToolDepends = [ hspec-discover ];

     

       181094
       +
              description = "Commonly useful extensions for the MMark markdown processor";

     

       181095
       +
              license = lib.licenses.bsd3;

     

       181096
       +
              hydraPlatforms = lib.platforms.none;

     

       181097
       +
            }) {};

     

       181098
       +
       

     

       181099
        
         "mmorph_1_1_3" = callPackage

     

       181100
        
           ({ mkDerivation, base, mtl, transformers, transformers-compat }:

     

       181101
        
            mkDerivation {

     
···

       181242
        
            }:

     

       181243
        
            mkDerivation {

     

       181244
        
              pname = "mmsyn6ukr-array";

     

       181245
       +
              version = "0.3.1.0";

     

       181246
       +
              sha256 = "1xmi3qbifk4hw9lgm33ldh6cfrwhppr7kg0cimlv2vmzpcz2ski2";

     

       181247
        
              isLibrary = true;

     

       181248
        
              isExecutable = true;

     

       181249
        
              enableSeparateDataOutput = true;

     
···

       183083
        
            }) {};

     

       183084
        
       

     

       183085
        
         "monad-tree" = callPackage

     

       183086
       +
           ({ mkDerivation, base, mtl, transformers }:

     

       183087
        
            mkDerivation {

     

       183088
        
              pname = "monad-tree";

     

       183089
       +
              version = "0.2.0.0";

     

       183090
       +
              sha256 = "1k3vbxc4z03inryalw725nwgb9xh92lwdw31746irzhwgbvrfqjk";

     

       183091
       +
              libraryHaskellDepends = [ base mtl transformers ];

     

       183092
        
              description = "Tree data structure for nondeterministic computations";

     

       183093
        
              license = lib.licenses.mit;

     

       183094
        
            }) {};

     
···

       183743
        
              ];

     

       183744
        
              description = "Type-classes for interacting with monomorphic containers with a key";

     

       183745
        
              license = lib.licenses.bsd3;

     

       183746
       +
            }) {};

     

       183747
       +
       

     

       183748
       +
         "mono-traversable-keys_0_2_0" = callPackage

     

       183749
       +
           ({ mkDerivation, base, bytestring, containers, hashable, keys

     

       183750
       +
            , mono-traversable, text, transformers, unordered-containers

     

       183751
       +
            , vector, vector-instances

     

       183752
       +
            }:

     

       183753
       +
            mkDerivation {

     

       183754
       +
              pname = "mono-traversable-keys";

     

       183755
       +
              version = "0.2.0";

     

       183756
       +
              sha256 = "0v0bh73l6fa3bvyfakm2sbp9qi7bd8aw468kr8d51zsl8r0b6nil";

     

       183757
       +
              libraryHaskellDepends = [

     

       183758
       +
                base bytestring containers hashable keys mono-traversable text

     

       183759
       +
                transformers unordered-containers vector vector-instances

     

       183760
       +
              ];

     

       183761
       +
              description = "Type-classes for interacting with monomorphic containers with a key";

     

       183762
       +
              license = lib.licenses.bsd3;

     

       183763
       +
              hydraPlatforms = lib.platforms.none;

     

       183764
        
            }) {};

     

       183765
        
       

     

       183766
        
         "mono-traversable-wrapper" = callPackage

     
···

       184465
        
              license = lib.licenses.mit;

     

       184466
        
            }) {};

     

       184467
        
       

     

       184468
       +
         "morpheus-graphql_0_18_0" = callPackage

     

       184469
       +
           ({ mkDerivation, aeson, base, bytestring, containers

     

       184470
       +
            , morpheus-graphql-app, morpheus-graphql-code-gen

     

       184471
       +
            , morpheus-graphql-core, morpheus-graphql-subscriptions

     

       184472
       +
            , morpheus-graphql-tests, mtl, relude, tasty, tasty-hunit

     

       184473
       +
            , template-haskell, text, transformers, unordered-containers

     

       184474
       +
            , vector

     

       184475
       +
            }:

     

       184476
       +
            mkDerivation {

     

       184477
       +
              pname = "morpheus-graphql";

     

       184478
       +
              version = "0.18.0";

     

       184479
       +
              sha256 = "1358hjnxla83v7rkn49r07cs8n49czm5shfdpc3avl564w1bzmzi";

     

       184480
       +
              enableSeparateDataOutput = true;

     

       184481
       +
              libraryHaskellDepends = [

     

       184482
       +
                aeson base bytestring containers morpheus-graphql-app

     

       184483
       +
                morpheus-graphql-code-gen morpheus-graphql-core mtl relude

     

       184484
       +
                template-haskell text transformers unordered-containers vector

     

       184485
       +
              ];

     

       184486
       +
              testHaskellDepends = [

     

       184487
       +
                aeson base bytestring containers morpheus-graphql-app

     

       184488
       +
                morpheus-graphql-code-gen morpheus-graphql-core

     

       184489
       +
                morpheus-graphql-subscriptions morpheus-graphql-tests mtl relude

     

       184490
       +
                tasty tasty-hunit template-haskell text transformers

     

       184491
       +
                unordered-containers vector

     

       184492
       +
              ];

     

       184493
       +
              description = "Morpheus GraphQL";

     

       184494
       +
              license = lib.licenses.mit;

     

       184495
       +
              hydraPlatforms = lib.platforms.none;

     

       184496
       +
            }) {};

     

       184497
       +
       

     

       184498
        
         "morpheus-graphql-app" = callPackage

     

       184499
        
           ({ mkDerivation, aeson, base, bytestring, containers, directory

     

       184500
        
            , hashable, megaparsec, morpheus-graphql-core, mtl, relude

     
···

       184521
        
              license = lib.licenses.mit;

     

       184522
        
            }) {};

     

       184523
        
       

     

       184524
       +
         "morpheus-graphql-app_0_18_0" = callPackage

     

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

     

       184526
       +
            , hashable, megaparsec, morpheus-graphql-core

     

       184527
       +
            , morpheus-graphql-tests, mtl, relude, scientific, tasty

     

       184528
       +
            , tasty-hunit, template-haskell, text, th-lift-instances

     

       184529
       +
            , transformers, unordered-containers, vector

     

       184530
       +
            }:

     

       184531
       +
            mkDerivation {

     

       184532
       +
              pname = "morpheus-graphql-app";

     

       184533
       +
              version = "0.18.0";

     

       184534
       +
              sha256 = "1s9v87pgn7fdnyx1776y4nvf0kx0ry08r5522dyqgwzfgd4s059z";

     

       184535
       +
              enableSeparateDataOutput = true;

     

       184536
       +
              libraryHaskellDepends = [

     

       184537
       +
                aeson base bytestring containers hashable megaparsec

     

       184538
       +
                morpheus-graphql-core mtl relude scientific template-haskell text

     

       184539
       +
                th-lift-instances transformers unordered-containers vector

     

       184540
       +
              ];

     

       184541
       +
              testHaskellDepends = [

     

       184542
       +
                aeson base bytestring containers directory hashable megaparsec

     

       184543
       +
                morpheus-graphql-core morpheus-graphql-tests mtl relude scientific

     

       184544
       +
                tasty tasty-hunit template-haskell text th-lift-instances

     

       184545
       +
                transformers unordered-containers vector

     

       184546
       +
              ];

     

       184547
       +
              description = "Morpheus GraphQL App";

     

       184548
       +
              license = lib.licenses.mit;

     

       184549
       +
              hydraPlatforms = lib.platforms.none;

     

       184550
       +
            }) {};

     

       184551
       +
       

     

       184552
        
         "morpheus-graphql-cli" = callPackage

     

       184553
        
           ({ mkDerivation, base, bytestring, filepath, morpheus-graphql

     

       184554
        
            , optparse-applicative

     
···

       184594
        
              license = lib.licenses.mit;

     

       184595
        
            }) {};

     

       184596
        
       

     

       184597
       +
         "morpheus-graphql-client_0_18_0" = callPackage

     

       184598
       +
           ({ mkDerivation, aeson, base, bytestring, directory

     

       184599
       +
            , morpheus-graphql-code-gen, morpheus-graphql-core, mtl, relude

     

       184600
       +
            , tasty, tasty-hunit, template-haskell, text, transformers

     

       184601
       +
            , unordered-containers

     

       184602
       +
            }:

     

       184603
       +
            mkDerivation {

     

       184604
       +
              pname = "morpheus-graphql-client";

     

       184605
       +
              version = "0.18.0";

     

       184606
       +
              sha256 = "0i8f932gq3p1ybh764pkr189iisbjqcjcq92awqyzxgpj39j0gg0";

     

       184607
       +
              enableSeparateDataOutput = true;

     

       184608
       +
              libraryHaskellDepends = [

     

       184609
       +
                aeson base bytestring morpheus-graphql-code-gen

     

       184610
       +
                morpheus-graphql-core mtl relude template-haskell text transformers

     

       184611
       +
                unordered-containers

     

       184612
       +
              ];

     

       184613
       +
              testHaskellDepends = [

     

       184614
       +
                aeson base bytestring directory morpheus-graphql-code-gen

     

       184615
       +
                morpheus-graphql-core mtl relude tasty tasty-hunit template-haskell

     

       184616
       +
                text transformers unordered-containers

     

       184617
       +
              ];

     

       184618
       +
              description = "Morpheus GraphQL Client";

     

       184619
       +
              license = lib.licenses.mit;

     

       184620
       +
              hydraPlatforms = lib.platforms.none;

     

       184621
       +
            }) {};

     

       184622
       +
       

     

       184623
       +
         "morpheus-graphql-code-gen" = callPackage

     

       184624
       +
           ({ mkDerivation, base, bytestring, containers, filepath

     

       184625
       +
            , morpheus-graphql-core, optparse-applicative, prettyprinter

     

       184626
       +
            , relude, template-haskell, text, unordered-containers

     

       184627
       +
            }:

     

       184628
       +
            mkDerivation {

     

       184629
       +
              pname = "morpheus-graphql-code-gen";

     

       184630
       +
              version = "0.18.0";

     

       184631
       +
              sha256 = "1965y2wd813y82mllzrnhiyjk2mp0vi7j6x7phwlmpabmsij5x0f";

     

       184632
       +
              isLibrary = true;

     

       184633
       +
              isExecutable = true;

     

       184634
       +
              libraryHaskellDepends = [

     

       184635
       +
                base bytestring containers morpheus-graphql-core prettyprinter

     

       184636
       +
                relude template-haskell text unordered-containers

     

       184637
       +
              ];

     

       184638
       +
              executableHaskellDepends = [

     

       184639
       +
                base bytestring containers filepath morpheus-graphql-core

     

       184640
       +
                optparse-applicative prettyprinter relude template-haskell text

     

       184641
       +
                unordered-containers

     

       184642
       +
              ];

     

       184643
       +
              description = "Morpheus GraphQL CLI";

     

       184644
       +
              license = lib.licenses.bsd3;

     

       184645
       +
              hydraPlatforms = lib.platforms.none;

     

       184646
       +
              broken = true;

     

       184647
       +
            }) {};

     

       184648
       +
       

     

       184649
        
         "morpheus-graphql-core" = callPackage

     

       184650
        
           ({ mkDerivation, aeson, base, bytestring, containers, directory

     

       184651
        
            , hashable, megaparsec, mtl, relude, scientific, tasty, tasty-hunit

     
···

       184671
        
              license = lib.licenses.mit;

     

       184672
        
            }) {};

     

       184673
        
       

     

       184674
       +
         "morpheus-graphql-core_0_18_0" = callPackage

     

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

     

       184676
       +
            , hashable, megaparsec, morpheus-graphql-tests, mtl, relude

     

       184677
       +
            , scientific, tasty, tasty-hunit, template-haskell, text

     

       184678
       +
            , th-lift-instances, transformers, unordered-containers, vector

     

       184679
       +
            }:

     

       184680
       +
            mkDerivation {

     

       184681
       +
              pname = "morpheus-graphql-core";

     

       184682
       +
              version = "0.18.0";

     

       184683
       +
              sha256 = "07j3i5dfc245l9gil3dk6c5sd7853m5923dxa993fj4gd564mwfd";

     

       184684
       +
              enableSeparateDataOutput = true;

     

       184685
       +
              libraryHaskellDepends = [

     

       184686
       +
                aeson base bytestring containers hashable megaparsec mtl relude

     

       184687
       +
                scientific template-haskell text th-lift-instances transformers

     

       184688
       +
                unordered-containers vector

     

       184689
       +
              ];

     

       184690
       +
              testHaskellDepends = [

     

       184691
       +
                aeson base bytestring containers directory hashable megaparsec

     

       184692
       +
                morpheus-graphql-tests mtl relude scientific tasty tasty-hunit

     

       184693
       +
                template-haskell text th-lift-instances transformers

     

       184694
       +
                unordered-containers vector

     

       184695
       +
              ];

     

       184696
       +
              description = "Morpheus GraphQL Core";

     

       184697
       +
              license = lib.licenses.mit;

     

       184698
       +
              hydraPlatforms = lib.platforms.none;

     

       184699
       +
            }) {};

     

       184700
       +
       

     

       184701
        
         "morpheus-graphql-subscriptions" = callPackage

     

       184702
        
           ({ mkDerivation, aeson, base, bytestring, directory

     

       184703
        
            , morpheus-graphql-app, morpheus-graphql-core, mtl, relude, tasty

     
···

       184722
        
              license = lib.licenses.mit;

     

       184723
        
            }) {};

     

       184724
        
       

     

       184725
       +
         "morpheus-graphql-subscriptions_0_18_0" = callPackage

     

       184726
       +
           ({ mkDerivation, aeson, base, bytestring, directory

     

       184727
       +
            , morpheus-graphql-app, morpheus-graphql-core, mtl, relude, tasty

     

       184728
       +
            , tasty-hunit, text, transformers, unliftio-core

     

       184729
       +
            , unordered-containers, uuid, websockets

     

       184730
       +
            }:

     

       184731
       +
            mkDerivation {

     

       184732
       +
              pname = "morpheus-graphql-subscriptions";

     

       184733
       +
              version = "0.18.0";

     

       184734
       +
              sha256 = "02xpnrvd8wydp1b7jvk2pqcrx6ldn8nvffz22g0l5xrrpcvhg9s4";

     

       184735
       +
              libraryHaskellDepends = [

     

       184736
       +
                aeson base bytestring morpheus-graphql-app morpheus-graphql-core

     

       184737
       +
                mtl relude text transformers unliftio-core unordered-containers

     

       184738
       +
                uuid websockets

     

       184739
       +
              ];

     

       184740
       +
              testHaskellDepends = [

     

       184741
       +
                aeson base bytestring directory morpheus-graphql-app

     

       184742
       +
                morpheus-graphql-core mtl relude tasty tasty-hunit text

     

       184743
       +
                transformers unliftio-core unordered-containers uuid websockets

     

       184744
       +
              ];

     

       184745
       +
              description = "Morpheus GraphQL Subscriptions";

     

       184746
       +
              license = lib.licenses.mit;

     

       184747
       +
              hydraPlatforms = lib.platforms.none;

     

       184748
       +
            }) {};

     

       184749
       +
       

     

       184750
       +
         "morpheus-graphql-tests" = callPackage

     

       184751
       +
           ({ mkDerivation, aeson, base, bytestring, directory, relude, tasty

     

       184752
       +
            , tasty-hunit, text, unordered-containers

     

       184753
       +
            }:

     

       184754
       +
            mkDerivation {

     

       184755
       +
              pname = "morpheus-graphql-tests";

     

       184756
       +
              version = "0.18.0";

     

       184757
       +
              sha256 = "0l89mmsl09ph412l8f9xjlyx8yp5g69ffmajynxcqvj501n21s9z";

     

       184758
       +
              libraryHaskellDepends = [

     

       184759
       +
                aeson base bytestring directory relude tasty tasty-hunit text

     

       184760
       +
                unordered-containers

     

       184761
       +
              ];

     

       184762
       +
              description = "Morpheus GraphQL Test";

     

       184763
       +
              license = lib.licenses.mit;

     

       184764
       +
            }) {};

     

       184765
       +
       

     

       184766
        
         "morphisms" = callPackage

     

       184767
        
           ({ mkDerivation }:

     

       184768
        
            mkDerivation {

     
···

       189197
        
              pname = "nats";

     

       189198
        
              version = "1.1.2";

     

       189199
        
              sha256 = "1v40drmhixck3pz3mdfghamh73l4rp71mzcviipv1y8jhrfxilmr";

     

       189200
       +
              revision = "4";

     

       189201
       +
              editedCabalFile = "0qccypqkfs7hi0v2bsjfqfhpi2jgsnpfwi9vmcqh7jxk5g08njk0";

     

       189202
        
              doHaddock = false;

     

       189203
        
              description = "Natural numbers";

     

       189204
        
              license = lib.licenses.bsd3;

     
···

       191458
        
              pname = "network-transport";

     

       191459
        
              version = "0.5.4";

     

       191460
        
              sha256 = "0izcqi3zl7ynav0qqrrfmiax8vziqwrhflprddhjj6x6nkzhp1sv";

     

       191461
       +
              revision = "1";

     

       191462
       +
              editedCabalFile = "03parnmzh2mffs6fadqbf4lw1d5bsmvr347rzamp230s303nr6yc";

     

       191463
        
              libraryHaskellDepends = [

     

       191464
        
                base binary bytestring deepseq hashable transformers

     

       191465
        
              ];

     
···

       191554
        
              pname = "network-transport-tests";

     

       191555
        
              version = "0.3.0";

     

       191556
        
              sha256 = "1552mgccfyyvvnplhflkfxgg3246jgx9iiv71a0gwblllbsh5y8p";

     

       191557
       +
              revision = "1";

     

       191558
       +
              editedCabalFile = "0kk8kib742s3iiah6d9g94ma776m4nyh14syvibsssfj1immf3jd";

     

       191559
        
              libraryHaskellDepends = [

     

       191560
        
                ansi-terminal base bytestring containers mtl network-transport

     

       191561
        
                random

     
···

       192588
        
            }) {};

     

       192589
        
       

     

       192590
        
         "nix-diff" = callPackage

     

       192591
       +
           ({ mkDerivation, attoparsec, base, containers, directory, filepath

     

       192592
       +
            , mtl, nix-derivation, optparse-applicative, patience, process

     

       192593
       +
            , text, unix, vector

     

       192594
        
            }:

     

       192595
        
            mkDerivation {

     

       192596
        
              pname = "nix-diff";

     

       192597
       +
              version = "1.0.16";

     

       192598
       +
              sha256 = "1l6d43d4pr9ql4lbcslk9cjw1lxj9y0bbgxdfqxrj46lg9w63h6g";

     

       192599
        
              isLibrary = false;

     

       192600
        
              isExecutable = true;

     

       192601
        
              executableHaskellDepends = [

     

       192602
       +
                attoparsec base containers directory filepath mtl nix-derivation

     

       192603
       +
                optparse-applicative patience process text unix vector

     

       192604
        
              ];

     

       192605
        
              description = "Explain why two Nix derivations differ";

     

       192606
        
              license = lib.licenses.bsd3;

     
···

       192778
        
            }:

     

       192779
        
            mkDerivation {

     

       192780
        
              pname = "nix-tree";

     

       192781
       +
              version = "0.1.9";

     

       192782
       +
              sha256 = "1xgb7f735afq0x7y3lsdciv9mk7cf9szbazn9fksb7fxf437w27m";

     

       192783
        
              isLibrary = false;

     

       192784
        
              isExecutable = true;

     

       192785
        
              executableHaskellDepends = [

     
···

       193666
        
              pname = "normalization-insensitive";

     

       193667
        
              version = "2.0.2";

     

       193668
        
              sha256 = "1rr12rrij64hi6jkd42h4x2m86k1ra10ykzpzc38n6rfdhyiswpn";

     

       193669
       +
              revision = "1";

     

       193670
       +
              editedCabalFile = "0q5h2017r0zwgi2xdrznhq2llljz9bslqnhq1l5zczrm9xs3304x";

     

       193671
        
              libraryHaskellDepends = [

     

       193672
        
                base bytestring deepseq hashable text unicode-transforms

     

       193673
        
              ];

     
···

       194580
        
            }) {};

     

       194581
        
       

     

       194582
        
         "numeric-kinds" = callPackage

     

       194583
       +
           ({ mkDerivation, base, type-compare }:

     

       194584
        
            mkDerivation {

     

       194585
        
              pname = "numeric-kinds";

     

       194586
       +
              version = "0.2.0";

     

       194587
       +
              sha256 = "0ba882bjp7gzqdfy15jgi8kbls2cjbp7860vzc7winzlsf0zqdy1";

     

       194588
       +
              libraryHaskellDepends = [ base type-compare ];

     

       0
        
       
     

       0
        
       
     

       194589
        
              description = "Type-level numeric types and classes";

     

       194590
        
              license = lib.licenses.asl20;

     

       194591
        
            }) {};

     
···

       196609
        
              license = lib.licenses.bsd3;

     

       196610
        
            }) {};

     

       196611
        
       

     

       196612
       +
         "opaleye_0_7_6_2" = callPackage

     

       196613
       +
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       196614
       +
            , case-insensitive, containers, contravariant, dotenv, hspec

     

       196615
       +
            , hspec-discover, multiset, postgresql-simple, pretty

     

       196616
       +
            , product-profunctors, profunctors, QuickCheck, scientific

     

       196617
       +
            , semigroups, text, time, time-compat, time-locale-compat

     

       196618
       +
            , transformers, uuid, void

     

       196619
       +
            }:

     

       196620
       +
            mkDerivation {

     

       196621
       +
              pname = "opaleye";

     

       196622
       +
              version = "0.7.6.2";

     

       196623
       +
              sha256 = "0dln0r4qk5k4gmjg06275zgbzgivwxw471sd0y4l01j3x7ix3q46";

     

       196624
       +
              libraryHaskellDepends = [

     

       196625
       +
                aeson base base16-bytestring bytestring case-insensitive

     

       196626
       +
                contravariant postgresql-simple pretty product-profunctors

     

       196627
       +
                profunctors scientific semigroups text time-compat

     

       196628
       +
                time-locale-compat transformers uuid void

     

       196629
       +
              ];

     

       196630
       +
              testHaskellDepends = [

     

       196631
       +
                aeson base bytestring containers contravariant dotenv hspec

     

       196632
       +
                hspec-discover multiset postgresql-simple product-profunctors

     

       196633
       +
                profunctors QuickCheck semigroups text time time-compat

     

       196634
       +
         "interpolatedstring-qq" = callPackage

     

       196635
       +
              ];

     

       196636
       +
              testToolDepends = [ hspec-discover ];

     

       196637
       +
              description = "An SQL-generating DSL targeting PostgreSQL";

     

       196638
       +
              license = lib.licenses.bsd3;

     

       196639
       +
              hydraPlatforms = lib.platforms.none;

     

       196640
       +
            }) {};

     

       196641
       +
       

     

       196642
        
         "opaleye-classy" = callPackage

     

       196643
        
           ({ mkDerivation, base, bytestring, lens, mtl, opaleye

     

       196644
        
            , postgresql-simple, product-profunctors, transformers

     
···

       197006
        
              pname = "openapi3";

     

       197007
        
              version = "3.1.0";

     

       197008
        
              sha256 = "011754qyxxw5mn06hdmxalvsiff7a4x4k2yb2r6ylzr6zhyz818z";

     

       197009
       +
              revision = "2";

     

       197010
       +
              editedCabalFile = "0hjczkslbn7m9vpn6vqxsr0b8aqa6im8pms3jbfcd7pfkp810z2s";

     

       197011
        
              isLibrary = true;

     

       197012
        
              isExecutable = true;

     

       197013
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       197896
        
            }:

     

       197897
        
            mkDerivation {

     

       197898
        
              pname = "opentracing";

     

       197899
       +
              version = "0.2.1";

     

       197900
       +
              sha256 = "0p2y996cl5hfw85kdr0majymxccv2d1ka15wbyc2qxgskz3dy9cq";

     

       197901
        
              libraryHaskellDepends = [

     

       197902
        
                aeson async base base64-bytestring bytestring case-insensitive

     

       197903
        
                clock containers http-types iproute lens mtl mwc-random network

     
···

       198075
        
              license = lib.licenses.bsd3;

     

       198076
        
            }) {};

     

       198077
        
       

     

       198078
       +
         "operational_0_2_4_1" = callPackage

     

       198079
       +
           ({ mkDerivation, base, mtl, random }:

     

       198080
       +
            mkDerivation {

     

       198081
       +
              pname = "operational";

     

       198082
       +
              version = "0.2.4.1";

     

       198083
       +
              sha256 = "0aa1pxymvkhbs0x03ikfiap2skzyf2z7307kz5adkmb3qmykcqa2";

     

       198084
       +
              isLibrary = true;

     

       198085
       +
              isExecutable = true;

     

       198086
       +
              libraryHaskellDepends = [ base mtl ];

     

       198087
       +
              executableHaskellDepends = [ base mtl random ];

     

       198088
       +
              description = "Implementation of difficult monads made easy with operational semantics";

     

       198089
       +
              license = lib.licenses.bsd3;

     

       198090
       +
              hydraPlatforms = lib.platforms.none;

     

       198091
       +
            }) {};

     

       198092
       +
       

     

       198093
        
         "operational-alacarte" = callPackage

     

       198094
        
           ({ mkDerivation, base, mtl }:

     

       198095
        
            mkDerivation {

     
···

       198654
        
              ];

     

       198655
        
              description = "Auto-generate a command-line parser for your datatype";

     

       198656
        
              license = lib.licenses.bsd3;

     

       198657
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       198658
       +
            }) {};

     

       198659
       +
       

     

       198660
       +
         "optparse-generic_1_4_7" = callPackage

     

       198661
       +
           ({ mkDerivation, base, bytestring, Only, optparse-applicative

     

       198662
       +
            , system-filepath, text, time, transformers, transformers-compat

     

       198663
       +
            , void

     

       198664
       +
            }:

     

       198665
       +
            mkDerivation {

     

       198666
       +
              pname = "optparse-generic";

     

       198667
       +
              version = "1.4.7";

     

       198668
       +
              sha256 = "03s6iwfr2iiypnx3wmnrb37zz7kflk40dj38v8j4ccqxkkf9h0kk";

     

       198669
       +
              libraryHaskellDepends = [

     

       198670
       +
                base bytestring Only optparse-applicative system-filepath text time

     

       198671
       +
                transformers transformers-compat void

     

       198672
       +
              ];

     

       198673
       +
              description = "Auto-generate a command-line parser for your datatype";

     

       198674
       +
              license = lib.licenses.bsd3;

     

       198675
       +
              hydraPlatforms = lib.platforms.none;

     

       198676
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       198677
        
            }) {};

     

       198678
        
       

     
···

       199285
        
            }:

     

       199286
        
            mkDerivation {

     

       199287
        
              pname = "orthotope";

     

       199288
       +
              version = "0.1.1.0";

     

       199289
       +
              sha256 = "0hjhy9i73r223s3p9xnbw2ac34dvnanrsdnnl6c9707ymjhy57jq";

     

       199290
        
              libraryHaskellDepends = [

     

       199291
        
                base deepseq dlist pretty QuickCheck vector

     

       199292
        
              ];

     
···

       199295
        
                test-framework-quickcheck2 vector

     

       199296
        
              ];

     

       199297
        
              description = "Multidimensional arrays inspired by APL";

     

       199298
       +
              license = lib.licenses.asl20;

     

       199299
       +
            }) {};

     

       199300
       +
       

     

       199301
       +
         "orthotope-hmatrix" = callPackage

     

       199302
       +
           ({ mkDerivation, base, hmatrix, orthotope }:

     

       199303
       +
            mkDerivation {

     

       199304
       +
              pname = "orthotope-hmatrix";

     

       199305
       +
              version = "0.1.0.1";

     

       199306
       +
              sha256 = "0xibg10wx0adchksxfr8087lrbp0h384lddq0dmvpk9hvc5j2qhl";

     

       199307
       +
              libraryHaskellDepends = [ base hmatrix orthotope ];

     

       199308
       +
              description = "Some algorithms from hmatrix";

     

       199309
        
              license = lib.licenses.asl20;

     

       199310
        
            }) {};

     

       199311
        
       

     
···

       200564
        
            }:

     

       200565
        
            mkDerivation {

     

       200566
        
              pname = "pandoc-crossref";

     

       200567
       +
              version = "0.3.12.1";

     

       200568
       +
              sha256 = "036lw5qa23bg292hgfj3ybfykbqj80fb2f8a26rnivj5pfqblm3w";

     

       0
        
       
     

       0
        
       
     

       200569
        
              isLibrary = true;

     

       200570
        
              isExecutable = true;

     

       200571
        
              enableSeparateDataOutput = true;

     
···

       206391
        
              broken = true;

     

       206392
        
            }) {};

     

       206393
        
       

     

       206394
       +
         "pg-entity" = callPackage

     

       206395
       +
           ({ mkDerivation, base, bytestring, colourista, exceptions, hspec

     

       206396
       +
            , hspec-expectations-lifted, hspec-pg-transact, monad-control

     

       206397
       +
            , parsec, pg-transact, postgresql-simple

     

       206398
       +
            , postgresql-simple-migration, resource-pool, safe-exceptions

     

       206399
       +
            , template-haskell, text, text-manipulate, time, uuid, vector

     

       206400
       +
            }:

     

       206401
       +
            mkDerivation {

     

       206402
       +
              pname = "pg-entity";

     

       206403
       +
              version = "0.0.1.0";

     

       206404
       +
              sha256 = "0njmlxxisigza4k6v5ci36xm6mpf5jdls2mrlarlw91agxiz8zd9";

     

       206405
       +
              libraryHaskellDepends = [

     

       206406
       +
                base bytestring colourista exceptions monad-control parsec

     

       206407
       +
                pg-transact postgresql-simple resource-pool safe-exceptions

     

       206408
       +
                template-haskell text text-manipulate time uuid vector

     

       206409
       +
              ];

     

       206410
       +
              testHaskellDepends = [

     

       206411
       +
                base hspec hspec-expectations-lifted hspec-pg-transact pg-transact

     

       206412
       +
                postgresql-simple postgresql-simple-migration text time uuid vector

     

       206413
       +
              ];

     

       206414
       +
              description = "A pleasant PostgreSQL layer";

     

       206415
       +
              license = lib.licenses.mit;

     

       206416
       +
              hydraPlatforms = lib.platforms.none;

     

       206417
       +
            }) {};

     

       206418
       +
       

     

       206419
        
         "pg-extras" = callPackage

     

       206420
        
           ({ mkDerivation, base, bytestring, HUnit, postgresql-simple

     

       206421
        
            , raw-strings-qq, text, time

     
···

       207073
        
            }:

     

       207074
        
            mkDerivation {

     

       207075
        
              pname = "phonetic-languages-simplified-base";

     

       207076
       +
              version = "0.4.1.0";

     

       207077
       +
              sha256 = "0jwwa1xj1k2bj9iw89lpks04q62zg6sp5ixfhlbs83zwhfz2jplb";

     

       207078
        
              libraryHaskellDepends = [

     

       207079
        
                base phonetic-languages-permutations-array subG

     

       207080
        
              ];

     
···

       207111
        
            }:

     

       207112
        
            mkDerivation {

     

       207113
        
              pname = "phonetic-languages-simplified-examples-array";

     

       207114
       +
              version = "0.15.1.0";

     

       207115
       +
              sha256 = "1y9i8278737dqil8gx8m27c8fwlzi949wb86z31r9v8k8irsx3p1";

     

       207116
        
              isLibrary = true;

     

       207117
        
              isExecutable = true;

     

       207118
        
              libraryHaskellDepends = [

     
···

       207263
        
            }:

     

       207264
        
            mkDerivation {

     

       207265
        
              pname = "phonetic-languages-simplified-properties-array";

     

       207266
       +
              version = "0.12.0.0";

     

       207267
       +
              sha256 = "1m4ficmkzp3k6xsg9dby8ch8k8zlc4jvgxxr76pnhy29dkgs8yxp";

     

       207268
        
              libraryHaskellDepends = [

     

       207269
        
                base phonetic-languages-rhythmicity

     

       207270
        
                phonetic-languages-simplified-base ukrainian-phonetics-basic-array

     
···

       210510
        
              pname = "pointed";

     

       210511
        
              version = "5.0.3";

     

       210512
        
              sha256 = "0999bba0gbb2qhk1ydaslmdf7ca17ip751psi4phi1lhb250fl8b";

     

       210513
       +
              revision = "1";

     

       210514
       +
              editedCabalFile = "00x5chjb3l43n35g7amaj3x32ahlwffp7v5khc1qmzxfqz6z50mv";

     

       210515
        
              libraryHaskellDepends = [

     

       210516
        
                base comonad containers data-default-class hashable kan-extensions

     

       210517
        
                semigroupoids semigroups stm tagged transformers

     
···

       211209
        
            }:

     

       211210
        
            mkDerivation {

     

       211211
        
              pname = "polysemy-RandomFu";

     

       211212
       +
              version = "0.4.4.0";

     

       211213
       +
              sha256 = "0mh6iiyz859446l8r54bqg8hmaig40kdapq9k4niry35nba6fdr1";

     

       211214
        
              libraryHaskellDepends = [

     

       211215
        
                base polysemy polysemy-plugin polysemy-zoo random-fu random-source

     

       211216
        
              ];

     
···

       213217
        
            }:

     

       213218
        
            mkDerivation {

     

       213219
        
              pname = "postgresql-migration";

     

       213220
       +
              version = "0.2.1.3";

     

       213221
       +
              sha256 = "1qxkan5f328rv3nl31pvhz305k7b4ah98s0j1bc4hcaa5g5d3052";

     

       0
        
       
     

       0
        
       
     

       213222
        
              isLibrary = true;

     

       213223
        
              isExecutable = true;

     

       213224
        
              libraryHaskellDepends = [

     
···

       218422
        
              pname = "pseudo-boolean";

     

       218423
        
              version = "0.1.10.0";

     

       218424
        
              sha256 = "1p9w1d80d2kp7wp7wp6xf9dz1iv9knhy8b75mklz7zq3cf5gvnrh";

     

       218425
       +
              revision = "1";

     

       218426
       +
              editedCabalFile = "05jvm2bhvzsxwiazsvgk6xwzjg1isabqnx8grx1v9hrxr6hjhlap";

     

       218427
        
              libraryHaskellDepends = [

     

       218428
        
                attoparsec base bytestring bytestring-builder containers deepseq

     

       218429
        
                dlist hashable megaparsec parsec void

     
···

       218509
        
            }:

     

       218510
        
            mkDerivation {

     

       218511
        
              pname = "psqueues";

     

       218512
       +
              version = "0.2.7.3";

     

       218513
       +
              sha256 = "1cmz7spfzx7niglmsphnndh0m4b8njkn0fhb9nshbnbq6nx515yh";

     

       0
        
       
     

       0
        
       
     

       218514
        
              libraryHaskellDepends = [ base deepseq ghc-prim hashable ];

     

       218515
        
              testHaskellDepends = [

     

       218516
        
                array base deepseq ghc-prim hashable HUnit QuickCheck tagged tasty

     
···

       219570
        
              license = lib.licenses.mit;

     

       219571
        
            }) {};

     

       219572
        
       

     

       219573
       +
         "pusher-http-haskell_2_1_0_6" = callPackage

     

       219574
       +
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       219575
       +
            , cryptonite, hashable, hspec, http-client, http-client-tls

     

       219576
       +
            , http-types, memory, QuickCheck, text, time, unordered-containers

     

       219577
       +
            }:

     

       219578
       +
            mkDerivation {

     

       219579
       +
              pname = "pusher-http-haskell";

     

       219580
       +
              version = "2.1.0.6";

     

       219581
       +
              sha256 = "029pxzidmflsa19417bcx82hbxj3yq1khzb6skf97xbzzf3hs6ki";

     

       219582
       +
              libraryHaskellDepends = [

     

       219583
       +
                aeson base base16-bytestring bytestring cryptonite hashable

     

       219584
       +
                http-client http-client-tls http-types memory text time

     

       219585
       +
                unordered-containers

     

       219586
       +
              ];

     

       219587
       +
              testHaskellDepends = [

     

       219588
       +
                aeson base bytestring hspec QuickCheck text unordered-containers

     

       219589
       +
              ];

     

       219590
       +
              description = "Haskell client library for the Pusher Channels HTTP API";

     

       219591
       +
              license = lib.licenses.mit;

     

       219592
       +
              hydraPlatforms = lib.platforms.none;

     

       219593
       +
            }) {};

     

       219594
       +
       

     

       219595
        
         "pusher-ws" = callPackage

     

       219596
        
           ({ mkDerivation, aeson, base, bytestring, containers, deepseq

     

       219597
        
            , hashable, http-conduit, lens, lens-aeson, network, scientific

     
···

       221978
        
            }:

     

       221979
        
            mkDerivation {

     

       221980
        
              pname = "r-glpk-phonetic-languages-ukrainian-durations";

     

       221981
       +
              version = "0.4.1.0";

     

       221982
       +
              sha256 = "1zgxr7c2szzmwk9n9hdir2nfg4gzpzwk4jgzlb95m5wlpagsz3fl";

     

       221983
        
              isLibrary = true;

     

       221984
        
              isExecutable = true;

     

       221985
        
              libraryHaskellDepends = [

     
···

       224599
        
            }:

     

       224600
        
            mkDerivation {

     

       224601
        
              pname = "readline-in-other-words";

     

       224602
       +
              version = "0.1.0.2";

     

       224603
       +
              sha256 = "1wldgk1dfq4kalxi3mmsyja39mvk2hb40fl83cwqbvhn39brfmq9";

     

       224604
        
              isLibrary = true;

     

       224605
        
              isExecutable = true;

     

       224606
        
              libraryHaskellDepends = [

     
···

       224613
        
              ];

     

       224614
        
              description = "Readline effect for in-other-words";

     

       224615
        
              license = lib.licenses.bsd2;

     

       224616
       +
              hydraPlatforms = lib.platforms.none;

     

       224617
       +
              broken = true;

     

       224618
        
            }) {};

     

       224619
        
       

     

       224620
        
         "readline-statevar" = callPackage

     
···

       224861
        
              license = lib.licenses.mit;

     

       224862
        
            }) {};

     

       224863
        
       

     

       224864
       +
         "rebase_1_13_1" = callPackage

     

       224865
       +
           ({ mkDerivation, base, bifunctors, bytestring, comonad, containers

     

       224866
       +
            , contravariant, deepseq, dlist, either, hashable, hashable-time

     

       224867
       +
            , mtl, profunctors, scientific, selective, semigroupoids, stm, text

     

       224868
       +
            , time, transformers, unordered-containers, uuid-types, vector

     

       224869
       +
            , vector-instances, void

     

       224870
       +
            }:

     

       224871
       +
            mkDerivation {

     

       224872
       +
              pname = "rebase";

     

       224873
       +
              version = "1.13.1";

     

       224874
       +
              sha256 = "1ffl4lxan27g6fkhyddbgf7n0b57l4zbzngrz0fajdfp96xklsn4";

     

       224875
       +
              libraryHaskellDepends = [

     

       224876
       +
                base bifunctors bytestring comonad containers contravariant deepseq

     

       224877
       +
                dlist either hashable hashable-time mtl profunctors scientific

     

       224878
       +
                selective semigroupoids stm text time transformers

     

       224879
       +
                unordered-containers uuid-types vector vector-instances void

     

       224880
       +
              ];

     

       224881
       +
              description = "A more progressive alternative to the \"base\" package";

     

       224882
       +
              license = lib.licenses.mit;

     

       224883
       +
              hydraPlatforms = lib.platforms.none;

     

       224884
       +
            }) {};

     

       224885
       +
       

     

       224886
        
         "rebindable" = callPackage

     

       224887
        
           ({ mkDerivation, base, data-default-class, indexed }:

     

       224888
        
            mkDerivation {

     
···

       224960
        
            }:

     

       224961
        
            mkDerivation {

     

       224962
        
              pname = "record-dot-preprocessor";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       224963
        
              version = "0.2.13";

     

       224964
        
              sha256 = "0kqk8iiqhpqrr0b0bxcy0vqp159cnsf9zri45hbp4npqm2lvcw37";

     

       224965
        
              isLibrary = true;

     
···

       224969
        
              testHaskellDepends = [ base extra filepath record-hasfield ];

     

       224970
        
              description = "Preprocessor to allow record.field syntax";

     

       224971
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       224972
        
            }) {};

     

       224973
        
       

     

       224974
        
         "record-encode" = callPackage

     
···

       225537
        
              pname = "reducers";

     

       225538
        
              version = "3.12.4";

     

       225539
        
              sha256 = "0hsycdir52jdijnnvc77jj971fjrrc722v952wr62ivrvx2zarn0";

     

       225540
       +
              revision = "1";

     

       225541
       +
              editedCabalFile = "0i5mvhfp5b6dmmk8l93492cyjxn6n9dncmijpbp4hbqi40pr9g47";

     

       225542
        
              libraryHaskellDepends = [

     

       225543
        
                array base bytestring containers fingertree hashable semigroupoids

     

       225544
        
                text transformers unordered-containers

     
···

       229296
        
              license = lib.licenses.mit;

     

       229297
        
            }) {};

     

       229298
        
       

     

       229299
       +
         "rerebase_1_13_1" = callPackage

     

       229300
       +
           ({ mkDerivation, rebase }:

     

       229301
       +
            mkDerivation {

     

       229302
       +
              pname = "rerebase";

     

       229303
       +
              version = "1.13.1";

     

       229304
       +
              sha256 = "1g3lwnkykl4np2fzylhi7469y10a3vpxxn1i5mqhm0mmx5lwrhw3";

     

       229305
       +
              libraryHaskellDepends = [ rebase ];

     

       229306
       +
              description = "Reexports from \"base\" with a bunch of other standard libraries";

     

       229307
       +
              license = lib.licenses.mit;

     

       229308
       +
              hydraPlatforms = lib.platforms.none;

     

       229309
       +
            }) {};

     

       229310
       +
       

     

       229311
        
         "reroute" = callPackage

     

       229312
        
           ({ mkDerivation, base, criterion, deepseq, graph-core, hashable

     

       229313
        
            , hspec, http-api-data, hvect, mtl, random, regex-compat, text

     
···

       229426
        
              executableHaskellDepends = [ base comfort-array lapack ];

     

       229427
        
              description = "Compute total resistance of a cube of resistors";

     

       229428
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       229429
        
            }) {};

     

       229430
        
       

     

       229431
        
         "resistor-cube_0_0_1_3" = callPackage

     
···

       234455
        
              pname = "salak";

     

       234456
        
              version = "0.3.6";

     

       234457
        
              sha256 = "00qyd09az0ldfidfgcki8z3r9gcpxmss3iyr99as5bky29rlz9n3";

     

       234458
       +
              revision = "6";

     

       234459
       +
              editedCabalFile = "1wrq2rdrxk96an5k1igcn09cma3dz9y2yp58xjlg2lh22djm297m";

     

       234460
        
              libraryHaskellDepends = [

     

       234461
        
                base bytestring containers data-default directory dlist exceptions

     

       234462
        
                filepath hashable heaps megaparsec mtl scientific text time

     
···

       235209
        
            }:

     

       235210
        
            mkDerivation {

     

       235211
        
              pname = "satyros";

     

       235212
       +
              version = "0.3.1.3";

     

       235213
       +
              sha256 = "1d0x3cm0wf4bpncb73b3mzmpcwdnwyf3pi7848hr3blnz5v3aj2b";

     

       235214
        
              libraryHaskellDepends = [

     

       235215
        
                base containers extra free lens mtl random vector

     

       235216
        
              ];

     
···

       238508
        
              pname = "semigroupoids";

     

       238509
        
              version = "5.3.6";

     

       238510
        
              sha256 = "0glhqc9x8i5z3bdg23xvl2lfns95msid3h3x0jksna7i6c8j869n";

     

       238511
       +
              revision = "2";

     

       238512
       +
              editedCabalFile = "0gnkd1kf1s412p7g4c1l1d1yykhl5hlvdnnn1c85c0h8pi19y4an";

     

       238513
        
              libraryHaskellDepends = [

     

       238514
        
                base base-orphans bifunctors comonad containers contravariant

     

       238515
        
                distributive hashable tagged template-haskell transformers

     
···

       238757
        
            }:

     

       238758
        
            mkDerivation {

     

       238759
        
              pname = "sensei";

     

       238760
       +
              version = "0.6.0";

     

       238761
       +
              sha256 = "19hbm83v3bn2ximfd5bqjzq1xb079ajxbw1kc8gkm9ds4mg7aw0b";

     

       238762
        
              isLibrary = false;

     

       238763
        
              isExecutable = true;

     

       238764
        
              executableHaskellDepends = [

     
···

       240753
        
            }:

     

       240754
        
            mkDerivation {

     

       240755
        
              pname = "servant-lucid";

     

       240756
       +
              version = "0.9.0.3";

     

       240757
       +
              sha256 = "10g7radhkh50hpwf97syh3kpdacw096bnawni0hwwbi6rfgz38nm";

     

       240758
        
              libraryHaskellDepends = [ base http-media lucid servant text ];

     

       240759
        
              testHaskellDepends = [ base lucid servant-server wai warp ];

     

       240760
        
              description = "Servant support for lucid";

     
···

       245160
        
              license = lib.licenses.bsd3;

     

       245161
        
            }) {};

     

       245162
        
       

     

       245163
       +
         "silently_1_2_5_2" = callPackage

     

       245164
       +
           ({ mkDerivation, base, deepseq, directory, nanospec, temporary }:

     

       245165
       +
            mkDerivation {

     

       245166
       +
              pname = "silently";

     

       245167
       +
              version = "1.2.5.2";

     

       245168
       +
              sha256 = "15dnp83b0wj7m5v4r2yfrwxg9g6szv94ldcb74fpidninrqgqns6";

     

       245169
       +
              libraryHaskellDepends = [ base deepseq directory ];

     

       245170
       +
              testHaskellDepends = [ base deepseq directory nanospec temporary ];

     

       245171
       +
              description = "Prevent or capture writing to stdout and other handles";

     

       245172
       +
              license = lib.licenses.bsd3;

     

       245173
       +
              hydraPlatforms = lib.platforms.none;

     

       245174
       +
            }) {};

     

       245175
       +
       

     

       245176
        
         "silkscreen" = callPackage

     

       245177
        
           ({ mkDerivation, base, prettyprinter }:

     

       245178
        
            mkDerivation {

     
···

       246692
        
              license = lib.licenses.bsd3;

     

       246693
        
            }) {};

     

       246694
        
       

     

       246695
       +
         "singletons-presburger_0_6_1_0" = callPackage

     

       246696
       +
           ({ mkDerivation, base, ghc-typelits-presburger, mtl, reflection

     

       246697
       +
            , singletons

     

       246698
       +
            }:

     

       246699
       +
            mkDerivation {

     

       246700
       +
              pname = "singletons-presburger";

     

       246701
       +
              version = "0.6.1.0";

     

       246702
       +
              sha256 = "1s12g1qcdz035y2lzjivw2m2jm9hqvbwvgmxvahn4a2j89f4zgky";

     

       246703
       +
              isLibrary = true;

     

       246704
       +
              isExecutable = true;

     

       246705
       +
              libraryHaskellDepends = [

     

       246706
       +
                base ghc-typelits-presburger mtl reflection singletons

     

       246707
       +
              ];

     

       246708
       +
              description = "Presburger Arithmetic Solver for GHC Type-level natural numbers with Singletons package";

     

       246709
       +
              license = lib.licenses.bsd3;

     

       246710
       +
              hydraPlatforms = lib.platforms.none;

     

       246711
       +
            }) {};

     

       246712
       +
       

     

       246713
        
         "singletons-th" = callPackage

     

       246714
        
           ({ mkDerivation, base, containers, ghc-boot-th, mtl, singletons

     

       246715
        
            , syb, template-haskell, th-desugar, th-orphans, transformers

     
···

       250478
        
            }) {};

     

       250479
        
       

     

       250480
        
         "snumber" = callPackage

     

       250481
       +
           ({ mkDerivation, base, numeric-kinds, type-compare }:

     

       250482
        
            mkDerivation {

     

       250483
        
              pname = "snumber";

     

       250484
       +
              version = "0.3.0";

     

       250485
       +
              sha256 = "16kgy0chysxws8n4651qq6bfwyk184v67iv2h2kbiyxl8wqsjq4l";

     

       250486
       +
              libraryHaskellDepends = [ base numeric-kinds type-compare ];

     

       0
        
       
     

       0
        
       
     

       250487
        
              description = "Integer singletons with flexible representation";

     

       250488
        
              license = lib.licenses.asl20;

     

       250489
        
            }) {};

     
···

       251957
        
              pname = "special-values";

     

       251958
        
              version = "0.1.0.0";

     

       251959
        
              sha256 = "1kkdw2c4d2hha99v9f89ahmifjxp7fxmxyfwq9a8xk6s0h9xs51w";

     

       251960
       +
              revision = "1";

     

       251961
       +
              editedCabalFile = "10pbx4px4kmg6nwb78bayi26dlzbzvji5zv9fa6f45rk19p2sdlc";

     

       251962
        
              libraryHaskellDepends = [

     

       251963
        
                base bytestring ieee754 scientific text

     

       251964
        
              ];

     
···

       256979
        
              license = lib.licenses.mit;

     

       256980
        
            }) {};

     

       256981
        
       

     

       256982
       +
         "streaming-commons_0_2_2_2" = callPackage

     

       256983
       +
           ({ mkDerivation, array, async, base, bytestring, deepseq, directory

     

       256984
       +
            , gauge, hspec, network, process, QuickCheck, random, stm, text

     

       256985
       +
            , transformers, unix, zlib

     

       256986
       +
            }:

     

       256987
       +
            mkDerivation {

     

       256988
       +
              pname = "streaming-commons";

     

       256989
       +
              version = "0.2.2.2";

     

       256990
       +
              sha256 = "0j1hwqadczg4rw9pmiv21qs9kvqxarxqg4dv4cpcrxx72b4xssvq";

     

       256991
       +
              libraryHaskellDepends = [

     

       256992
       +
                array async base bytestring directory network process random stm

     

       256993
       +
                text transformers unix zlib

     

       256994
       +
              ];

     

       256995
       +
              testHaskellDepends = [

     

       256996
       +
                array async base bytestring deepseq hspec network QuickCheck text

     

       256997
       +
                unix zlib

     

       256998
       +
              ];

     

       256999
       +
              benchmarkHaskellDepends = [ base bytestring deepseq gauge text ];

     

       257000
       +
              description = "Common lower-level functions needed by various streaming data libraries";

     

       257001
       +
              license = lib.licenses.mit;

     

       257002
       +
              hydraPlatforms = lib.platforms.none;

     

       257003
       +
            }) {};

     

       257004
       +
       

     

       257005
        
         "streaming-concurrency" = callPackage

     

       257006
        
           ({ mkDerivation, base, exceptions, hspec, HUnit, lifted-async

     

       257007
        
            , monad-control, QuickCheck, quickcheck-instances, stm, streaming

     
···

       260466
        
              license = lib.licenses.bsd3;

     

       260467
        
            }) {};

     

       260468
        
       

     

       260469
       +
         "swagger2_2_7" = callPackage

     

       260470
       +
           ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries

     

       260471
       +
            , bytestring, Cabal, cabal-doctest, containers, cookie, doctest

     

       260472
       +
            , generics-sop, Glob, hashable, hspec, hspec-discover, http-media

     

       260473
       +
            , HUnit, insert-ordered-containers, lens, mtl, network, optics-core

     

       260474
       +
            , optics-th, QuickCheck, quickcheck-instances, scientific

     

       260475
       +
            , template-haskell, text, time, transformers, unordered-containers

     

       260476
       +
            , utf8-string, uuid-types, vector

     

       260477
       +
            }:

     

       260478
       +
            mkDerivation {

     

       260479
       +
              pname = "swagger2";

     

       260480
       +
              version = "2.7";

     

       260481
       +
              sha256 = "1p3vi90siylgg94s7izmdvp2i36g017q2hnl90d1rpphi0nd1f6b";

     

       260482
       +
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       260483
       +
              libraryHaskellDepends = [

     

       260484
       +
                aeson aeson-pretty base base-compat-batteries bytestring containers

     

       260485
       +
                cookie generics-sop hashable http-media insert-ordered-containers

     

       260486
       +
                lens mtl network optics-core optics-th QuickCheck scientific

     

       260487
       +
                template-haskell text time transformers unordered-containers

     

       260488
       +
                uuid-types vector

     

       260489
       +
              ];

     

       260490
       +
              testHaskellDepends = [

     

       260491
       +
                aeson base base-compat-batteries bytestring containers doctest Glob

     

       260492
       +
                hashable hspec HUnit insert-ordered-containers lens mtl QuickCheck

     

       260493
       +
                quickcheck-instances template-haskell text time

     

       260494
       +
                unordered-containers utf8-string vector

     

       260495
       +
              ];

     

       260496
       +
              testToolDepends = [ hspec-discover ];

     

       260497
       +
              description = "Swagger 2.0 data model";

     

       260498
       +
              license = lib.licenses.bsd3;

     

       260499
       +
              hydraPlatforms = lib.platforms.none;

     

       260500
       +
            }) {};

     

       260501
       +
       

     

       260502
        
         "swapper" = callPackage

     

       260503
        
           ({ mkDerivation, base, binary, bytestring, deepseq, happstack-data

     

       260504
        
            , happstack-state, parallel, tokyocabinet

     
···

       260616
        
              license = lib.licenses.lgpl21Only;

     

       260617
        
            }) {};

     

       260618
        
       

     

       260619
       +
         "swish_0_10_0_8" = callPackage

     

       260620
       +
           ({ mkDerivation, base, containers, directory, filepath, hashable

     

       260621
       +
            , HUnit, intern, mtl, network-uri, old-locale, polyparse

     

       260622
       +
            , semigroups, test-framework, test-framework-hunit, text, time

     

       260623
       +
            }:

     

       260624
       +
            mkDerivation {

     

       260625
       +
              pname = "swish";

     

       260626
       +
              version = "0.10.0.8";

     

       260627
       +
              sha256 = "1a7iz3d78r00mgkq370zy5fxjkb5x34c9iq3kc3gbl6hs6m6l579";

     

       260628
       +
              isLibrary = true;

     

       260629
       +
              isExecutable = true;

     

       260630
       +
              enableSeparateDataOutput = true;

     

       260631
       +
              libraryHaskellDepends = [

     

       260632
       +
                base containers directory filepath hashable intern mtl network-uri

     

       260633
       +
                old-locale polyparse text time

     

       260634
       +
              ];

     

       260635
       +
              executableHaskellDepends = [ base ];

     

       260636
       +
              testHaskellDepends = [

     

       260637
       +
                base containers hashable HUnit network-uri old-locale semigroups

     

       260638
       +
                test-framework test-framework-hunit text time

     

       260639
       +
              ];

     

       260640
       +
              description = "A semantic web toolkit";

     

       260641
       +
              license = lib.licenses.lgpl21Only;

     

       260642
       +
              hydraPlatforms = lib.platforms.none;

     

       260643
       +
            }) {};

     

       260644
       +
       

     

       260645
        
         "swiss-ephemeris" = callPackage

     

       260646
        
           ({ mkDerivation, base, directory, hspec, hspec-discover, QuickCheck

     

       260647
       +
            , random, time, vector

     

       260648
        
            }:

     

       260649
        
            mkDerivation {

     

       260650
        
              pname = "swiss-ephemeris";

     

       260651
       +
              version = "1.4.0.0";

     

       260652
       +
              sha256 = "0ss502h2083qbiprspylwv02lbgidqgi106qs6k4s6jppgay34gx";

     

       260653
       +
              libraryHaskellDepends = [ base time vector ];

     

       260654
       +
              testHaskellDepends = [

     

       260655
       +
                base directory hspec QuickCheck random time vector

     

       260656
       +
              ];

     

       260657
        
              testToolDepends = [ hspec-discover ];

     

       260658
        
              description = "Haskell bindings for the Swiss Ephemeris C library";

     

       260659
        
              license = lib.licenses.agpl3Only;

     
···

       262142
        
              platforms = [

     

       262143
        
                "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"

     

       262144
        
              ];

     

       0
        
       
     

       0
        
       
     

       262145
        
            }) {};

     

       262146
        
       

     

       262147
        
         "synthesizer-core" = callPackage

     
···

       263747
        
            }) {};

     

       263748
        
       

     

       263749
        
         "tangle" = callPackage

     

       263750
       +
           ({ mkDerivation, barbies, base, containers, lens, transformers }:

     

       263751
        
            mkDerivation {

     

       263752
        
              pname = "tangle";

     

       263753
       +
              version = "0.1";

     

       263754
       +
              sha256 = "0gx8zcshi465wxxrmjrl40l8bph0md764fkjzqrq7w517x8cxdhb";

     

       263755
       +
              isLibrary = true;

     

       263756
       +
              isExecutable = true;

     

       263757
       +
              libraryHaskellDepends = [ barbies base transformers ];

     

       263758
       +
              executableHaskellDepends = [

     

       263759
       +
                barbies base containers lens transformers

     

       263760
       +
              ];

     

       263761
       +
              description = "Heterogenous memoisation monad";

     

       263762
        
              license = lib.licenses.bsd3;

     

       263763
        
            }) {};

     

       263764
        
       

     
···

       268298
        
              license = lib.licenses.bsd3;

     

       268299
        
            }) {};

     

       268300
        
       

     

       268301
       +
         "text-printer_0_5_0_2" = callPackage

     

       268302
       +
           ({ mkDerivation, base, bytestring, pretty, QuickCheck

     

       268303
       +
            , test-framework, test-framework-quickcheck2, text, text-latin1

     

       268304
       +
            }:

     

       268305
       +
            mkDerivation {

     

       268306
       +
              pname = "text-printer";

     

       268307
       +
              version = "0.5.0.2";

     

       268308
       +
              sha256 = "1qzmgqcr1bmz34h24gvnfaxaqr3c7z727xv676sd1x51y2qjj2dl";

     

       268309
       +
              libraryHaskellDepends = [

     

       268310
       +
                base bytestring pretty text text-latin1

     

       268311
       +
              ];

     

       268312
       +
              testHaskellDepends = [

     

       268313
       +
                base QuickCheck test-framework test-framework-quickcheck2

     

       268314
       +
              ];

     

       268315
       +
              description = "Abstract interface for text builders/printers";

     

       268316
       +
              license = lib.licenses.bsd3;

     

       268317
       +
              hydraPlatforms = lib.platforms.none;

     

       268318
       +
            }) {};

     

       268319
       +
       

     

       268320
        
         "text-regex-replace" = callPackage

     

       268321
        
           ({ mkDerivation, attoparsec, base, hspec, QuickCheck, smallcheck

     

       268322
        
            , text, text-icu

     
···

       269111
        
            }) {};

     

       269112
        
       

     

       269113
        
         "th-env" = callPackage

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       269114
        
           ({ mkDerivation, base, markdown-unlit, template-haskell, th-compat

     

       269115
        
            }:

     

       269116
        
            mkDerivation {

     
···

       269122
        
              testToolDepends = [ markdown-unlit ];

     

       269123
        
              description = "Template Haskell splice that expands to an environment variable";

     

       269124
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       269125
        
            }) {};

     

       269126
        
       

     

       269127
        
         "th-expand-syns" = callPackage

     
···

       269508
        
              license = lib.licenses.bsd3;

     

       269509
        
            }) {};

     

       269510
        
       

     

       269511
       +
         "th-test-utils_1_1_1" = callPackage

     

       269512
       +
           ({ mkDerivation, base, bytestring, tasty, tasty-golden, tasty-hunit

     

       269513
       +
            , template-haskell, th-orphans, transformers

     

       269514
       +
            }:

     

       269515
       +
            mkDerivation {

     

       269516
       +
              pname = "th-test-utils";

     

       269517
       +
              version = "1.1.1";

     

       269518
       +
              sha256 = "03qpszfhb58nmm673zhbkvsmw1ynjr2h19qpggyay2fk5zgq7n3q";

     

       269519
       +
              libraryHaskellDepends = [

     

       269520
       +
                base template-haskell th-orphans transformers

     

       269521
       +
              ];

     

       269522
       +
              testHaskellDepends = [

     

       269523
       +
                base bytestring tasty tasty-golden tasty-hunit template-haskell

     

       269524
       +
                th-orphans transformers

     

       269525
       +
              ];

     

       269526
       +
              description = "Utility functions for testing Template Haskell code";

     

       269527
       +
              license = lib.licenses.bsd3;

     

       269528
       +
              hydraPlatforms = lib.platforms.none;

     

       269529
       +
            }) {};

     

       269530
       +
       

     

       269531
        
         "th-to-exp" = callPackage

     

       269532
        
           ({ mkDerivation, base, hspec, template-haskell }:

     

       269533
        
            mkDerivation {

     
···

       270156
        
              pname = "threepenny-gui";

     

       270157
        
              version = "0.9.1.0";

     

       270158
        
              sha256 = "00sjkfa9qfnnwqfdw68yb8hq6nm1y5qv9896rzn5aachr7mlfpx2";

     

       270159
       +
              revision = "3";

     

       270160
       +
              editedCabalFile = "0pk2vy2lqifjdm3cw9lhl5nx7aw4ff4g8p6l8p7yc9x7h9m6va16";

     

       270161
        
              isLibrary = true;

     

       270162
        
              isExecutable = true;

     

       270163
        
              enableSeparateDataOutput = true;

     
···

       271476
        
            }) {};

     

       271477
        
       

     

       271478
        
         "timers-tick" = callPackage

     

       271479
       +
           ({ mkDerivation, base, hspec, QuickCheck }:

     

       271480
        
            mkDerivation {

     

       271481
        
              pname = "timers-tick";

     

       271482
       +
              version = "0.5.0.0";

     

       271483
       +
              sha256 = "0j4nf3l939dwn35q2qan58pxs4v82s1nh6zm5jgbpq38bhxvjvmc";

     

       271484
        
              libraryHaskellDepends = [ base ];

     

       271485
       +
              testHaskellDepends = [ base hspec QuickCheck ];

     

       271486
        
              description = "tick based timers";

     

       271487
        
              license = lib.licenses.bsd3;

     

       271488
        
            }) {};

     
···

       272982
        
              license = lib.licenses.mpl20;

     

       272983
        
            }) {};

     

       272984
        
       

     

       272985
       +
         "tomland_1_3_3_1" = callPackage

     

       272986
        
           ({ mkDerivation, base, bytestring, containers, deepseq, directory

     

       272987
        
            , hashable, hedgehog, hspec, hspec-hedgehog, hspec-megaparsec

     

       272988
       +
            , megaparsec, mtl, parser-combinators, text, time, transformers

     

       272989
       +
            , unordered-containers, validation-selective

     

       272990
        
            }:

     

       272991
        
            mkDerivation {

     

       272992
        
              pname = "tomland";

     

       272993
       +
              version = "1.3.3.1";

     

       272994
       +
              sha256 = "1hg6hx9ak43gzzn3h643z54jkp5x0wjad313j8299fsi31768wgg";

     

       272995
        
              isLibrary = true;

     

       272996
        
              isExecutable = true;

     

       272997
        
              libraryHaskellDepends = [

     
···

       272999
        
                parser-combinators text time transformers unordered-containers

     

       273000
        
                validation-selective

     

       273001
        
              ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       273002
        
              testHaskellDepends = [

     

       273003
        
                base bytestring containers directory hashable hedgehog hspec

     

       273004
        
                hspec-hedgehog hspec-megaparsec megaparsec text time

     
···

       277201
        
              hydraPlatforms = lib.platforms.none;

     

       277202
        
            }) {};

     

       277203
        
       

     

       277204
       +
         "type-compare" = callPackage

     

       277205
       +
           ({ mkDerivation, base }:

     

       277206
       +
            mkDerivation {

     

       277207
       +
              pname = "type-compare";

     

       277208
       +
              version = "0.1.1";

     

       277209
       +
              sha256 = "0k0mb43cx87i7gp6w391gvsnqzfcxdyzmn3fnwqp7nn5vy8x851c";

     

       277210
       +
              libraryHaskellDepends = [ base ];

     

       277211
       +
              description = "Type-level Ord compatibility layer";

     

       277212
       +
              license = lib.licenses.asl20;

     

       277213
       +
            }) {};

     

       277214
       +
       

     

       277215
        
         "type-digits" = callPackage

     

       277216
        
           ({ mkDerivation, base, template-haskell, type-spine }:

     

       277217
        
            mkDerivation {

     
···

       278342
        
            }:

     

       278343
        
            mkDerivation {

     

       278344
        
              pname = "typesafe-precure";

     

       278345
       +
              version = "0.8.1.1";

     

       278346
       +
              sha256 = "10siihvba8c4zbwvw247zrx9z5v5sgr8vswjbbiw9gn7qdiq8ppa";

     

       278347
        
              libraryHaskellDepends = [

     

       278348
        
                aeson aeson-pretty autoexporter base bytestring dlist

     

       278349
        
                monad-skeleton template-haskell text th-data-compat

     
···

       279041
        
           ({ mkDerivation, base, bytestring, mmsyn2-array, mmsyn5 }:

     

       279042
        
            mkDerivation {

     

       279043
        
              pname = "ukrainian-phonetics-basic-array";

     

       279044
       +
              version = "0.4.2.0";

     

       279045
       +
              sha256 = "1qw75wp493bnzwcbmhaifm4m7dj71f5q16xcscmgsysf1lj2y3m3";

     

       279046
        
              libraryHaskellDepends = [ base bytestring mmsyn2-array mmsyn5 ];

     

       279047
        
              description = "A library to work with the basic Ukrainian phonetics and syllable segmentation";

     

       279048
        
              license = lib.licenses.mit;

     
···

       279663
        
              license = lib.licenses.bsd2;

     

       279664
        
            }) {};

     

       279665
        
       

     

       279666
       +
         "unicode-collation_0_1_3_1" = callPackage

     

       279667
       +
           ({ mkDerivation, base, binary, bytestring, containers, parsec

     

       279668
       +
            , QuickCheck, quickcheck-instances, tasty, tasty-bench, tasty-hunit

     

       279669
       +
            , tasty-quickcheck, template-haskell, text, text-icu

     

       279670
       +
            , th-lift-instances, unicode-transforms

     

       279671
       +
            }:

     

       279672
       +
            mkDerivation {

     

       279673
       +
              pname = "unicode-collation";

     

       279674
       +
              version = "0.1.3.1";

     

       279675
       +
              sha256 = "1b04ml07ghfsh9cmp6b0l8c6ywxrn3c4xs7swvlmxx64asmicf3i";

     

       279676
       +
              isLibrary = true;

     

       279677
       +
              isExecutable = true;

     

       279678
       +
              libraryHaskellDepends = [

     

       279679
       +
                base binary bytestring containers parsec template-haskell text

     

       279680
       +
                th-lift-instances

     

       279681
       +
              ];

     

       279682
       +
              testHaskellDepends = [

     

       279683
       +
                base bytestring tasty tasty-hunit tasty-quickcheck text

     

       279684
       +
                unicode-transforms

     

       279685
       +
              ];

     

       279686
       +
              benchmarkHaskellDepends = [

     

       279687
       +
                base QuickCheck quickcheck-instances tasty-bench text text-icu

     

       279688
       +
              ];

     

       279689
       +
              description = "Haskell implementation of the Unicode Collation Algorithm";

     

       279690
       +
              license = lib.licenses.bsd2;

     

       279691
       +
              hydraPlatforms = lib.platforms.none;

     

       279692
       +
            }) {};

     

       279693
       +
       

     

       279694
        
         "unicode-data" = callPackage

     

       279695
        
           ({ mkDerivation, base }:

     

       279696
        
            mkDerivation {

     
···

       279778
        
              pname = "unicode-show";

     

       279779
        
              version = "0.1.0.4";

     

       279780
        
              sha256 = "158vnv6d7s1ahm3fr5s8ns585bcds8pf19rsglsyfk33qps3il9i";

     

       279781
       +
              libraryHaskellDepends = [ base ];

     

       279782
       +
              testHaskellDepends = [ base hspec QuickCheck ];

     

       279783
       +
              description = "print and show in unicode";

     

       279784
       +
              license = lib.licenses.bsd3;

     

       279785
       +
              hydraPlatforms = lib.platforms.none;

     

       279786
       +
              broken = true;

     

       279787
       +
            }) {};

     

       279788
       +
       

     

       279789
       +
         "unicode-show_0_1_0_5" = callPackage

     

       279790
       +
           ({ mkDerivation, base, hspec, QuickCheck }:

     

       279791
       +
            mkDerivation {

     

       279792
       +
              pname = "unicode-show";

     

       279793
       +
              version = "0.1.0.5";

     

       279794
       +
              sha256 = "0iq2fivi6fclra32y5yqc6p18pd7qlyxb042hkc082pvgmj8b40v";

     

       279795
        
              libraryHaskellDepends = [ base ];

     

       279796
        
              testHaskellDepends = [ base hspec QuickCheck ];

     

       279797
        
              description = "print and show in unicode";

     
···

       280070
        
              pname = "union";

     

       280071
        
              version = "0.1.2";

     

       280072
        
              sha256 = "1i4fvlwkw1wx64a6l8342aqfqsdq7fqa4p24g3i5gn5704lxrsb3";

     

       280073
       +
              revision = "7";

     

       280074
       +
              editedCabalFile = "1xcm1v2dipdahd4c6hki0fx9a7vg52q3wz5aa8nw5lxjkc4s3xn8";

     

       280075
        
              libraryHaskellDepends = [

     

       280076
        
                base deepseq hashable profunctors tagged vinyl

     

       280077
        
              ];

     
···

       280198
        
              pname = "unique";

     

       280199
        
              version = "0.0.1";

     

       280200
        
              sha256 = "1dgln2dr64ma1isqskj1qnjslg9smmr7jssg8hmk68wp36i3rwkd";

     

       280201
       +
              revision = "1";

     

       280202
       +
              editedCabalFile = "0l95cgs8hbvakrcqzqk5l9rkz3cr3jnnszq7pgjnxrqfhgsp58r7";

     

       280203
        
              libraryHaskellDepends = [ base hashable ];

     

       280204
        
              description = "Fully concurrent unique identifiers";

     

       280205
        
              license = lib.licenses.bsd3;

     
···

       280834
        
           ({ mkDerivation, base, bytestring }:

     

       280835
        
            mkDerivation {

     

       280836
        
              pname = "unix-bytestring";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       280837
        
              version = "0.3.7.6";

     

       280838
        
              sha256 = "1f9hf7blxy8ckakd0klrs16q0hfvxfarbjgyrc7azgbb86m1skb3";

     

       280839
        
              libraryHaskellDepends = [ base bytestring ];

     

       280840
        
              description = "Unix/Posix-specific functions for ByteStrings";

     

       280841
        
              license = lib.licenses.bsd3;

     

       0
        
       
     

       280842
        
            }) {};

     

       280843
        
       

     

       280844
        
         "unix-compat" = callPackage

     
···

       281245
        
              ];

     

       281246
        
              description = "Efficient hashing-based container types";

     

       281247
        
              license = lib.licenses.bsd3;

     

       281248
       +
            }) {};

     

       281249
       +
       

     

       281250
       +
         "unordered-containers_0_2_15_0" = callPackage

     

       281251
       +
           ({ mkDerivation, base, bytestring, ChasingBottoms, containers

     

       281252
       +
            , deepseq, gauge, hashable, hashmap, HUnit, mtl, QuickCheck, random

     

       281253
       +
            , test-framework, test-framework-hunit, test-framework-quickcheck2

     

       281254
       +
            }:

     

       281255
       +
            mkDerivation {

     

       281256
       +
              pname = "unordered-containers";

     

       281257
       +
              version = "0.2.15.0";

     

       281258
       +
              sha256 = "0s6kmkz0p5iw5bkmbv4fhgd6cb7v8a75wkv7h5acxp52h3qfm4kc";

     

       281259
       +
              libraryHaskellDepends = [ base deepseq hashable ];

     

       281260
       +
              testHaskellDepends = [

     

       281261
       +
                base ChasingBottoms containers hashable HUnit QuickCheck random

     

       281262
       +
                test-framework test-framework-hunit test-framework-quickcheck2

     

       281263
       +
              ];

     

       281264
       +
              benchmarkHaskellDepends = [

     

       281265
       +
                base bytestring containers deepseq gauge hashable hashmap mtl

     

       281266
       +
                random

     

       281267
       +
              ];

     

       281268
       +
              description = "Efficient hashing-based container types";

     

       281269
       +
              license = lib.licenses.bsd3;

     

       281270
       +
              hydraPlatforms = lib.platforms.none;

     

       281271
        
            }) {};

     

       281272
        
       

     

       281273
        
         "unordered-containers-rematch" = callPackage

     
···

       284912
        
              license = lib.licenses.bsd3;

     

       284913
        
            }) {};

     

       284914
        
       

     

       284915
       +
         "vector-th-unbox_0_2_2" = callPackage

     

       284916
       +
           ({ mkDerivation, base, data-default, template-haskell, vector }:

     

       284917
       +
            mkDerivation {

     

       284918
       +
              pname = "vector-th-unbox";

     

       284919
       +
              version = "0.2.2";

     

       284920
       +
              sha256 = "0j81m09xxv24zziv0nanfppckzmas5184jr3npjhc9w49r3cm94a";

     

       284921
       +
              revision = "1";

     

       284922
       +
              editedCabalFile = "1kwjmjmp5pk9n9hps2y8kzjz4p42mcmzki8mypfhc0360n97r0wn";

     

       284923
       +
              libraryHaskellDepends = [ base template-haskell vector ];

     

       284924
       +
              testHaskellDepends = [ base data-default vector ];

     

       284925
       +
              description = "Deriver for Data.Vector.Unboxed using Template Haskell";

     

       284926
       +
              license = lib.licenses.bsd3;

     

       284927
       +
              hydraPlatforms = lib.platforms.none;

     

       284928
       +
            }) {};

     

       284929
       +
       

     

       284930
        
         "vectortiles" = callPackage

     

       284931
        
           ({ mkDerivation, base, bytestring, containers, criterion, deepseq

     

       284932
        
            , hashable, microlens, microlens-platform, mtl, protocol-buffers

     
···

       284980
        
            }:

     

       284981
        
            mkDerivation {

     

       284982
        
              pname = "venzone";

     

       284983
       +
              version = "1.1.0.0";

     

       284984
       +
              sha256 = "19ivc72skzl8h06h5bfl6lfnph3knd9zz7842rsarjknbmszrgqg";

     

       284985
        
              isLibrary = false;

     

       284986
        
              isExecutable = true;

     

       284987
        
              enableSeparateDataOutput = true;

     
···

       286385
        
            }:

     

       286386
        
            mkDerivation {

     

       286387
        
              pname = "vulkan";

     

       286388
       +
              version = "3.13.2";

     

       286389
       +
              sha256 = "1bbqz5xpd3jw71m70pdg6nifi63m0s42jvnldf55nj2ms0mzjmhr";

     

       286390
        
              libraryHaskellDepends = [ base bytestring transformers vector ];

     

       286391
        
              libraryPkgconfigDepends = [ vulkan ];

     

       286392
        
              testHaskellDepends = [

     
···

       289978
        
              description = "Binding to the Webkit library";

     

       289979
        
              license = lib.licenses.lgpl21Only;

     

       289980
        
              hydraPlatforms = lib.platforms.none;

     

       289981
       +
              broken = true;

     

       289982
        
            }) {inherit (pkgs) webkitgtk;};

     

       289983
        
       

     

       289984
        
         "webkitgtk3-javascriptcore" = callPackage

     
···

       291231
        
              pname = "witherable";

     

       291232
        
              version = "0.4.2";

     

       291233
        
              sha256 = "0121ic4xkv3k568j23zp22a5lrv0k11h94fq7cbijd18fjr2n3br";

     

       291234
       +
              revision = "1";

     

       291235
       +
              editedCabalFile = "1mwmnc4pdsw0v8p9bh8n49xjjmbyf5bd0kvlg970iyq3cqik546f";

     

       291236
        
              libraryHaskellDepends = [

     

       291237
        
                base base-orphans containers hashable indexed-traversable

     

       291238
        
                indexed-traversable-instances transformers unordered-containers

     
···

       294799
        
            }:

     

       294800
        
            mkDerivation {

     

       294801
        
              pname = "xmobar";

     

       294802
       +
         "interpolatedstring-qq" = callPackage

     

       294803
       +
              sha256 = "1mrdiblm8vilkm1w23pz6xbi16zh1b1lvql26czjzw5k79vd67sf";

     

       294804
        
              configureFlags = [

     

       294805
        
                "-fwith_alsa" "-fwith_conduit" "-fwith_datezone" "-fwith_dbus"

     

       294806
        
                "-fwith_inotify" "-fwith_iwlib" "-fwith_mpd" "-fwith_mpris"

+2 -2

pkgs/development/interpreters/erlang/R24.nix

···

       3
        
       # How to obtain `sha256`:

     

       4
        
       # nix-prefetch-url --unpack https://github.com/erlang/otp/archive/OTP-${version}.tar.gz

     

       5
        
       mkDerivation {

     

       6
       -
         version = "24.1.5";

     

       7
       -
         sha256 = "sha256-MSPoJpbL9WeERqCSh9fiw9jhJGssqolxudyURpiypb0=";

     

       8
        
       }

···

       3
        
       # How to obtain `sha256`:

     

       4
        
       # nix-prefetch-url --unpack https://github.com/erlang/otp/archive/OTP-${version}.tar.gz

     

       5
        
       mkDerivation {

     

       6
       +
         version = "24.1.6";

     

       7
       +
         sha256 = "sha256-Jh9w3+ft1RZjmb4PriCmHPj0tgkx8LBFjsg1s4BGojs=";

     

       8
        
       }

pkgs/development/libraries/libinput/default.nix

···

       3
        
       , documentationSupport ? false, doxygen, graphviz # Documentation

     

       4
        
       , eventGUISupport ? false, cairo, glib, gtk3 # GUI event viewer support

     

       5
        
       , testsSupport ? false, check, valgrind, python3

     

       0
        
       
     

       6
        
       }:

     

       7
        
       

     

       8
        
       let

     
···

       75
        
         '';

     

       76
        
       

     

       77
        
         doCheck = testsSupport && stdenv.hostPlatform == stdenv.buildPlatform;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       78
        
       

     

       79
        
         meta = with lib; {

     

       80
        
           description = "Handles input devices in Wayland compositors and provides a generic X.Org input driver";

···

       3
        
       , documentationSupport ? false, doxygen, graphviz # Documentation

     

       4
        
       , eventGUISupport ? false, cairo, glib, gtk3 # GUI event viewer support

     

       5
        
       , testsSupport ? false, check, valgrind, python3

     

       6
       +
       , nixosTests

     

       7
        
       }:

     

       8
        
       

     

       9
        
       let

     
···

       76
        
         '';

     

       77
        
       

     

       78
        
         doCheck = testsSupport && stdenv.hostPlatform == stdenv.buildPlatform;

     

       79
       +
       

     

       80
       +
         passthru.tests = {

     

       81
       +
           libinput-module = nixosTests.libinput;

     

       82
       +
         };

     

       83
        
       

     

       84
        
         meta = with lib; {

     

       85
        
           description = "Handles input devices in Wayland compositors and provides a generic X.Org input driver";

+5 -6

pkgs/development/libraries/liburing/default.nix

···

       33
        
       

     

       34
        
         outputs = [ "out" "bin" "dev" "man" ];

     

       35
        
       

     

       36
       -
         postInstall =

     

       37
       -
         # Copy the examples into $bin. Most reverse dependency of this package should

     

       38
       -
         # reference only the $out output

     

       39
       -
         ''

     

       40
        
           mkdir -p $bin/bin

     

       41
        
           cp ./examples/io_uring-cp examples/io_uring-test $bin/bin

     

       42
        
           cp ./examples/link-cp $bin/bin/io_uring-link-cp

     

       0
        
       
     

       43
        
           cp ./examples/ucontext-cp $bin/bin/io_uring-ucontext-cp

     

       44
       -
         ''

     

       45
       -
         ;

     

       46
        
       

     

       47
        
         meta = with lib; {

     

       48
        
           description = "Userspace library for the Linux io_uring API";

···

       33
        
       

     

       34
        
         outputs = [ "out" "bin" "dev" "man" ];

     

       35
        
       

     

       36
       +
         postInstall = ''

     

       37
       +
           # Copy the examples into $bin. Most reverse dependency of this package should

     

       38
       +
           # reference only the $out output

     

       0
        
       
     

       39
        
           mkdir -p $bin/bin

     

       40
        
           cp ./examples/io_uring-cp examples/io_uring-test $bin/bin

     

       41
        
           cp ./examples/link-cp $bin/bin/io_uring-link-cp

     

       42
       +
         '' + lib.optionalString stdenv.hostPlatform.isGnu ''

     

       43
        
           cp ./examples/ucontext-cp $bin/bin/io_uring-ucontext-cp

     

       44
       +
         '';

     

       0
        
       
     

       45
        
       

     

       46
        
         meta = with lib; {

     

       47
        
           description = "Userspace library for the Linux io_uring API";

-28

pkgs/development/libraries/mumlib/default.nix

···

       1
       -
       { stdenv, lib, fetchFromGitHub, cmake, pkg-config

     

       2
       -
       , boost, openssl, log4cpp, libopus, protobuf }:

     

       3
       -
       with lib; stdenv.mkDerivation {

     

       4
       -
         pname = "mumlib";

     

       5
       -
         version = "unstable-2018-12-12";

     

       6
       -
       

     

       7
       -
         src = fetchFromGitHub {

     

       8
       -
           owner = "slomkowski";

     

       9
       -
           repo = "mumlib";

     

       10
       -
           rev = "f91720de264c0ab5e02bb30deafc5c4b2c245eac";

     

       11
       -
           sha256 = "0p29z8379dp2ra0420x8xjp4d3r2mf680lj38xmlc8npdzqjqjdp";

     

       12
       -
         };

     

       13
       -
       

     

       14
       -
         buildInputs = [ boost openssl libopus protobuf log4cpp ];

     

       15
       -
         nativeBuildInputs = [ cmake pkg-config ];

     

       16
       -
         installPhase = ''

     

       17
       -
           install -Dm555 libmumlib.so $out/lib/libmumlib.so

     

       18
       -
           cp -a ../include $out

     

       19
       -
         '';

     

       20
       -
       

     

       21
       -
         meta = {

     

       22
       -
           description = "Fairy simple Mumble library written in C++, using boost::asio asynchronous networking framework";

     

       23
       -
           homepage = "https://github.com/slomkowski/mumlib";

     

       24
       -
           maintainers = with maintainers; [ das_j ];

     

       25
       -
           license = licenses.gpl2;

     

       26
       -
           platforms = platforms.linux;

     

       27
       -
         };

     

       28
       -
       }

+2 -2

pkgs/development/libraries/science/math/scs/default.nix

···

       4
        
       

     

       5
        
       stdenv.mkDerivation rec {

     

       6
        
         pname = "scs";

     

       7
       -
         version = "2.1.1";

     

       8
        
       

     

       9
        
         src = fetchFromGitHub {

     

       10
        
           owner = "cvxgrp";

     

       11
        
           repo = "scs";

     

       12
        
           rev = version;

     

       13
       -
           sha256 = "14g5m3lcvrbwpq1bq0liq00jh0gm1947lg3z4jfsp43f6p5alb20";

     

       14
        
         };

     

       15
        
       

     

       16
        
         # Actually link and add libgfortran to the rpath

···

       4
        
       

     

       5
        
       stdenv.mkDerivation rec {

     

       6
        
         pname = "scs";

     

       7
       +
         version = "3.0.0";

     

       8
        
       

     

       9
        
         src = fetchFromGitHub {

     

       10
        
           owner = "cvxgrp";

     

       11
        
           repo = "scs";

     

       12
        
           rev = version;

     

       13
       +
           sha256 = "sha256-Lly28KDDZ5hJyiMOhiX/3VaKs0iPcSqizOurZevhfCo=";

     

       14
        
         };

     

       15
        
       

     

       16
        
         # Actually link and add libgfortran to the rpath

+2 -2

pkgs/development/libraries/sope/default.nix

···

       4
        
       

     

       5
        
       gnustep.stdenv.mkDerivation rec {

     

       6
        
         pname = "sope";

     

       7
       -
         version = "5.2.0";

     

       8
        
       

     

       9
        
         src = fetchFromGitHub {

     

       10
        
           owner = "inverse-inc";

     

       11
        
           repo = pname;

     

       12
        
           rev = "SOPE-${version}";

     

       13
       -
           sha256 = "14s9rcnglkwl0nmbmpdxxbiqqnr3m8n7x69idm1crgbbjkj4gi68";

     

       14
        
         };

     

       15
        
       

     

       16
        
         hardeningDisable = [ "format" ];

···

       4
        
       

     

       5
        
       gnustep.stdenv.mkDerivation rec {

     

       6
        
         pname = "sope";

     

       7
       +
         version = "5.3.0";

     

       8
        
       

     

       9
        
         src = fetchFromGitHub {

     

       10
        
           owner = "inverse-inc";

     

       11
        
           repo = pname;

     

       12
        
           rev = "SOPE-${version}";

     

       13
       +
           sha256 = "0xqa7fsf60acbri5dd9x8nmf1zdkalxnmkm559w4xz7sdi569ssa";

     

       14
        
         };

     

       15
        
       

     

       16
        
         hardeningDisable = [ "format" ];

+2 -3

pkgs/development/libraries/sqlite/default.nix

···

       1
       -
       { lib, stdenv, fetchurl, zlib, interactive ? false, readline ? null, ncurses ? null

     

       2
        
       , python3Packages

     

       3
        
       , enableDeserialize ? false

     

       4
        
       }:

     

       5
       -
       

     

       6
       -
       assert interactive -> readline != null && ncurses != null;

     

       7
        
       

     

       8
        
       with lib;

     

       9
        
       

     
···

       93
        
           downloadPage = "https://sqlite.org/download.html";

     

       94
        
           homepage = "https://www.sqlite.org/";

     

       95
        
           license = licenses.publicDomain;

     

       0
        
       
     

       96
        
           maintainers = with maintainers; [ eelco np ];

     

       97
        
           platforms = platforms.unix ++ platforms.windows;

     

       98
        
         };

···

       1
       +
       { lib, stdenv, fetchurl, zlib, interactive ? false, readline, ncurses

     

       2
        
       , python3Packages

     

       3
        
       , enableDeserialize ? false

     

       4
        
       }:

     

       0
        
       
     

       0
        
       
     

       5
        
       

     

       6
        
       with lib;

     

       7
        
       

     
···

       91
        
           downloadPage = "https://sqlite.org/download.html";

     

       92
        
           homepage = "https://www.sqlite.org/";

     

       93
        
           license = licenses.publicDomain;

     

       94
       +
           mainProgram = "sqlite3";

     

       95
        
           maintainers = with maintainers; [ eelco np ];

     

       96
        
           platforms = platforms.unix ++ platforms.windows;

     

       97
        
         };

+2 -1

pkgs/development/mobile/androidenv/emulator.nix

···

       3
        
       deployAndroidPackage {

     

       4
        
         inherit package os;

     

       5
        
         buildInputs = [ autoPatchelfHook makeWrapper ]

     

       6
       -
         ++ lib.optional (os == "linux") [

     

       7
        
           pkgs.glibc

     

       8
        
           pkgs.xorg.libX11

     

       9
        
           pkgs.xorg.libXext

     
···

       18
        
           pkgs.libcxx

     

       19
        
           pkgs.libGL

     

       20
        
           pkgs.libpulseaudio

     

       0
        
       
     

       21
        
           pkgs.zlib

     

       22
        
           pkgs.ncurses5

     

       23
        
           pkgs.stdenv.cc.cc

···

       3
        
       deployAndroidPackage {

     

       4
        
         inherit package os;

     

       5
        
         buildInputs = [ autoPatchelfHook makeWrapper ]

     

       6
       +
         ++ lib.optionals (os == "linux") [

     

       7
        
           pkgs.glibc

     

       8
        
           pkgs.xorg.libX11

     

       9
        
           pkgs.xorg.libXext

     
···

       18
        
           pkgs.libcxx

     

       19
        
           pkgs.libGL

     

       20
        
           pkgs.libpulseaudio

     

       21
       +
           pkgs.libuuid

     

       22
        
           pkgs.zlib

     

       23
        
           pkgs.ncurses5

     

       24
        
           pkgs.stdenv.cc.cc

+5 -4

pkgs/development/python-modules/casbin/default.nix

···

       2
        
       , buildPythonPackage

     

       3
        
       , fetchFromGitHub

     

       4
        
       , simpleeval

     

       5
       -
       , isPy27

     

       6
        
       , coveralls

     

       7
        
       , wcmatch

     

       8
        
       }:

     

       9
        
       

     

       10
        
       buildPythonPackage rec {

     

       11
        
         pname = "casbin";

     

       12
       -
         version = "1.9.6";

     

       0
        
       
     

       13
        
       

     

       14
       -
         disabled = isPy27;

     

       15
        
       

     

       16
        
         src = fetchFromGitHub {

     

       17
        
           owner = pname;

     

       18
        
           repo = "pycasbin";

     

       19
        
           rev = "v${version}";

     

       20
       -
           sha256 = "0r3pmkcgmsk3z6iy714fpg05mrs4ckb7ldyjsws6hwidcijha8rk";

     

       21
        
         };

     

       22
        
       

     

       23
        
         propagatedBuildInputs = [

···

       2
        
       , buildPythonPackage

     

       3
        
       , fetchFromGitHub

     

       4
        
       , simpleeval

     

       5
       +
       , pythonOlder

     

       6
        
       , coveralls

     

       7
        
       , wcmatch

     

       8
        
       }:

     

       9
        
       

     

       10
        
       buildPythonPackage rec {

     

       11
        
         pname = "casbin";

     

       12
       +
         version = "1.9.7";

     

       13
       +
         format = "setuptools";

     

       14
        
       

     

       15
       +
         disabled = pythonOlder "3.6";

     

       16
        
       

     

       17
        
         src = fetchFromGitHub {

     

       18
        
           owner = pname;

     

       19
        
           repo = "pycasbin";

     

       20
        
           rev = "v${version}";

     

       21
       +
           sha256 = "sha256-wNygKs37PtMLij3f+pAh6PNLqQ45cvrpF43Aj+cO8p8=";

     

       22
        
         };

     

       23
        
       

     

       24
        
         propagatedBuildInputs = [

+2 -2

pkgs/development/python-modules/cvxpy/default.nix

···

       16
        
       

     

       17
        
       buildPythonPackage rec {

     

       18
        
         pname = "cvxpy";

     

       19
       -
         version = "1.1.13";

     

       20
        
         format = "pyproject";

     

       21
        
       

     

       22
        
         disabled = pythonOlder "3.5";

     

       23
        
       

     

       24
        
         src = fetchPypi {

     

       25
        
           inherit pname version;

     

       26
       -
           sha256 = "012avhf0a8n9xyy4g3xcr5z8z2a3m6rnqic6gfs9fq6p9bkq3ix9";

     

       27
        
         };

     

       28
        
       

     

       29
        
         propagatedBuildInputs = [

···

       16
        
       

     

       17
        
       buildPythonPackage rec {

     

       18
        
         pname = "cvxpy";

     

       19
       +
         version = "1.1.17";

     

       20
        
         format = "pyproject";

     

       21
        
       

     

       22
        
         disabled = pythonOlder "3.5";

     

       23
        
       

     

       24
        
         src = fetchPypi {

     

       25
        
           inherit pname version;

     

       26
       +
           sha256 = "sha256-M5fTuJ13Dqnw/DWbHJs6/t5qDTvqHP8g4mU7E0Uc24o=";

     

       27
        
         };

     

       28
        
       

     

       29
        
         propagatedBuildInputs = [

+2 -2

pkgs/development/python-modules/identify/default.nix

···

       8
        
       

     

       9
        
       buildPythonPackage rec {

     

       10
        
         pname = "identify";

     

       11
       -
         version = "2.3.6";

     

       12
        
         format = "setuptools";

     

       13
        
       

     

       14
        
         disabled = pythonOlder "3.7";

     
···

       17
        
           owner = "pre-commit";

     

       18
        
           repo = pname;

     

       19
        
           rev = "v${version}";

     

       20
       -
           sha256 = "sha256-1+ILyqb0Ve+YmP9K+tin4iYIWUoRpi/+fbuyUFZOzBE=";

     

       21
        
         };

     

       22
        
       

     

       23
        
         checkInputs = [

···

       8
        
       

     

       9
        
       buildPythonPackage rec {

     

       10
        
         pname = "identify";

     

       11
       +
         version = "2.3.7";

     

       12
        
         format = "setuptools";

     

       13
        
       

     

       14
        
         disabled = pythonOlder "3.7";

     
···

       17
        
           owner = "pre-commit";

     

       18
        
           repo = pname;

     

       19
        
           rev = "v${version}";

     

       20
       +
           sha256 = "sha256-L71Zi0SWFh7K4BRwF57prdrIdxLp8Igs0k/gc6k1+Mo=";

     

       21
        
         };

     

       22
        
       

     

       23
        
         checkInputs = [

+43

pkgs/development/python-modules/niko-home-control/default.nix

···

       1
       +
       { lib

     

       2
       +
       , buildPythonPackage

     

       3
       +
       , fetchFromGitHub

     

       4
       +
       , nclib

     

       5
       +
       , netaddr

     

       6
       +
       , netifaces

     

       7
       +
       , pythonOlder

     

       8
       +
       }:

     

       9
       +
       

     

       10
       +
       buildPythonPackage rec {

     

       11
       +
         pname = "niko-home-control";

     

       12
       +
         version = "0.2.2";

     

       13
       +
         format = "setuptools";

     

       14
       +
       

     

       15
       +
         disabled = pythonOlder "3.8";

     

       16
       +
       

     

       17
       +
         src = fetchFromGitHub {

     

       18
       +
           owner = "NoUseFreak";

     

       19
       +
           repo = pname;

     

       20
       +
           rev = version;

     

       21
       +
           sha256 = "0ah02dfnnbk98grvd180fp9rak5gpi58xiql1yyzig5pcbjidvk3";

     

       22
       +
         };

     

       23
       +
       

     

       24
       +
         propagatedBuildInputs = [

     

       25
       +
           nclib

     

       26
       +
           netaddr

     

       27
       +
           netifaces

     

       28
       +
         ];

     

       29
       +
       

     

       30
       +
         # Project has no tests

     

       31
       +
         doCheck = false;

     

       32
       +
       

     

       33
       +
         pythonImportsCheck = [

     

       34
       +
           "nikohomecontrol"

     

       35
       +
         ];

     

       36
       +
       

     

       37
       +
         meta = with lib; {

     

       38
       +
           description = "Python SDK for Niko Home Control";

     

       39
       +
           homepage = "https://github.com/NoUseFreak/niko-home-control";

     

       40
       +
           license = with licenses; [ mit ];

     

       41
       +
           maintainers = with maintainers; [ fab ];

     

       42
       +
         };

     

       43
       +
       }

+18 -26

pkgs/development/python-modules/pydyf/default.nix

···

       1
       -
       { lib,

     

       2
       -
         buildPythonPackage,

     

       3
       -
         fetchPypi,

     

       4
       -
         isPy3k,

     

       5
       -
         pytestCheckHook,

     

       6
       -
         coverage,

     

       7
       -
         ghostscript,

     

       8
       -
         pillow,

     

       9
       -
         pytest,

     

       10
       -
         pytest-cov,

     

       11
       -
         pytest-flake8,

     

       12
       -
         pytest-isort

     

       13
        
       }:

     

       14
        
       

     

       15
        
       buildPythonPackage rec {

     
···

       17
        
         version = "0.1.2";

     

       18
        
         disabled = !isPy3k;

     

       19
        
       

     

       20
       -
         pytestFlagsArray = [

     

       21
       -
           # setup.py is auto-generated and doesn't pass the flake8 check

     

       22
       -
           "--ignore=setup.py"

     

       23
       -
         ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
       

     

       25
        
         checkInputs = [

     

       26
        
           pytestCheckHook

     

       27
        
           coverage

     

       28
        
           ghostscript

     

       29
        
           pillow

     

       30
       -
           pytest

     

       31
       -
           pytest-cov

     

       32
       -
           pytest-flake8

     

       33
       -
           pytest-isort

     

       34
        
         ];

     

       35
       -
       

     

       36
       -
         src = fetchPypi {

     

       37
       -
           inherit version;

     

       38
       -
           pname = "pydyf";

     

       39
       -
           sha256 = "sha256-Hi9d5IF09QXeAlp9HnzwG73ZQiyoq5RReCvwDuF4YCw=";

     

       40
       -
         };

     

       41
        
       

     

       42
        
         meta = with lib; {

     

       43
        
           homepage = "https://doc.courtbouillon.org/pydyf/stable/";

···

       1
       +
       { lib

     

       2
       +
       , buildPythonPackage

     

       3
       +
       , fetchPypi

     

       4
       +
       , isPy3k

     

       5
       +
       , pytestCheckHook

     

       6
       +
       , coverage

     

       7
       +
       , ghostscript

     

       8
       +
       , pillow

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       9
        
       }:

     

       10
        
       

     

       11
        
       buildPythonPackage rec {

     
···

       13
        
         version = "0.1.2";

     

       14
        
         disabled = !isPy3k;

     

       15
        
       

     

       16
       +
         src = fetchPypi {

     

       17
       +
           inherit version;

     

       18
       +
           pname = "pydyf";

     

       19
       +
           sha256 = "sha256-Hi9d5IF09QXeAlp9HnzwG73ZQiyoq5RReCvwDuF4YCw=";

     

       20
       +
         };

     

       21
       +
       

     

       22
       +
         postPatch = ''

     

       23
       +
           substituteInPlace pyproject.toml \

     

       24
       +
             --replace "--isort --flake8 --cov --no-cov-on-fail" ""

     

       25
       +
         '';

     

       26
        
       

     

       27
        
         checkInputs = [

     

       28
        
           pytestCheckHook

     

       29
        
           coverage

     

       30
        
           ghostscript

     

       31
        
           pillow

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
         ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       33
        
       

     

       34
        
         meta = with lib; {

     

       35
        
           homepage = "https://doc.courtbouillon.org/pydyf/stable/";

+42

pkgs/development/python-modules/pyevilgenius/default.nix

···

       1
       +
       { lib

     

       2
       +
       , aiohttp

     

       3
       +
       , buildPythonPackage

     

       4
       +
       , fetchFromGitHub

     

       5
       +
       , async-timeout

     

       6
       +
       , pythonOlder

     

       7
       +
       }:

     

       8
       +
       

     

       9
       +
       buildPythonPackage rec {

     

       10
       +
         pname = "pyevilgenius";

     

       11
       +
         version = "1.0.0";

     

       12
       +
         format = "setuptools";

     

       13
       +
       

     

       14
       +
         disabled = pythonOlder "3.8";

     

       15
       +
       

     

       16
       +
         src = fetchFromGitHub {

     

       17
       +
           owner = "home-assistant-libs";

     

       18
       +
           repo = pname;

     

       19
       +
           rev = version;

     

       20
       +
           sha256 = "06xnl93sqklg7gx0z50vm79xwww0yyw05c1yynajc9aijfi8cmi3";

     

       21
       +
         };

     

       22
       +
       

     

       23
       +
         propagatedBuildInputs = [

     

       24
       +
           aiohttp

     

       25
       +
           async-timeout

     

       26
       +
         ];

     

       27
       +
       

     

       28
       +
         # Project has no test

     

       29
       +
         doCheck = false;

     

       30
       +
       

     

       31
       +
         pythonImportsCheck = [

     

       32
       +
           "pyevilgenius"

     

       33
       +
         ];

     

       34
       +
       

     

       35
       +
         meta = with lib; {

     

       36
       +
           description = "Python SDK to interact with Evil Genius Labs devices";

     

       37
       +
           homepage = "https://github.com/home-assistant-libs/pyevilgenius";

     

       38
       +
           changelog = "https://github.com/home-assistant-libs/pyevilgenius/releases/tag/${version}";

     

       39
       +
           license = with licenses; [ asl20 ];

     

       40
       +
           maintainers = with maintainers; [ fab ];

     

       41
       +
         };

     

       42
       +
       }

+9 -3

pkgs/development/python-modules/pysmartapp/default.nix

···

       4
        
       , httpsig

     

       5
        
       , pytest-asyncio

     

       6
        
       , pytestCheckHook

     

       0
        
       
     

       7
        
       }:

     

       8
        
       

     

       9
        
       buildPythonPackage rec {

     

       10
        
         pname = "pysmartapp";

     

       11
       -
         version = "0.3.3";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
       

     

       13
        
         src = fetchFromGitHub {

     

       14
        
           owner = "andrewsayre";

     

       15
        
           repo = pname;

     

       16
        
           rev = version;

     

       17
       -
           sha256 = "03wk44siqxl15pa46x5vkg4q0mnga34ir7qn897576z2ivbx7awh";

     

       18
        
         };

     

       19
        
       

     

       20
        
         propagatedBuildInputs = [

     
···

       26
        
           pytestCheckHook

     

       27
        
         ];

     

       28
        
       

     

       29
       -
         pythonImportsCheck = [ "pysmartapp" ];

     

       0
        
       
     

       0
        
       
     

       30
        
       

     

       31
        
         meta = with lib; {

     

       32
        
           description = "Python implementation to work with SmartApp lifecycle events";

···

       4
        
       , httpsig

     

       5
        
       , pytest-asyncio

     

       6
        
       , pytestCheckHook

     

       7
       +
       , pythonOlder

     

       8
        
       }:

     

       9
        
       

     

       10
        
       buildPythonPackage rec {

     

       11
        
         pname = "pysmartapp";

     

       12
       +
         version = "0.3.4";

     

       13
       +
         format = "setuptools";

     

       14
       +
       

     

       15
       +
         disabled = pythonOlder "3.8";

     

       16
        
       

     

       17
        
         src = fetchFromGitHub {

     

       18
        
           owner = "andrewsayre";

     

       19
        
           repo = pname;

     

       20
        
           rev = version;

     

       21
       +
           sha256 = "sha256-zYjv7wRxQTS4PnNaY69bw9xE6I4DZMocwUzEICBfwqM=";

     

       22
        
         };

     

       23
        
       

     

       24
        
         propagatedBuildInputs = [

     
···

       30
        
           pytestCheckHook

     

       31
        
         ];

     

       32
        
       

     

       33
       +
         pythonImportsCheck = [

     

       34
       +
           "pysmartapp"

     

       35
       +
         ];

     

       36
        
       

     

       37
        
         meta = with lib; {

     

       38
        
           description = "Python implementation to work with SmartApp lifecycle events";

+2 -2

pkgs/development/python-modules/qcs-api-client/default.nix

···

       18
        
       

     

       19
        
       buildPythonPackage rec {

     

       20
        
         pname = "qcs-api-client";

     

       21
       -
         version = "0.16.0";

     

       22
        
         format = "setuptools";

     

       23
        
       

     

       24
        
         disabled = pythonOlder "3.7";

     

       25
        
       

     

       26
        
         src = fetchPypi {

     

       27
        
           inherit pname version;

     

       28
       -
           sha256 = "4ac6cf55e414494095ac1e1258f5700fed8eefa37d3b8da80264bd674cbfac43";

     

       29
        
         };

     

       30
        
       

     

       31
        
         propagatedBuildInputs = [

···

       18
        
       

     

       19
        
       buildPythonPackage rec {

     

       20
        
         pname = "qcs-api-client";

     

       21
       +
         version = "0.18.0";

     

       22
        
         format = "setuptools";

     

       23
        
       

     

       24
        
         disabled = pythonOlder "3.7";

     

       25
        
       

     

       26
        
         src = fetchPypi {

     

       27
        
           inherit pname version;

     

       28
       +
           sha256 = "sha256-7qrE+XqXOCmfauD772epIbZ1Lzv+5pXrA7tgD8qCVSE=";

     

       29
        
         };

     

       30
        
       

     

       31
        
         propagatedBuildInputs = [

+1 -1

pkgs/development/python-modules/qiskit-aer/default.nix

···

       88
        
         ];

     

       89
        
         # Slow tests

     

       90
        
         disabledTests = [

     

       0
        
       
     

       91
        
           "test_snapshot" # TODO: these ~30 tests fail on setup due to pytest fixture issues?

     

       92
        
           "test_initialize_2" # TODO: simulations appear incorrect, off by >10%.

     

       93
        
       

     
···

       111
        
           "_144"

     

       112
        
           "test_sparse_output_probabilities"

     

       113
        
           "test_reset_2_qubit"

     

       114
       -
           # "test_clifford"

     

       115
        
         ];

     

       116
        
         checkInputs = [

     

       117
        
           pytestCheckHook

···

       88
        
         ];

     

       89
        
         # Slow tests

     

       90
        
         disabledTests = [

     

       91
       +
           "test_clifford" # fails on cvxpy >= 1.1.15. https://github.com/Qiskit/qiskit-aer/pull/1318. Remove in future.

     

       92
        
           "test_snapshot" # TODO: these ~30 tests fail on setup due to pytest fixture issues?

     

       93
        
           "test_initialize_2" # TODO: simulations appear incorrect, off by >10%.

     

       94
        
       

     
···

       112
        
           "_144"

     

       113
        
           "test_sparse_output_probabilities"

     

       114
        
           "test_reset_2_qubit"

     

       0
        
       
     

       115
        
         ];

     

       116
        
         checkInputs = [

     

       117
        
           pytestCheckHook

pkgs/development/python-modules/rtoml/default.nix

···

       5
        
       , setuptools-rust

     

       6
        
       , rustPlatform

     

       7
        
       , pytestCheckHook

     

       0
        
       
     

       8
        
       }:

     

       9
        
       

     

       10
        
       buildPythonPackage rec {

     
···

       31
        
           rust.cargo

     

       32
        
           cargoSetupHook

     

       33
        
         ];

     

       0
        
       
     

       0
        
       
     

       34
        
       

     

       35
        
         pythonImportsCheck = [ "rtoml" ];

     

       36

···

       5
        
       , setuptools-rust

     

       6
        
       , rustPlatform

     

       7
        
       , pytestCheckHook

     

       8
       +
       , libiconv

     

       9
        
       }:

     

       10
        
       

     

       11
        
       buildPythonPackage rec {

     
···

       32
        
           rust.cargo

     

       33
        
           cargoSetupHook

     

       34
        
         ];

     

       35
       +
       

     

       36
       +
         buildInputs = [ libiconv ];

     

       37
        
       

     

       38
        
         pythonImportsCheck = [ "rtoml" ];

     

       39

+8 -15

pkgs/development/python-modules/scs/default.nix

···

       5
        
       , lapack

     

       6
        
       , numpy

     

       7
        
       , scipy

     

       8
       -
       , scs

     

       9
        
         # check inputs

     

       10
       -
       , nose

     

       11
        
       }:

     

       12
        
       

     

       13
        
       buildPythonPackage rec {

     

       14
       -
         inherit (scs) pname version;

     

       0
        
       
     

       15
        
       

     

       16
        
         src = fetchFromGitHub {

     

       17
        
           owner = "bodono";

     

       18
        
           repo = "scs-python";

     

       19
       -
           rev = "f02abdc0e2e0a5851464e30f6766ccdbb19d73f0"; # need to choose commit manually, untagged

     

       20
       -
           sha256 = "174b5s7cwgrn1m55jlrszdl403zhpzc4yl9acs6kjv9slmg1mmjr";

     

       0
        
       
     

       21
        
         };

     

       22
        
       

     

       23
       -
         preConfigure = ''

     

       24
       -
           rm -r scs

     

       25
       -
           ln -s ${scs.src} scs

     

       26
       -
         '';

     

       27
       -
       

     

       28
        
         buildInputs = [

     

       29
        
           lapack

     

       30
        
           blas

     
···

       35
        
           scipy

     

       36
        
         ];

     

       37
        
       

     

       38
       -
         checkInputs = [ nose ];

     

       39
       -
         checkPhase = ''

     

       40
       -
           nosetests

     

       41
       -
         '';

     

       42
        
         pythonImportsCheck = [ "scs" ];

     

       43
        
       

     

       44
        
         meta = with lib; {

     
···

       50
        
           '';

     

       51
        
           homepage = "https://github.com/cvxgrp/scs"; # upstream C package

     

       52
        
           downloadPage = "https://github.com/bodono/scs-python";

     

       53
       -
           license = licenses.gpl3;

     

       54
        
           maintainers = with maintainers; [ drewrisinger ];

     

       55
        
         };

     

       56
        
       }

···

       5
        
       , lapack

     

       6
        
       , numpy

     

       7
        
       , scipy

     

       0
        
       
     

       8
        
         # check inputs

     

       9
       +
       , pytestCheckHook

     

       10
        
       }:

     

       11
        
       

     

       12
        
       buildPythonPackage rec {

     

       13
       +
         pname = "scs";

     

       14
       +
         version = "3.0.0";

     

       15
        
       

     

       16
        
         src = fetchFromGitHub {

     

       17
        
           owner = "bodono";

     

       18
        
           repo = "scs-python";

     

       19
       +
           rev = version;

     

       20
       +
           sha256 = "sha256-7OgqCo21S0FDev8xv6/8iGFXg8naVi93zd8v1f9iaWw=";

     

       21
       +
           fetchSubmodules = true;

     

       22
        
         };

     

       23
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
         buildInputs = [

     

       25
        
           lapack

     

       26
        
           blas

     
···

       31
        
           scipy

     

       32
        
         ];

     

       33
        
       

     

       34
       +
         checkInputs = [ pytestCheckHook ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35
        
         pythonImportsCheck = [ "scs" ];

     

       36
        
       

     

       37
        
         meta = with lib; {

     
···

       43
        
           '';

     

       44
        
           homepage = "https://github.com/cvxgrp/scs"; # upstream C package

     

       45
        
           downloadPage = "https://github.com/bodono/scs-python";

     

       46
       +
           license = licenses.mit;

     

       47
        
           maintainers = with maintainers; [ drewrisinger ];

     

       48
        
         };

     

       49
        
       }

+40

pkgs/development/python-modules/uptime-kuma-monitor/default.nix

···

       1
       +
       { lib

     

       2
       +
       , requests

     

       3
       +
       , buildPythonPackage

     

       4
       +
       , fetchPypi

     

       5
       +
       , prometheus-client

     

       6
       +
       , pythonOlder

     

       7
       +
       }:

     

       8
       +
       

     

       9
       +
       buildPythonPackage rec {

     

       10
       +
         pname = "uptime-kuma-monitor";

     

       11
       +
         version = "1.0.0";

     

       12
       +
         format = "setuptools";

     

       13
       +
       

     

       14
       +
         disabled = pythonOlder "3.8";

     

       15
       +
       

     

       16
       +
         src = fetchPypi {

     

       17
       +
           pname = "uptime_kuma_monitor";

     

       18
       +
           inherit version;

     

       19
       +
           sha256 = "0zi4856hj5ar4yidh7366kx3xnh8qzydw9z8vlalcn98jf3jlnk9";

     

       20
       +
         };

     

       21
       +
       

     

       22
       +
         propagatedBuildInputs = [

     

       23
       +
           requests

     

       24
       +
           prometheus-client

     

       25
       +
         ];

     

       26
       +
       

     

       27
       +
         # Project has no test

     

       28
       +
         doCheck = false;

     

       29
       +
       

     

       30
       +
         pythonImportsCheck = [

     

       31
       +
           "uptime_kuma_monitor"

     

       32
       +
         ];

     

       33
       +
       

     

       34
       +
         meta = with lib; {

     

       35
       +
           description = "Python wrapper around UptimeKuma /metrics endpoint";

     

       36
       +
           homepage = "https://github.com/meichthys/utptime_kuma_monitor";

     

       37
       +
           license = with licenses; [ mit ];

     

       38
       +
           maintainers = with maintainers; [ fab ];

     

       39
       +
         };

     

       40
       +
       }

+35 -46

pkgs/development/python-modules/weasyprint/default.nix

···

       1
       -
       { buildPythonPackage,

     

       2
       -
         fetchPypi,

     

       3
       -
         fetchpatch,

     

       4
       -
         pytestCheckHook,

     

       5
       -
         brotli,

     

       6
       -
         cairosvg,

     

       7
       -
         fonttools,

     

       8
       -
         pydyf,

     

       9
       -
         pyphen,

     

       10
       -
         cffi,

     

       11
       -
         cssselect,

     

       12
       -
         lxml,

     

       13
       -
         html5lib,

     

       14
       -
         tinycss,

     

       15
       -
         zopfli,

     

       16
       -
         glib,

     

       17
       -
         harfbuzz,

     

       18
       -
         pango,

     

       19
       -
         fontconfig,

     

       20
       -
         lib, stdenv,

     

       21
       -
         ghostscript,

     

       22
       -
         pytest,

     

       23
       -
         pytest-runner,

     

       24
       -
         pytest-isort,

     

       25
       -
         pytest-flake8,

     

       26
       -
         pytest-cov,

     

       27
       -
         isPy3k,

     

       28
       -
         substituteAll

     

       29
        
       }:

     

       30
        
       

     

       31
        
       buildPythonPackage rec {

     
···

       33
        
         version = "53.4";

     

       34
        
         disabled = !isPy3k;

     

       35
        
       

     

       36
       -
         pytestFlagsArray = [

     

       37
       -
           # setup.py is auto-generated and doesn't pass the flake8 check

     

       38
       -
           "--ignore=setup.py"

     

       39
       -
           # ffi.py is patched by us and doesn't pass the flake8 check

     

       40
       -
           "--ignore=weasyprint/text/ffi.py"

     

       41
       -
         ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       42
        
       

     

       43
        
         disabledTests = [

     

       44
       -
           # test_font_stretch needs the Ahem font (fails on macOS)

     

       45
        
           "test_font_stretch"

     

       46
        
         ];

     

       47
        
       

     

       48
        
         checkInputs = [

     

       49
        
           pytestCheckHook

     

       50
        
           ghostscript

     

       51
       -
           pytest

     

       52
       -
           pytest-runner

     

       53
       -
           pytest-isort

     

       54
       -
           pytest-flake8

     

       55
       -
           pytest-cov

     

       56
        
         ];

     

       57
        
       

     

       58
        
         FONTCONFIG_FILE = "${fontconfig.out}/etc/fonts/fonts.conf";

     
···

       82
        
             harfbuzz = "${harfbuzz.out}/lib/libharfbuzz${stdenv.hostPlatform.extensions.sharedLibrary}";

     

       83
        
           })

     

       84
        
         ];

     

       85
       -
       

     

       86
       -
         src = fetchPypi {

     

       87
       -
           inherit version;

     

       88
       -
           pname = "weasyprint";

     

       89
       -
           sha256 = "sha256-EMyxfVXHMJa98e3T7+WMuFWwfkwwfZutTryaPxP/RYA=";

     

       90
       -
         };

     

       91
        
       

     

       92
        
         meta = with lib; {

     

       93
        
           homepage = "https://weasyprint.org/";

···

       1
       +
       { buildPythonPackage

     

       2
       +
       , fetchPypi

     

       3
       +
       , fetchpatch

     

       4
       +
       , pytestCheckHook

     

       5
       +
       , brotli

     

       6
       +
       , cairosvg

     

       7
       +
       , fonttools

     

       8
       +
       , pydyf

     

       9
       +
       , pyphen

     

       10
       +
       , cffi

     

       11
       +
       , cssselect

     

       12
       +
       , lxml

     

       13
       +
       , html5lib

     

       14
       +
       , tinycss

     

       15
       +
       , zopfli

     

       16
       +
       , glib

     

       17
       +
       , harfbuzz

     

       18
       +
       , pango

     

       19
       +
       , fontconfig

     

       20
       +
       , lib

     

       21
       +
       , stdenv

     

       22
       +
       , ghostscript

     

       23
       +
       , isPy3k

     

       24
       +
       , substituteAll

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
       }:

     

       26
        
       

     

       27
        
       buildPythonPackage rec {

     
···

       29
        
         version = "53.4";

     

       30
        
         disabled = !isPy3k;

     

       31
        
       

     

       32
       +
         src = fetchPypi {

     

       33
       +
           inherit version;

     

       34
       +
           pname = "weasyprint";

     

       35
       +
           sha256 = "sha256-EMyxfVXHMJa98e3T7+WMuFWwfkwwfZutTryaPxP/RYA=";

     

       36
       +
         };

     

       37
       +
       

     

       38
       +
         postPatch = ''

     

       39
       +
           substituteInPlace pyproject.toml \

     

       40
       +
             --replace "--isort --flake8 --cov --no-cov-on-fail" ""

     

       41
       +
         '';

     

       42
        
       

     

       43
        
         disabledTests = [

     

       44
       +
           # needs the Ahem font (fails on macOS)

     

       45
        
           "test_font_stretch"

     

       46
        
         ];

     

       47
        
       

     

       48
        
         checkInputs = [

     

       49
        
           pytestCheckHook

     

       50
        
           ghostscript

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       51
        
         ];

     

       52
        
       

     

       53
        
         FONTCONFIG_FILE = "${fontconfig.out}/etc/fonts/fonts.conf";

     
···

       77
        
             harfbuzz = "${harfbuzz.out}/lib/libharfbuzz${stdenv.hostPlatform.extensions.sharedLibrary}";

     

       78
        
           })

     

       79
        
         ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
       

     

       81
        
         meta = with lib; {

     

       82
        
           homepage = "https://weasyprint.org/";

+2 -2

pkgs/development/tools/analysis/checkov/default.nix

···

       56
        
       

     

       57
        
       buildPythonApplication rec {

     

       58
        
         pname = "checkov";

     

       59
       -
         version = "2.0.582";

     

       60
        
       

     

       61
        
         src = fetchFromGitHub {

     

       62
        
           owner = "bridgecrewio";

     

       63
        
           repo = pname;

     

       64
        
           rev = version;

     

       65
       -
           sha256 = "sha256-25RT70HyOyfdg2jWLKMnEVgvNdlZuJ0e6eajlU486IQ=";

     

       66
        
         };

     

       67
        
       

     

       68
        
         nativeBuildInputs = with py.pkgs; [

···

       56
        
       

     

       57
        
       buildPythonApplication rec {

     

       58
        
         pname = "checkov";

     

       59
       +
         version = "2.0.587";

     

       60
        
       

     

       61
        
         src = fetchFromGitHub {

     

       62
        
           owner = "bridgecrewio";

     

       63
        
           repo = pname;

     

       64
        
           rev = version;

     

       65
       +
           sha256 = "sha256-uLH3g3UeWdIZsMsUwCYpTehgxDKGraPBlENdTz+QYLI=";

     

       66
        
         };

     

       67
        
       

     

       68
        
         nativeBuildInputs = with py.pkgs; [

-3

pkgs/development/tools/haskell/hyper-haskell/default.nix

···

       49
        
           homepage = "https://github.com/HeinrichApfelmus/hyper-haskell";

     

       50
        
           license = licenses.bsd3;

     

       51
        
           maintainers = [ maintainers.rvl ];

     

       52
       -
           # depends on electron-10.4.7 which is marked as insecure:

     

       53
       -
           # https://github.com/NixOS/nixpkgs/pull/142641#issuecomment-957358476

     

       54
       -
           broken = true;

     

       55
        
         };

     

       56
        
       }

···

       49
        
           homepage = "https://github.com/HeinrichApfelmus/hyper-haskell";

     

       50
        
           license = licenses.bsd3;

     

       51
        
           maintainers = [ maintainers.rvl ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       52
        
         };

     

       53
        
       }

+3 -1

pkgs/development/tools/rust/devserver/default.nix

···

       1
        
       { lib

     

       0
        
       
     

       2
        
       , fetchCrate

     

       3
        
       , rustPlatform

     

       4
        
       , openssl

     

       5
        
       , pkg-config

     

       0
        
       
     

       6
        
       }:

     

       7
        
       

     

       8
        
       rustPlatform.buildRustPackage rec {

     
···

       16
        
       

     

       17
        
         nativeBuildInputs = [ pkg-config ];

     

       18
        
       

     

       19
       -
         buildInputs = [ openssl ];

     

       20
        
       

     

       21
        
         cargoSha256 = "sha256-XlrQ6CvjeWnzvfaeNbe8FtMXMVSQNLxDVIEjyHm57Js=";

     

       22

···

       1
        
       { lib

     

       2
       +
       , stdenv

     

       3
        
       , fetchCrate

     

       4
        
       , rustPlatform

     

       5
        
       , openssl

     

       6
        
       , pkg-config

     

       7
       +
       , CoreServices

     

       8
        
       }:

     

       9
        
       

     

       10
        
       rustPlatform.buildRustPackage rec {

     
···

       18
        
       

     

       19
        
         nativeBuildInputs = [ pkg-config ];

     

       20
        
       

     

       21
       +
         buildInputs = [ openssl ] ++ lib.optional stdenv.isDarwin CoreServices;

     

       22
        
       

     

       23
        
         cargoSha256 = "sha256-XlrQ6CvjeWnzvfaeNbe8FtMXMVSQNLxDVIEjyHm57Js=";

     

       24

+1 -1

pkgs/servers/home-assistant/component-packages.nix

···

       573
        
           "nextcloud" = ps: with ps; [ nextcloudmonitor ];

     

       574
        
           "nfandroidtv" = ps: with ps; [ ]; # missing inputs: notifications-android-tv

     

       575
        
           "nightscout" = ps: with ps; [ ]; # missing inputs: py-nightscout

     

       576
       -
           "niko_home_control" = ps: with ps; [ ]; # missing inputs: niko-home-control

     

       577
        
           "nilu" = ps: with ps; [ niluclient ];

     

       578
        
           "nissan_leaf" = ps: with ps; [ pycarwings2 ];

     

       579
        
           "nmap_tracker" = ps: with ps; [ aiohttp-cors getmac ifaddr netmap ]; # missing inputs: mac-vendor-lookup

···

       573
        
           "nextcloud" = ps: with ps; [ nextcloudmonitor ];

     

       574
        
           "nfandroidtv" = ps: with ps; [ ]; # missing inputs: notifications-android-tv

     

       575
        
           "nightscout" = ps: with ps; [ ]; # missing inputs: py-nightscout

     

       576
       +
           "niko_home_control" = ps: with ps; [ niko-home-control ];

     

       577
        
           "nilu" = ps: with ps; [ niluclient ];

     

       578
        
           "nissan_leaf" = ps: with ps; [ pycarwings2 ];

     

       579
        
           "nmap_tracker" = ps: with ps; [ aiohttp-cors getmac ifaddr netmap ]; # missing inputs: mac-vendor-lookup

+14 -22

pkgs/servers/monitoring/icinga2/default.nix

···

       1
       -
       { stdenv, lib, fetchFromGitHub, fetchpatch, cmake, flex, bison, systemd

     

       2
       -
       , boost, openssl, patchelf, mariadb-connector-c, postgresql, zlib

     

       3
        
       # Databases

     

       4
        
       , withMysql ? true, withPostgresql ? false

     

       5
        
       # Features

     
···

       22
        
           ./etc-icinga2.patch # Makes /etc/icinga2 relative to / instead of the store path

     

       23
        
           ./no-systemd-service.patch # Prevent systemd service from being written to /usr

     

       24
        
           ./no-var-directories.patch # Prevent /var directories from being created

     

       25
       -
           # Fix the non-unity build

     

       26
       -
           (fetchpatch {

     

       27
       -
             url = "https://github.com/Icinga/icinga2/commit/2ad0a4b8c3852ad937fec9fc85780230257c821e.patch";

     

       28
       -
             sha256 = "sha256:06qn7x73zbccmd8ycj46a29x2rr6qjwg0rr831wc2gc6q2k9d2g0";

     

       29
       -
           })

     

       30
        
         ];

     

       31
        
       

     

       32
        
         cmakeFlags = let

     
···

       40
        
           "-DMYSQL_INCLUDE_DIR=${mariadb-connector-c.dev}/include/mariadb"

     

       41
        
           "-DMYSQL_LIB=${mariadb-connector-c.out}/lib/mariadb/libmysqlclient.a"

     

       42
        
           "-DICINGA2_PLUGINDIR=bin"

     

       43
       -
           "-DICINGA2_UNITY_BUILD=no"

     

       44
        
           # Features

     

       45
        
           (mkFeatureFlag "MYSQL" withMysql)

     

       46
        
           (mkFeatureFlag "PGSQL" withPostgresql)

     
···

       54
        
           "-DICINGA2_USER=icinga2"

     

       55
        
           "-DICINGA2_GROUP=icinga2"

     

       56
        
           "-DICINGA2_GIT_VERSION_INFO=OFF"

     

       57
       -
           "-DICINGA2_WITH_TESTS=OFF"

     

       58
        
           "-DUSE_SYSTEMD=ON"

     

       59
        
         ];

     

       0
        
       
     

       0
        
       
     

       60
        
       

     

       61
        
         buildInputs = [ boost openssl systemd ]

     

       62
        
           ++ lib.optional withPostgresql postgresql;

     

       63
        
       

     

       64
        
         nativeBuildInputs = [ cmake flex bison patchelf ];

     

       65
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       66
        
         postFixup = ''

     

       67
        
           rm -r $out/etc/logrotate.d $out/etc/sysconfig $out/lib/icinga2/prepare-dirs

     

       68
        
       

     

       69
        
           # Fix hardcoded paths

     

       70
        
           sed -i 's:/usr/bin/::g' $out/etc/icinga2/scripts/*

     

       71
        
       

     

       72
       -
           # Cleanup sbin

     

       73
        
           sed -i 's/sbin/bin/g' $out/lib/icinga2/safe-reload

     

       0
        
       
     

       74
        
           rm $out/sbin

     

       75
        
       

     

       76
        
           ${lib.optionalString withMysql ''

     
···

       83
        
           ''}

     

       84
        
         '';

     

       85
        
       

     

       86
       -
         vim = stdenv.mkDerivation {

     

       87
       -
           pname = "vim-icinga2";

     

       88
       -
           inherit version src;

     

       89
       -
       

     

       90
       -
           dontConfigure = true;

     

       91
       -
           dontBuild = true;

     

       92
       -
       

     

       93
       -
           installPhase = ''

     

       94
       -
             mkdir -p $out/share/vim-plugins

     

       95
       -
             cp -r tools/syntax/vim $out/share/vim-plugins/icinga2

     

       96
       -
           '';

     

       97
       -
         };

     

       98
        
       

     

       99
        
         meta = {

     

       100
        
           description = "Open source monitoring system";

···

       1
       +
       { stdenv, runCommand, lib, fetchFromGitHub, fetchpatch, cmake, flex, bison, systemd

     

       2
       +
       , boost, openssl, patchelf, mariadb-connector-c, postgresql, zlib, tzdata

     

       3
        
       # Databases

     

       4
        
       , withMysql ? true, withPostgresql ? false

     

       5
        
       # Features

     
···

       22
        
           ./etc-icinga2.patch # Makes /etc/icinga2 relative to / instead of the store path

     

       23
        
           ./no-systemd-service.patch # Prevent systemd service from being written to /usr

     

       24
        
           ./no-var-directories.patch # Prevent /var directories from being created

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
         ];

     

       26
        
       

     

       27
        
         cmakeFlags = let

     
···

       35
        
           "-DMYSQL_INCLUDE_DIR=${mariadb-connector-c.dev}/include/mariadb"

     

       36
        
           "-DMYSQL_LIB=${mariadb-connector-c.out}/lib/mariadb/libmysqlclient.a"

     

       37
        
           "-DICINGA2_PLUGINDIR=bin"

     

       38
       +
           "-DICINGA2_LTO_BUILD=yes"

     

       39
        
           # Features

     

       40
        
           (mkFeatureFlag "MYSQL" withMysql)

     

       41
        
           (mkFeatureFlag "PGSQL" withPostgresql)

     
···

       49
        
           "-DICINGA2_USER=icinga2"

     

       50
        
           "-DICINGA2_GROUP=icinga2"

     

       51
        
           "-DICINGA2_GIT_VERSION_INFO=OFF"

     

       0
        
       
     

       52
        
           "-DUSE_SYSTEMD=ON"

     

       53
        
         ];

     

       54
       +
       

     

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

     

       56
        
       

     

       57
        
         buildInputs = [ boost openssl systemd ]

     

       58
        
           ++ lib.optional withPostgresql postgresql;

     

       59
        
       

     

       60
        
         nativeBuildInputs = [ cmake flex bison patchelf ];

     

       61
        
       

     

       62
       +
         doCheck = true;

     

       63
       +
         checkInputs = [ tzdata ]; # legacytimeperiod/dst needs this

     

       64
       +
       

     

       65
        
         postFixup = ''

     

       66
        
           rm -r $out/etc/logrotate.d $out/etc/sysconfig $out/lib/icinga2/prepare-dirs

     

       67
        
       

     

       68
        
           # Fix hardcoded paths

     

       69
        
           sed -i 's:/usr/bin/::g' $out/etc/icinga2/scripts/*

     

       70
        
       

     

       71
       +
           # Get rid of sbin

     

       72
        
           sed -i 's/sbin/bin/g' $out/lib/icinga2/safe-reload

     

       73
       +
           sed -i 's/sbin/bin/g' $out/bin/icinga2

     

       74
        
           rm $out/sbin

     

       75
        
       

     

       76
        
           ${lib.optionalString withMysql ''

     
···

       83
        
           ''}

     

       84
        
         '';

     

       85
        
       

     

       86
       +
         vim = runCommand "vim-icinga2-${version}" {} ''

     

       87
       +
           mkdir -p $out/share/vim-plugins

     

       88
       +
           cp -r "${src}/tools/syntax/vim" $out/share/vim-plugins/icinga2

     

       89
       +
         '';

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       90
        
       

     

       91
        
         meta = {

     

       92
        
           description = "Open source monitoring system";

-27

pkgs/servers/mumsi/default.nix

···

       1
       -
       { stdenv, lib, fetchFromGitHub, cmake, pkg-config, boost

     

       2
       -
       , log4cpp, pjsip, openssl, alsa-lib, mumlib }:

     

       3
       -
       with lib; stdenv.mkDerivation {

     

       4
       -
         pname = "mumsi";

     

       5
       -
         version = "unstable-2018-12-12";

     

       6
       -
       

     

       7
       -
         src = fetchFromGitHub {

     

       8
       -
           owner = "slomkowski";

     

       9
       -
           repo = "mumsi";

     

       10
       -
           rev = "961b75792f8da22fb5502e39edb286e32172d0b0";

     

       11
       -
           sha256 = "0vrivl1fiiwjsz4v26nrn8ra3k9v0mcz7zjm2z319fw8hv6n1nrk";

     

       12
       -
         };

     

       13
       -
       

     

       14
       -
         buildInputs = [ boost log4cpp pkg-config pjsip mumlib openssl alsa-lib ];

     

       15
       -
         nativeBuildInputs = [ cmake pkg-config ];

     

       16
       -
         installPhase = ''

     

       17
       -
           install -Dm555 mumsi $out/bin/mumsi

     

       18
       -
         '';

     

       19
       -
       

     

       20
       -
         meta = {

     

       21
       -
           description = "SIP to Mumble gateway/bridge using PJSUA stack";

     

       22
       -
           homepage = "https://github.com/slomkowski/mumsi";

     

       23
       -
           maintainers = with maintainers; [ das_j ];

     

       24
       -
           license = licenses.asl20;

     

       25
       -
           platforms = platforms.linux;

     

       26
       -
         };

     

       27
       -
       }

+2 -2

pkgs/servers/web-apps/sogo/default.nix

···

       2
        
       , openssl, openldap, sope, libmemcached, curl, libsodium, libytnef, libzip, pkg-config, nixosTests }:

     

       3
        
       gnustep.stdenv.mkDerivation rec {

     

       4
        
         pname = "SOGo";

     

       5
       -
         version = "5.2.0";

     

       6
        
       

     

       7
        
         src = fetchFromGitHub {

     

       8
        
           owner = "inverse-inc";

     

       9
        
           repo = pname;

     

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

     

       11
       -
           sha256 = "0y9im5y6ffdc7sy2qphq0xai4ig1ks7vj10vy4mn1psdlc5kd516";

     

       12
        
         };

     

       13
        
       

     

       14
        
         nativeBuildInputs = [ gnustep.make makeWrapper python3 ];

···

       2
        
       , openssl, openldap, sope, libmemcached, curl, libsodium, libytnef, libzip, pkg-config, nixosTests }:

     

       3
        
       gnustep.stdenv.mkDerivation rec {

     

       4
        
         pname = "SOGo";

     

       5
       +
         version = "5.3.0";

     

       6
        
       

     

       7
        
         src = fetchFromGitHub {

     

       8
        
           owner = "inverse-inc";

     

       9
        
           repo = pname;

     

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

     

       11
       +
           sha256 = "0f09b2ga43xdd8w14llclrsdxc1y8xb3g1h15lahxq82xkvixjjl";

     

       12
        
         };

     

       13
        
       

     

       14
        
         nativeBuildInputs = [ gnustep.make makeWrapper python3 ];

+3 -1

pkgs/tools/archivers/pax/default.nix

···

       1
       -
       { lib, stdenv, fetchurl }:

     

       2
        
       

     

       3
        
       stdenv.mkDerivation rec {

     

       4
        
         pname = "pax";

     
···

       8
        
           url = "http://www.mirbsd.org/MirOS/dist/mir/cpio/paxmirabilis-${version}.tgz";

     

       9
        
           sha256 = "1p18nxijh323f4i1s2pg7pcr0557xljl5avv8ll5s9nfr34r5j0w";

     

       10
        
         };

     

       0
        
       
     

       0
        
       
     

       11
        
       

     

       12
        
         buildPhase = ''

     

       13
        
           sh Build.sh -r -tpax

···

       1
       +
       { lib, stdenv, fetchurl, utmp }:

     

       2
        
       

     

       3
        
       stdenv.mkDerivation rec {

     

       4
        
         pname = "pax";

     
···

       8
        
           url = "http://www.mirbsd.org/MirOS/dist/mir/cpio/paxmirabilis-${version}.tgz";

     

       9
        
           sha256 = "1p18nxijh323f4i1s2pg7pcr0557xljl5avv8ll5s9nfr34r5j0w";

     

       10
        
         };

     

       11
       +
       

     

       12
       +
         buildInputs = lib.optional stdenv.isDarwin utmp;

     

       13
        
       

     

       14
        
         buildPhase = ''

     

       15
        
           sh Build.sh -r -tpax

pkgs/tools/misc/convbin/default.nix

···

       13
        
           sha256 = "sha256-zCRM62xwaPaN8+cg+CeaqK/9hKpZmSBBeUOQqAvQGYw=";

     

       14
        
         };

     

       15
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       16
        
         makeFlags = [ "CC=${stdenv.cc.targetPrefix}cc" ];

     

       17
        
       

     

       18
        
         checkPhase = ''

···

       13
        
           sha256 = "sha256-zCRM62xwaPaN8+cg+CeaqK/9hKpZmSBBeUOQqAvQGYw=";

     

       14
        
         };

     

       15
        
       

     

       16
       +
         postPatch = lib.optionalString stdenv.isDarwin ''

     

       17
       +
           substituteInPlace Makefile --replace "-flto" ""

     

       18
       +
         '';

     

       19
       +
       

     

       20
        
         makeFlags = [ "CC=${stdenv.cc.targetPrefix}cc" ];

     

       21
        
       

     

       22
        
         checkPhase = ''

+2 -1

pkgs/tools/misc/gparted/default.nix

···

       1
        
       { lib, stdenv, fetchurl, intltool, gettext, coreutils, gnused, gnome

     

       2
        
       , gnugrep, parted, glib, libuuid, pkg-config, gtkmm3, libxml2

     

       3
        
       , gpart, hdparm, procps, util-linux, polkit, wrapGAppsHook, substituteAll

     

       0
        
       
     

       4
        
       }:

     

       5
        
       

     

       6
        
       stdenv.mkDerivation rec {

     
···

       29
        
       

     

       30
        
         preFixup = ''

     

       31
        
           gappsWrapperArgs+=(

     

       32
       -
              --prefix PATH : "${lib.makeBinPath [ gpart hdparm util-linux procps coreutils gnused gnugrep ]}"

     

       33
        
           )

     

       34
        
         '';

     

       35

···

       1
        
       { lib, stdenv, fetchurl, intltool, gettext, coreutils, gnused, gnome

     

       2
        
       , gnugrep, parted, glib, libuuid, pkg-config, gtkmm3, libxml2

     

       3
        
       , gpart, hdparm, procps, util-linux, polkit, wrapGAppsHook, substituteAll

     

       4
       +
       , mtools, dosfstools

     

       5
        
       }:

     

       6
        
       

     

       7
        
       stdenv.mkDerivation rec {

     
···

       30
        
       

     

       31
        
         preFixup = ''

     

       32
        
           gappsWrapperArgs+=(

     

       33
       +
              --prefix PATH : "${lib.makeBinPath [ gpart hdparm util-linux procps coreutils gnused gnugrep mtools dosfstools ]}"

     

       34
        
           )

     

       35
        
         '';

     

       36

pkgs/tools/misc/rates/default.nix

···

       1
        
       { lib

     

       0
        
       
     

       2
        
       , fetchFromGitHub

     

       3
        
       , rustPlatform

     

       0
        
       
     

       4
        
       }:

     

       5
        
       

     

       6
        
       rustPlatform.buildRustPackage rec {

     
···

       15
        
         };

     

       16
        
       

     

       17
        
         cargoSha256 = "041sskiq152iywwqd8p7aqsqzbj359zl7ilnp8ahzdqprz3slk1w";

     

       0
        
       
     

       0
        
       
     

       18
        
       

     

       19
        
         meta = with lib; {

     

       20
        
           description = "CLI tool that brings currency exchange rates right into your terminal";

···

       1
        
       { lib

     

       2
       +
       , stdenv

     

       3
        
       , fetchFromGitHub

     

       4
        
       , rustPlatform

     

       5
       +
       , Security

     

       6
        
       }:

     

       7
        
       

     

       8
        
       rustPlatform.buildRustPackage rec {

     
···

       17
        
         };

     

       18
        
       

     

       19
        
         cargoSha256 = "041sskiq152iywwqd8p7aqsqzbj359zl7ilnp8ahzdqprz3slk1w";

     

       20
       +
       

     

       21
       +
         buildInputs = lib.optional stdenv.isDarwin Security;

     

       22
        
       

     

       23
        
         meta = with lib; {

     

       24
        
           description = "CLI tool that brings currency exchange rates right into your terminal";

+4 -4

pkgs/tools/networking/lychee/default.nix

···

       7
        
       

     

       8
        
       rustPlatform.buildRustPackage rec {

     

       9
        
         pname = "lychee";

     

       10
       -
         version = "0.7.0";

     

       11
        
       

     

       12
        
         src = fetchFromGitHub {

     

       13
        
           owner = "lycheeverse";

     

       14
        
           repo = pname;

     

       15
       -
           rev = version;

     

       16
       -
           sha256 = "0kpwpbv0dqb0p4bxjlcjas6x1n91rdsvy2psrc1nyr1sh6gb1q5j";

     

       17
        
         };

     

       18
        
       

     

       19
       -
         cargoSha256 = "1b915zkg41n3azk4hhg6fgc83n7iq8p7drvdyil2m2a4qdjvp9r3";

     

       20
        
       

     

       21
        
         nativeBuildInputs = [ pkg-config ];

     

       22

···

       7
        
       

     

       8
        
       rustPlatform.buildRustPackage rec {

     

       9
        
         pname = "lychee";

     

       10
       +
         version = "0.8.1";

     

       11
        
       

     

       12
        
         src = fetchFromGitHub {

     

       13
        
           owner = "lycheeverse";

     

       14
        
           repo = pname;

     

       15
       +
           rev = "v${version}";

     

       16
       +
           sha256 = "sha256-TjjSysG4UCXVi5ytWaJVL31TFLHC3Ro5OEB56pzbn7s=";

     

       17
        
         };

     

       18
        
       

     

       19
       +
         cargoSha256 = "sha256-apRXxd7RBnNjhZb0xAUr5hSTafyMbg0k1wgHT93Z66g=";

     

       20
        
       

     

       21
        
         nativeBuildInputs = [ pkg-config ];

     

       22

+2 -2

pkgs/tools/security/exploitdb/default.nix

···

       2
        
       

     

       3
        
       stdenv.mkDerivation rec {

     

       4
        
         pname = "exploitdb";

     

       5
       -
         version = "2021-11-16";

     

       6
        
       

     

       7
        
         src = fetchFromGitHub {

     

       8
        
           owner = "offensive-security";

     

       9
        
           repo = pname;

     

       10
        
           rev = version;

     

       11
       -
           sha256 = "sha256-xsTmZdEee/lrRYPemny7lUy13xXVVDrb7w1NBnkzmJM=";

     

       12
        
         };

     

       13
        
       

     

       14
        
         nativeBuildInputs = [ makeWrapper ];

···

       2
        
       

     

       3
        
       stdenv.mkDerivation rec {

     

       4
        
         pname = "exploitdb";

     

       5
       +
         version = "2021-11-18";

     

       6
        
       

     

       7
        
         src = fetchFromGitHub {

     

       8
        
           owner = "offensive-security";

     

       9
        
           repo = pname;

     

       10
        
           rev = version;

     

       11
       +
           sha256 = "sha256-GSqJIM/wAgSKn9BWOSEwmrVTwI6ZOTZGNHRcepDT7MI=";

     

       12
        
         };

     

       13
        
       

     

       14
        
         nativeBuildInputs = [ makeWrapper ];

+1 -1

pkgs/tools/security/metasploit/Gemfile

···

       1
        
       # frozen_string_literal: true

     

       2
        
       source "https://rubygems.org"

     

       3
        
       

     

       4
       -
       gem "metasploit-framework", git: "https://github.com/rapid7/metasploit-framework", ref: "refs/tags/6.1.14"

···

       1
        
       # frozen_string_literal: true

     

       2
        
       source "https://rubygems.org"

     

       3
        
       

     

       4
       +
       gem "metasploit-framework", git: "https://github.com/rapid7/metasploit-framework", ref: "refs/tags/6.1.15"

+8 -8

pkgs/tools/security/metasploit/Gemfile.lock

···

       1
        
       GIT

     

       2
        
         remote: https://github.com/rapid7/metasploit-framework

     

       3
       -
         revision: 2c47df62b425e4083f4816d71405fed1c0e8b35b

     

       4
       -
         ref: refs/tags/6.1.14

     

       5
        
         specs:

     

       6
       -
           metasploit-framework (6.1.14)

     

       7
        
             actionpack (~> 6.0)

     

       8
        
             activerecord (~> 6.0)

     

       9
        
             activesupport (~> 6.0)

     
···

       128
        
           arel-helpers (2.12.1)

     

       129
        
             activerecord (>= 3.1.0, < 7)

     

       130
        
           aws-eventstream (1.2.0)

     

       131
       -
           aws-partitions (1.528.0)

     

       132
        
           aws-sdk-core (3.122.1)

     

       133
        
             aws-eventstream (~> 1, >= 1.0.2)

     

       134
        
             aws-partitions (~> 1, >= 1.525.0)

     

       135
        
             aws-sigv4 (~> 1.1)

     

       136
        
             jmespath (~> 1.0)

     

       137
       -
           aws-sdk-ec2 (1.279.0)

     

       138
        
             aws-sdk-core (~> 3, >= 3.122.0)

     

       139
        
             aws-sigv4 (~> 1.1)

     

       140
        
           aws-sdk-iam (1.63.0)

     
···

       143
        
           aws-sdk-kms (1.51.0)

     

       144
        
             aws-sdk-core (~> 3, >= 3.122.0)

     

       145
        
             aws-sigv4 (~> 1.1)

     

       146
       -
           aws-sdk-s3 (1.105.1)

     

       147
        
             aws-sdk-core (~> 3, >= 3.122.0)

     

       148
        
             aws-sdk-kms (~> 1)

     

       149
        
             aws-sigv4 (~> 1.4)

     
···

       288
        
             pcaprub

     

       289
        
           patch_finder (1.0.2)

     

       290
        
           pcaprub (0.12.4)

     

       291
       -
           pdf-reader (2.5.0)

     

       292
        
             Ascii85 (~> 1.0)

     

       293
        
             afm (~> 0.2.1)

     

       294
        
             hashery (~> 2.0)

     
···

       330
        
             rex-core

     

       331
        
             rex-struct2

     

       332
        
             rex-text

     

       333
       -
           rex-core (0.1.18)

     

       334
        
           rex-encoder (0.1.6)

     

       335
        
             metasm

     

       336
        
             rex-arch

···

       1
        
       GIT

     

       2
        
         remote: https://github.com/rapid7/metasploit-framework

     

       3
       +
         revision: 1dd828ca9f705d3f05d273b535ff666b5941ddd6

     

       4
       +
         ref: refs/tags/6.1.15

     

       5
        
         specs:

     

       6
       +
           metasploit-framework (6.1.15)

     

       7
        
             actionpack (~> 6.0)

     

       8
        
             activerecord (~> 6.0)

     

       9
        
             activesupport (~> 6.0)

     
···

       128
        
           arel-helpers (2.12.1)

     

       129
        
             activerecord (>= 3.1.0, < 7)

     

       130
        
           aws-eventstream (1.2.0)

     

       131
       +
           aws-partitions (1.533.0)

     

       132
        
           aws-sdk-core (3.122.1)

     

       133
        
             aws-eventstream (~> 1, >= 1.0.2)

     

       134
        
             aws-partitions (~> 1, >= 1.525.0)

     

       135
        
             aws-sigv4 (~> 1.1)

     

       136
        
             jmespath (~> 1.0)

     

       137
       +
           aws-sdk-ec2 (1.281.0)

     

       138
        
             aws-sdk-core (~> 3, >= 3.122.0)

     

       139
        
             aws-sigv4 (~> 1.1)

     

       140
        
           aws-sdk-iam (1.63.0)

     
···

       143
        
           aws-sdk-kms (1.51.0)

     

       144
        
             aws-sdk-core (~> 3, >= 3.122.0)

     

       145
        
             aws-sigv4 (~> 1.1)

     

       146
       +
           aws-sdk-s3 (1.106.0)

     

       147
        
             aws-sdk-core (~> 3, >= 3.122.0)

     

       148
        
             aws-sdk-kms (~> 1)

     

       149
        
             aws-sigv4 (~> 1.4)

     
···

       288
        
             pcaprub

     

       289
        
           patch_finder (1.0.2)

     

       290
        
           pcaprub (0.12.4)

     

       291
       +
           pdf-reader (2.6.0)

     

       292
        
             Ascii85 (~> 1.0)

     

       293
        
             afm (~> 0.2.1)

     

       294
        
             hashery (~> 2.0)

     
···

       330
        
             rex-core

     

       331
        
             rex-struct2

     

       332
        
             rex-text

     

       333
       +
           rex-core (0.1.20)

     

       334
        
           rex-encoder (0.1.6)

     

       335
        
             metasm

     

       336
        
             rex-arch

+2 -2

pkgs/tools/security/metasploit/default.nix

···

       15
        
         };

     

       16
        
       in stdenv.mkDerivation rec {

     

       17
        
         pname = "metasploit-framework";

     

       18
       -
         version = "6.1.14";

     

       19
        
       

     

       20
        
         src = fetchFromGitHub {

     

       21
        
           owner = "rapid7";

     

       22
        
           repo = "metasploit-framework";

     

       23
        
           rev = version;

     

       24
       -
           sha256 = "sha256-ySQOc/k+kvdSj5g88ujm4e2apvPVbiaspzSbCdEQ4ZA=";

     

       25
        
         };

     

       26
        
       

     

       27
        
         nativeBuildInputs = [ makeWrapper ];

···

       15
        
         };

     

       16
        
       in stdenv.mkDerivation rec {

     

       17
        
         pname = "metasploit-framework";

     

       18
       +
         version = "6.1.15";

     

       19
        
       

     

       20
        
         src = fetchFromGitHub {

     

       21
        
           owner = "rapid7";

     

       22
        
           repo = "metasploit-framework";

     

       23
        
           rev = version;

     

       24
       +
           sha256 = "sha256-Wz5FeM7AvRS4mV3BJcWOdp1GgAzTOqRnjBAQp4/Oj5E=";

     

       25
        
         };

     

       26
        
       

     

       27
        
         nativeBuildInputs = [ makeWrapper ];

+13 -13

pkgs/tools/security/metasploit/gemset.nix

···

       104
        
           platforms = [];

     

       105
        
           source = {

     

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

     

       107
       -
             sha256 = "1awcpdvfk6dlb9n5wiksq8vhqwdpmkybv4ga8drmlx6x9li3my5k";

     

       108
        
             type = "gem";

     

       109
        
           };

     

       110
       -
           version = "1.528.0";

     

       111
        
         };

     

       112
        
         aws-sdk-core = {

     

       113
        
           groups = ["default"];

     
···

       124
        
           platforms = [];

     

       125
        
           source = {

     

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

     

       127
       -
             sha256 = "1cvf70lj99r59wn35pqxg5c6c2qkgnir0b8fqgi8h757xz6b9m72";

     

       128
        
             type = "gem";

     

       129
        
           };

     

       130
       -
           version = "1.279.0";

     

       131
        
         };

     

       132
        
         aws-sdk-iam = {

     

       133
        
           groups = ["default"];

     
···

       154
        
           platforms = [];

     

       155
        
           source = {

     

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

     

       157
       -
             sha256 = "12j7i6l52b6hsnj59grn0m1s9pn6l38zmra6ad8i12vdsvd185w7";

     

       158
        
             type = "gem";

     

       159
        
           };

     

       160
       -
           version = "1.105.1";

     

       161
        
         };

     

       162
        
         aws-sigv4 = {

     

       163
        
           groups = ["default"];

     
···

       664
        
           platforms = [];

     

       665
        
           source = {

     

       666
        
             fetchSubmodules = false;

     

       667
       -
             rev = "2c47df62b425e4083f4816d71405fed1c0e8b35b";

     

       668
       -
             sha256 = "1471238hk6rllyn2cvnmyfk9mvg1wvlg4g4qix9gg4iyz5rhw969";

     

       669
        
             type = "git";

     

       670
        
             url = "https://github.com/rapid7/metasploit-framework";

     

       671
        
           };

     

       672
       -
           version = "6.1.14";

     

       673
        
         };

     

       674
        
         metasploit-model = {

     

       675
        
           groups = ["default"];

     
···

       947
        
           platforms = [];

     

       948
        
           source = {

     

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

     

       950
       -
             sha256 = "14cxj3ra9nnn334qpm2vsx9s0zk3095s8ih6cwcp47h3hv03c73y";

     

       951
        
             type = "gem";

     

       952
        
           };

     

       953
       -
           version = "2.5.0";

     

       954
        
         };

     

       955
        
         pg = {

     

       956
        
           groups = ["default"];

     
···

       1127
        
           platforms = [];

     

       1128
        
           source = {

     

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

     

       1130
       -
             sha256 = "1i3rn2ndf9ijgjfn3c8rpblw8lnqynm2flmfmm6dbfhjyhhawnaz";

     

       1131
        
             type = "gem";

     

       1132
        
           };

     

       1133
       -
           version = "0.1.18";

     

       1134
        
         };

     

       1135
        
         rex-encoder = {

     

       1136
        
           groups = ["default"];

···

       104
        
           platforms = [];

     

       105
        
           source = {

     

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

     

       107
       +
             sha256 = "052y91z5xqysfmnclcp0k9cy7dgjk28xv6dskwww42ljdgjxcmxi";

     

       108
        
             type = "gem";

     

       109
        
           };

     

       110
       +
           version = "1.533.0";

     

       111
        
         };

     

       112
        
         aws-sdk-core = {

     

       113
        
           groups = ["default"];

     
···

       124
        
           platforms = [];

     

       125
        
           source = {

     

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

     

       127
       +
             sha256 = "01ywgc5mh1h19ac10l1ck911qgkxqavwbanp4i6h9ddlcd9jmhm1";

     

       128
        
             type = "gem";

     

       129
        
           };

     

       130
       +
           version = "1.281.0";

     

       131
        
         };

     

       132
        
         aws-sdk-iam = {

     

       133
        
           groups = ["default"];

     
···

       154
        
           platforms = [];

     

       155
        
           source = {

     

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

     

       157
       +
             sha256 = "06ix8lw1r0mw77hnc7ns0fqrsl616g35xw8qcsihzwzgvwb2z0mb";

     

       158
        
             type = "gem";

     

       159
        
           };

     

       160
       +
           version = "1.106.0";

     

       161
        
         };

     

       162
        
         aws-sigv4 = {

     

       163
        
           groups = ["default"];

     
···

       664
        
           platforms = [];

     

       665
        
           source = {

     

       666
        
             fetchSubmodules = false;

     

       667
       +
             rev = "1dd828ca9f705d3f05d273b535ff666b5941ddd6";

     

       668
       +
             sha256 = "14cgrs7sf40hiiks8fnk1j04d7bniv2jbhaxk6w19gf0rrw4agjv";

     

       669
        
             type = "git";

     

       670
        
             url = "https://github.com/rapid7/metasploit-framework";

     

       671
        
           };

     

       672
       +
           version = "6.1.15";

     

       673
        
         };

     

       674
        
         metasploit-model = {

     

       675
        
           groups = ["default"];

     
···

       947
        
           platforms = [];

     

       948
        
           source = {

     

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

     

       950
       +
             sha256 = "0zgv9pp9cqd1cf8bwk7pb5lkm81gn7znnan0a7s42wd0qavs4nnz";

     

       951
        
             type = "gem";

     

       952
        
           };

     

       953
       +
           version = "2.6.0";

     

       954
        
         };

     

       955
        
         pg = {

     

       956
        
           groups = ["default"];

     
···

       1127
        
           platforms = [];

     

       1128
        
           source = {

     

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

     

       1130
       +
             sha256 = "0hy7xrd3pwyfk2199zkgfa6kz1fsx7ngf6s512gpk8gadjc8hq6j";

     

       1131
        
             type = "gem";

     

       1132
        
           };

     

       1133
       +
           version = "0.1.20";

     

       1134
        
         };

     

       1135
        
         rex-encoder = {

     

       1136
        
           groups = ["default"];

+2 -2

pkgs/tools/security/trufflehog/default.nix

···

       12
        
       in

     

       13
        
         python3Packages.buildPythonApplication rec {

     

       14
        
           pname = "truffleHog";

     

       15
       -
           version = "2.1.11";

     

       16
        
       

     

       17
        
           src = python3Packages.fetchPypi {

     

       18
        
             inherit pname version;

     

       19
       -
             sha256 = "53619f0c5be082abd377f987291ace80bc3b88f864972b1a30494780980f769e";

     

       20
        
           };

     

       21
        
       

     

       22
        
           # Relax overly restricted version constraint

···

       12
        
       in

     

       13
        
         python3Packages.buildPythonApplication rec {

     

       14
        
           pname = "truffleHog";

     

       15
       +
           version = "2.2.1";

     

       16
        
       

     

       17
        
           src = python3Packages.fetchPypi {

     

       18
        
             inherit pname version;

     

       19
       +
             sha256 = "sha256-fw0JyM2iqQrkL4FAXllEozJdkKWELS3eAURx5NZcceQ=";

     

       20
        
           };

     

       21
        
       

     

       22
        
           # Relax overly restricted version constraint

pkgs/top-level/aliases.nix

···

       576
        
         mssys = ms-sys; # added 2015-12-13

     

       577
        
         mpv-with-scripts = self.wrapMpv self.mpv-unwrapped { }; # added 2020-05-22

     

       578
        
         multipath_tools = multipath-tools;  # added 2016-01-21

     

       0
        
       
     

       579
        
         mupen64plus1_5 = mupen64plus; # added 2016-02-12

     

       580
        
         mx = throw "graalvm8 and its tools were deprecated in favor of graalvm8-ce"; # added 2021-10-15

     

       581
        
         mxisd = throw "mxisd has been removed from nixpkgs as it has reached end of life, see https://github.com/kamax-matrix/mxisd/blob/535e0a5b96ab63cb0ddef90f6f42c5866407df95/EOL.md#end-of-life-notice . ma1sd may be a suitable alternative."; # added 2021-04-15

···

       576
        
         mssys = ms-sys; # added 2015-12-13

     

       577
        
         mpv-with-scripts = self.wrapMpv self.mpv-unwrapped { }; # added 2020-05-22

     

       578
        
         multipath_tools = multipath-tools;  # added 2016-01-21

     

       579
       +
         mumsi = throw "mumsi has been removed from nixpkgs, as it's unmaintained and does not build anymore"; # added 2021-11-18

     

       580
        
         mupen64plus1_5 = mupen64plus; # added 2016-02-12

     

       581
        
         mx = throw "graalvm8 and its tools were deprecated in favor of graalvm8-ce"; # added 2021-10-15

     

       582
        
         mxisd = throw "mxisd has been removed from nixpkgs as it has reached end of life, see https://github.com/kamax-matrix/mxisd/blob/535e0a5b96ab63cb0ddef90f6f42c5866407df95/EOL.md#end-of-life-notice . ma1sd may be a suitable alternative."; # added 2021-04-15

+11 -7

pkgs/top-level/all-packages.nix

···

       4759
        
           inherit (darwin.apple_sdk.frameworks) Security;

     

       4760
        
         };

     

       4761
        
       

     

       4762
       -
         pax = callPackage ../tools/archivers/pax { };

     

       0
        
       
     

       0
        
       
     

       4763
        
       

     

       4764
        
         rage = callPackage ../tools/security/rage {

     

       4765
        
           inherit (darwin.apple_sdk.frameworks) Foundation Security;

     
···

       12912
        
           inherit (darwin.apple_sdk.frameworks) Security;

     

       12913
        
         };

     

       12914
        
       

     

       12915
       -
         devserver = callPackage ../development/tools/rust/devserver { };

     

       0
        
       
     

       0
        
       
     

       12916
        
       

     

       12917
        
         maturin = callPackage ../development/tools/rust/maturin {

     

       12918
        
           inherit (darwin.apple_sdk.frameworks) Security;

     
···

       18674
        
       

     

       18675
        
         mueval = callPackage ../development/tools/haskell/mueval { };

     

       18676
        
       

     

       18677
       -
         mumlib = callPackage ../development/libraries/mumlib { };

     

       18678
       -
       

     

       18679
        
         muparser = callPackage ../development/libraries/muparser {

     

       18680
        
           inherit (darwin.stubs) setfile;

     

       18681
        
         };

     
···

       20927
        
         morty = callPackage ../servers/web-apps/morty { };

     

       20928
        
       

     

       20929
        
         mullvad-vpn = callPackage ../applications/networking/mullvad-vpn { };

     

       20930
       -
       

     

       20931
       -
         mumsi = callPackage ../servers/mumsi { };

     

       20932
        
       

     

       20933
        
         mycorrhiza = callPackage ../servers/mycorrhiza { };

     

       20934
        
       

     
···

       27533
        
         pur = callPackage ../development/tools/pur { };

     

       27534
        
       

     

       27535
        
         purple-discord = callPackage ../applications/networking/instant-messengers/pidgin-plugins/purple-discord { };

     

       0
        
       
     

       0
        
       
     

       27536
        
       

     

       27537
        
         purple-hangouts = callPackage ../applications/networking/instant-messengers/pidgin-plugins/purple-hangouts { };

     

       27538
        
       

     
···

       32816
        
       

     

       32817
        
         qdl = callPackage ../tools/misc/qdl { };

     

       32818
        
       

     

       32819
       -
         rates = callPackage ../tools/misc/rates { };

     

       0
        
       
     

       0
        
       
     

       32820
        
       

     

       32821
        
         rargs = callPackage ../tools/misc/rargs { };

     

       32822

···

       4759
        
           inherit (darwin.apple_sdk.frameworks) Security;

     

       4760
        
         };

     

       4761
        
       

     

       4762
       +
         pax = callPackage ../tools/archivers/pax {

     

       4763
       +
           inherit (pkgs.darwin.apple_sdk.libs) utmp;

     

       4764
       +
         };

     

       4765
        
       

     

       4766
        
         rage = callPackage ../tools/security/rage {

     

       4767
        
           inherit (darwin.apple_sdk.frameworks) Foundation Security;

     
···

       12914
        
           inherit (darwin.apple_sdk.frameworks) Security;

     

       12915
        
         };

     

       12916
        
       

     

       12917
       +
         devserver = callPackage ../development/tools/rust/devserver {

     

       12918
       +
           inherit (darwin.apple_sdk.frameworks) CoreServices;

     

       12919
       +
         };

     

       12920
        
       

     

       12921
        
         maturin = callPackage ../development/tools/rust/maturin {

     

       12922
        
           inherit (darwin.apple_sdk.frameworks) Security;

     
···

       18678
        
       

     

       18679
        
         mueval = callPackage ../development/tools/haskell/mueval { };

     

       18680
        
       

     

       0
        
       
     

       0
        
       
     

       18681
        
         muparser = callPackage ../development/libraries/muparser {

     

       18682
        
           inherit (darwin.stubs) setfile;

     

       18683
        
         };

     
···

       20929
        
         morty = callPackage ../servers/web-apps/morty { };

     

       20930
        
       

     

       20931
        
         mullvad-vpn = callPackage ../applications/networking/mullvad-vpn { };

     

       0
        
       
     

       0
        
       
     

       20932
        
       

     

       20933
        
         mycorrhiza = callPackage ../servers/mycorrhiza { };

     

       20934
        
       

     
···

       27533
        
         pur = callPackage ../development/tools/pur { };

     

       27534
        
       

     

       27535
        
         purple-discord = callPackage ../applications/networking/instant-messengers/pidgin-plugins/purple-discord { };

     

       27536
       +
       

     

       27537
       +
         purple-googlechat = callPackage ../applications/networking/instant-messengers/pidgin-plugins/purple-googlechat { };

     

       27538
        
       

     

       27539
        
         purple-hangouts = callPackage ../applications/networking/instant-messengers/pidgin-plugins/purple-hangouts { };

     

       27540
        
       

     
···

       32818
        
       

     

       32819
        
         qdl = callPackage ../tools/misc/qdl { };

     

       32820
        
       

     

       32821
       +
         rates = callPackage ../tools/misc/rates {

     

       32822
       +
           inherit (darwin.apple_sdk.frameworks) Security;

     

       32823
       +
         };

     

       32824
        
       

     

       32825
        
         rargs = callPackage ../tools/misc/rargs { };

     

       32826

+1 -1

pkgs/top-level/haskell-packages.nix

···

       128
        
             llvmPackages = pkgs.llvmPackages_10;

     

       129
        
           };

     

       130
        
           ghcHEAD = callPackage ../development/compilers/ghc/head.nix {

     

       131
       -
             bootPkgs = packages.ghc901; # no binary yet

     

       132
        
             inherit (buildPackages.python3Packages) sphinx;

     

       133
        
             # Need to use apple's patched xattr until

     

       134
        
             # https://github.com/xattr/xattr/issues/44 and

···

       128
        
             llvmPackages = pkgs.llvmPackages_10;

     

       129
        
           };

     

       130
        
           ghcHEAD = callPackage ../development/compilers/ghc/head.nix {

     

       131
       +
             bootPkgs = packages.ghc8107Binary;

     

       132
        
             inherit (buildPackages.python3Packages) sphinx;

     

       133
        
             # Need to use apple's patched xattr until

     

       134
        
             # https://github.com/xattr/xattr/issues/44 and

+7 -1

pkgs/top-level/python-packages.nix

···

       5106
        
       

     

       5107
        
         Nikola = callPackage ../development/python-modules/Nikola { };

     

       5108
        
       

     

       0
        
       
     

       0
        
       
     

       5109
        
         nilearn = callPackage ../development/python-modules/nilearn { };

     

       5110
        
       

     

       5111
        
         niluclient = callPackage ../development/python-modules/niluclient { };

     
···

       6397
        
         pyerfa = callPackage ../development/python-modules/pyerfa { };

     

       6398
        
       

     

       6399
        
         pyevmasm = callPackage ../development/python-modules/pyevmasm { };

     

       0
        
       
     

       0
        
       
     

       6400
        
       

     

       6401
        
         pyexcel = callPackage ../development/python-modules/pyexcel { };

     

       6402
        
       

     
···

       8434
        
       

     

       8435
        
         scikit-survival = callPackage ../development/python-modules/scikit-survival { };

     

       8436
        
       

     

       8437
       -
         scs = callPackage ../development/python-modules/scs { scs = pkgs.scs; };

     

       8438
        
       

     

       8439
        
         sdnotify = callPackage ../development/python-modules/sdnotify { };

     

       8440
        
       

     
···

       9653
        
         uproot3-methods = callPackage ../development/python-modules/uproot3-methods { };

     

       9654
        
       

     

       9655
        
         uptime = callPackage ../development/python-modules/uptime { };

     

       0
        
       
     

       0
        
       
     

       9656
        
       

     

       9657
        
         uranium = callPackage ../development/python-modules/uranium { };

     

       9658

···

       5106
        
       

     

       5107
        
         Nikola = callPackage ../development/python-modules/Nikola { };

     

       5108
        
       

     

       5109
       +
         niko-home-control = callPackage ../development/python-modules/niko-home-control { };

     

       5110
       +
       

     

       5111
        
         nilearn = callPackage ../development/python-modules/nilearn { };

     

       5112
        
       

     

       5113
        
         niluclient = callPackage ../development/python-modules/niluclient { };

     
···

       6399
        
         pyerfa = callPackage ../development/python-modules/pyerfa { };

     

       6400
        
       

     

       6401
        
         pyevmasm = callPackage ../development/python-modules/pyevmasm { };

     

       6402
       +
       

     

       6403
       +
         pyevilgenius = callPackage ../development/python-modules/pyevilgenius { };

     

       6404
        
       

     

       6405
        
         pyexcel = callPackage ../development/python-modules/pyexcel { };

     

       6406
        
       

     
···

       8438
        
       

     

       8439
        
         scikit-survival = callPackage ../development/python-modules/scikit-survival { };

     

       8440
        
       

     

       8441
       +
         scs = callPackage ../development/python-modules/scs { };

     

       8442
        
       

     

       8443
        
         sdnotify = callPackage ../development/python-modules/sdnotify { };

     

       8444
        
       

     
···

       9657
        
         uproot3-methods = callPackage ../development/python-modules/uproot3-methods { };

     

       9658
        
       

     

       9659
        
         uptime = callPackage ../development/python-modules/uptime { };

     

       9660
       +
       

     

       9661
       +
         uptime-kuma-monitor = callPackage ../development/python-modules/uptime-kuma-monitor { };

     

       9662
        
       

     

       9663
        
         uranium = callPackage ../development/python-modules/uranium { };

     

       9664