commit ef6416a6ba776e2cbbe49b443e030c8d8a6fe441 · pyrox.dev/nixpkgs

nixos/doc/manual/release-notes/rl-2105.xml

···

       703
       703
        
              <literal>skip-kernel-setup true</literal> and takes care of setting forwarding and rp_filter sysctls by itself as well

     

       704
       704
        
              as for each interface in <varname>services.babeld.interfaces</varname>.

     

       705
       705
        
            </para>

     

       706
       706
       +
           </listitem>

     

       707
       707
       +
          <listitem>

     

       708
       708
       +
            <para>

     

       709
       709
       +
             The <option>services.zigbee2mqtt.config</option> option has been renamed to <option>services.zigbee2mqtt.settings</option> and

     

       710
       710
       +
             now follows <link xlink:href="https://github.com/NixOS/rfcs/blob/master/rfcs/0042-config-option.md">RFC 0042</link>.

     

       711
       711
       +
            </para>

     

       706
       712
        
          </listitem>

     

       707
       713
        
         </itemizedlist>

     

       708
       714
        
        </section>

nixos/modules/module-list.nix

···

       631
       631
        
         ./services/network-filesystems/xtreemfs.nix

     

       632
       632
        
         ./services/network-filesystems/ceph.nix

     

       633
       633
        
         ./services/networking/3proxy.nix

     

       634
       634
       +
         ./services/networking/adguardhome.nix

     

       634
       635
        
         ./services/networking/amuled.nix

     

       635
       636
        
         ./services/networking/aria2.nix

     

       636
       637
        
         ./services/networking/asterisk.nix

+71 -25

nixos/modules/services/misc/zigbee2mqtt.nix

···

       5
       5
        
       let

     

       6
       6
        
         cfg = config.services.zigbee2mqtt;

     

       7
       7
        
       

     

       8
       8
       -
         configJSON = pkgs.writeText "configuration.json"

     

       9
       9
       -
           (builtins.toJSON (recursiveUpdate defaultConfig cfg.config));

     

       10
       10
       -
         configFile = pkgs.runCommand "configuration.yaml" { preferLocalBuild = true; } ''

     

       11
       11
       -
           ${pkgs.remarshal}/bin/json2yaml -i ${configJSON} -o $out

     

       12
       12
       -
         '';

     

       8
       8
       +
         format = pkgs.formats.yaml { };

     

       9
       9
       +
         configFile = format.generate "zigbee2mqtt.yaml" cfg.settings;

     

       13
       10
        
       

     

       14
       14
       -
         # the default config contains all required settings,

     

       15
       15
       -
         # so the service starts up without crashing.

     

       16
       16
       -
         defaultConfig = {

     

       17
       17
       -
           homeassistant = false;

     

       18
       18
       -
           permit_join = false;

     

       19
       19
       -
           mqtt = {

     

       20
       20
       -
             base_topic = "zigbee2mqtt";

     

       21
       21
       -
             server = "mqtt://localhost:1883";

     

       22
       22
       -
           };

     

       23
       23
       -
           serial.port = "/dev/ttyACM0";

     

       24
       24
       -
           # put device configuration into separate file because configuration.yaml

     

       25
       25
       -
           # is copied from the store on startup

     

       26
       26
       -
           devices = "devices.yaml";

     

       27
       27
       -
         };

     

       28
       11
        
       in

     

       29
       12
        
       {

     

       30
       30
       -
         meta.maintainers = with maintainers; [ sweber ];

     

       13
       13
       +
         meta.maintainers = with maintainers; [ sweber hexa ];

     

       14
       14
       +
       

     

       15
       15
       +
         imports = [

     

       16
       16
       +
           # Remove warning before the 21.11 release

     

       17
       17
       +
           (mkRenamedOptionModule [ "services" "zigbee2mqtt" "config" ] [ "services" "zigbee2mqtt" "settings" ])

     

       18
       18
       +
         ];

     

       31
       19
        
       

     

       32
       20
        
         options.services.zigbee2mqtt = {

     

       33
       21
        
           enable = mkEnableOption "enable zigbee2mqtt service";

     
···

       37
       25
        
             default = pkgs.zigbee2mqtt.override {

     

       38
       26
        
               dataDir = cfg.dataDir;

     

       39
       27
        
             };

     

       40
       40
       -
             defaultText = "pkgs.zigbee2mqtt";

     

       28
       28
       +
             defaultText = literalExample ''

     

       29
       29
       +
               pkgs.zigbee2mqtt {

     

       30
       30
       +
                 dataDir = services.zigbee2mqtt.dataDir

     

       31
       31
       +
               }

     

       32
       32
       +
             '';

     

       41
       33
        
             type = types.package;

     

       42
       34
        
           };

     

       43
       35
        
       

     
···

       47
       39
        
             type = types.path;

     

       48
       40
        
           };

     

       49
       41
        
       

     

       50
       50
       -
           config = mkOption {

     

       42
       42
       +
           settings = mkOption {

     

       43
       43
       +
             type = format.type;

     

       51
       44
        
             default = {};

     

       52
       52
       -
             type = with types; nullOr attrs;

     

       53
       45
        
             example = literalExample ''

     

       54
       46
        
               {

     

       55
       47
        
                 homeassistant = config.services.home-assistant.enable;

     
···

       61
       53
        
             '';

     

       62
       54
        
             description = ''

     

       63
       55
        
               Your <filename>configuration.yaml</filename> as a Nix attribute set.

     

       56
       56
       +
               Check the <link xlink:href="https://www.zigbee2mqtt.io/information/configuration.html">documentation</link>

     

       57
       57
       +
               for possible options.

     

       64
       58
        
             '';

     

       65
       59
        
           };

     

       66
       60
        
         };

     

       67
       61
        
       

     

       68
       62
        
         config = mkIf (cfg.enable) {

     

       63
       63
       +
       

     

       64
       64
       +
           # preset config values

     

       65
       65
       +
           services.zigbee2mqtt.settings = {

     

       66
       66
       +
             homeassistant = mkDefault config.services.home-assistant.enable;

     

       67
       67
       +
             permit_join = mkDefault false;

     

       68
       68
       +
             mqtt = {

     

       69
       69
       +
               base_topic = mkDefault "zigbee2mqtt";

     

       70
       70
       +
               server = mkDefault "mqtt://localhost:1883";

     

       71
       71
       +
             };

     

       72
       72
       +
             serial.port = mkDefault "/dev/ttyACM0";

     

       73
       73
       +
             # reference device configuration, that is kept in a separate file

     

       74
       74
       +
             # to prevent it being overwritten in the units ExecStartPre script

     

       75
       75
       +
             devices = mkDefault "devices.yaml";

     

       76
       76
       +
           };

     

       77
       77
       +
       

     

       69
       78
        
           systemd.services.zigbee2mqtt = {

     

       70
       79
        
             description = "Zigbee2mqtt Service";

     

       71
       80
        
             wantedBy = [ "multi-user.target" ];

     
···

       76
       85
        
               User = "zigbee2mqtt";

     

       77
       86
        
               WorkingDirectory = cfg.dataDir;

     

       78
       87
        
               Restart = "on-failure";

     

       88
       88
       +
       

     

       89
       89
       +
               # Hardening

     

       90
       90
       +
               CapabilityBoundingSet = "";

     

       91
       91
       +
               DeviceAllow = [

     

       92
       92
       +
                 config.services.zigbee2mqtt.settings.serial.port

     

       93
       93
       +
               ];

     

       94
       94
       +
               DevicePolicy = "closed";

     

       95
       95
       +
               LockPersonality = true;

     

       96
       96
       +
               MemoryDenyWriteExecute = false;

     

       97
       97
       +
               NoNewPrivileges = true;

     

       98
       98
       +
               PrivateDevices = false; # prevents access to /dev/serial, because it is set 0700 root:root

     

       99
       99
       +
               PrivateUsers = true;

     

       100
       100
       +
               PrivateTmp = true;

     

       101
       101
       +
               ProtectClock = true;

     

       102
       102
       +
               ProtectControlGroups = true;

     

       103
       103
       +
               ProtectHome = true;

     

       104
       104
       +
               ProtectHostname = true;

     

       105
       105
       +
               ProtectKernelLogs = true;

     

       106
       106
       +
               ProtectKernelModules = true;

     

       107
       107
       +
               ProtectKernelTunables = true;

     

       108
       108
       +
               ProtectProc = "invisible";

     

       109
       109
       +
               ProcSubset = "pid";

     

       79
       110
        
               ProtectSystem = "strict";

     

       80
       111
        
               ReadWritePaths = cfg.dataDir;

     

       81
       81
       -
               PrivateTmp = true;

     

       82
       112
        
               RemoveIPC = true;

     

       113
       113
       +
               RestrictAddressFamilies = [

     

       114
       114
       +
                 "AF_INET"

     

       115
       115
       +
                 "AF_INET6"

     

       116
       116
       +
               ];

     

       117
       117
       +
               RestrictNamespaces = true;

     

       118
       118
       +
               RestrictRealtime = true;

     

       119
       119
       +
               RestrictSUIDSGID = true;

     

       120
       120
       +
               SupplementaryGroups = [

     

       121
       121
       +
                 "dialout"

     

       122
       122
       +
               ];

     

       123
       123
       +
               SystemCallArchitectures = "native";

     

       124
       124
       +
               SystemCallFilter = [

     

       125
       125
       +
                 "@system-service"

     

       126
       126
       +
                 "~@privileged"

     

       127
       127
       +
                 "~@resources"

     

       128
       128
       +
               ];

     

       129
       129
       +
               UMask = "0077";

     

       83
       130
        
             };

     

       84
       131
        
             preStart = ''

     

       85
       132
        
               cp --no-preserve=mode ${configFile} "${cfg.dataDir}/configuration.yaml"

     
···

       90
       137
        
             home = cfg.dataDir;

     

       91
       138
        
             createHome = true;

     

       92
       139
        
             group = "zigbee2mqtt";

     

       93
       93
       -
             extraGroups = [ "dialout" ];

     

       94
       140
        
             uid = config.ids.uids.zigbee2mqtt;

     

       95
       141
        
           };

     

       96
       142

+78

nixos/modules/services/networking/adguardhome.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.adguardhome;

     

       7
       7
       +
       

     

       8
       8
       +
         args = concatStringsSep " " ([

     

       9
       9
       +
           "--no-check-update"

     

       10
       10
       +
           "--pidfile /run/AdGuardHome/AdGuardHome.pid"

     

       11
       11
       +
           "--work-dir /var/lib/AdGuardHome/"

     

       12
       12
       +
           "--config /var/lib/AdGuardHome/AdGuardHome.yaml"

     

       13
       13
       +
           "--host ${cfg.host}"

     

       14
       14
       +
           "--port ${toString cfg.port}"

     

       15
       15
       +
         ] ++ cfg.extraArgs);

     

       16
       16
       +
       

     

       17
       17
       +
       in

     

       18
       18
       +
       {

     

       19
       19
       +
         options.services.adguardhome = with types; {

     

       20
       20
       +
           enable = mkEnableOption "AdGuard Home network-wide ad blocker";

     

       21
       21
       +
       

     

       22
       22
       +
           host = mkOption {

     

       23
       23
       +
             default = "0.0.0.0";

     

       24
       24
       +
             type = str;

     

       25
       25
       +
             description = ''

     

       26
       26
       +
               Host address to bind HTTP server to.

     

       27
       27
       +
             '';

     

       28
       28
       +
           };

     

       29
       29
       +
       

     

       30
       30
       +
           port = mkOption {

     

       31
       31
       +
             default = 3000;

     

       32
       32
       +
             type = port;

     

       33
       33
       +
             description = ''

     

       34
       34
       +
               Port to serve HTTP pages on.

     

       35
       35
       +
             '';

     

       36
       36
       +
           };

     

       37
       37
       +
       

     

       38
       38
       +
           openFirewall = mkOption {

     

       39
       39
       +
             default = false;

     

       40
       40
       +
             type = bool;

     

       41
       41
       +
             description = ''

     

       42
       42
       +
               Open ports in the firewall for the AdGuard Home web interface. Does not

     

       43
       43
       +
               open the port needed to access the DNS resolver.

     

       44
       44
       +
             '';

     

       45
       45
       +
           };

     

       46
       46
       +
       

     

       47
       47
       +
           extraArgs = mkOption {

     

       48
       48
       +
             default = [ ];

     

       49
       49
       +
             type = listOf str;

     

       50
       50
       +
             description = ''

     

       51
       51
       +
               Extra command line parameters to be passed to the adguardhome binary.

     

       52
       52
       +
             '';

     

       53
       53
       +
           };

     

       54
       54
       +
         };

     

       55
       55
       +
       

     

       56
       56
       +
         config = mkIf cfg.enable {

     

       57
       57
       +
           systemd.services.adguardhome = {

     

       58
       58
       +
             description = "AdGuard Home: Network-level blocker";

     

       59
       59
       +
             after = [ "syslog.target" "network.target" ];

     

       60
       60
       +
             wantedBy = [ "multi-user.target" ];

     

       61
       61
       +
             unitConfig = {

     

       62
       62
       +
               StartLimitIntervalSec = 5;

     

       63
       63
       +
               StartLimitBurst = 10;

     

       64
       64
       +
             };

     

       65
       65
       +
             serviceConfig = {

     

       66
       66
       +
               DynamicUser = true;

     

       67
       67
       +
               ExecStart = "${pkgs.adguardhome}/bin/adguardhome ${args}";

     

       68
       68
       +
               AmbientCapabilities = [ "CAP_NET_BIND_SERVICE" ];

     

       69
       69
       +
               Restart = "always";

     

       70
       70
       +
               RestartSec = 10;

     

       71
       71
       +
               RuntimeDirectory = "AdGuardHome";

     

       72
       72
       +
               StateDirectory = "AdGuardHome";

     

       73
       73
       +
             };

     

       74
       74
       +
           };

     

       75
       75
       +
       

     

       76
       76
       +
           networking.firewall.allowedTCPPorts = mkIf cfg.openFirewall [ cfg.port ];

     

       77
       77
       +
         };

     

       78
       78
       +
       }

+11 -1

nixos/modules/services/web-servers/nginx/default.nix

···

       819
       819
        
               # Logs directory and mode

     

       820
       820
        
               LogsDirectory = "nginx";

     

       821
       821
        
               LogsDirectoryMode = "0750";

     

       822
       822
       +
               # Proc filesystem

     

       823
       823
       +
               ProcSubset = "pid";

     

       824
       824
       +
               ProtectProc = "invisible";

     

       825
       825
       +
               # New file permissions

     

       826
       826
       +
               UMask = "0027"; # 0640 / 0750

     

       822
       827
        
               # Capabilities

     

       823
       828
        
               AmbientCapabilities = [ "CAP_NET_BIND_SERVICE" "CAP_SYS_RESOURCE" ];

     

       824
       829
        
               CapabilityBoundingSet = [ "CAP_NET_BIND_SERVICE" "CAP_SYS_RESOURCE" ];

     

       825
       830
        
               # Security

     

       826
       831
        
               NoNewPrivileges = true;

     

       827
       827
       -
               # Sandboxing

     

       832
       832
       +
               # Sandboxing (sorted by occurrence in https://www.freedesktop.org/software/systemd/man/systemd.exec.html)

     

       828
       833
        
               ProtectSystem = "strict";

     

       829
       834
        
               ProtectHome = mkDefault true;

     

       830
       835
        
               PrivateTmp = true;

     

       831
       836
        
               PrivateDevices = true;

     

       832
       837
        
               ProtectHostname = true;

     

       838
       838
       +
               ProtectClock = true;

     

       833
       839
        
               ProtectKernelTunables = true;

     

       834
       840
        
               ProtectKernelModules = true;

     

       841
       841
       +
               ProtectKernelLogs = true;

     

       835
       842
        
               ProtectControlGroups = true;

     

       836
       843
        
               RestrictAddressFamilies = [ "AF_UNIX" "AF_INET" "AF_INET6" ];

     

       844
       844
       +
               RestrictNamespaces = true;

     

       837
       845
        
               LockPersonality = true;

     

       838
       846
        
               MemoryDenyWriteExecute = !(builtins.any (mod: (mod.allowMemoryWriteExecute or false)) cfg.package.modules);

     

       839
       847
        
               RestrictRealtime = true;

     

       840
       848
        
               RestrictSUIDSGID = true;

     

       849
       849
       +
               RemoveIPC = true;

     

       841
       850
        
               PrivateMounts = true;

     

       842
       851
        
               # System Call Filtering

     

       843
       852
        
               SystemCallArchitectures = "native";

     

       853
       853
       +
               SystemCallFilter = "~@chown @cpu-emulation @debug @keyring @ipc @module @mount @obsolete @privileged @raw-io @reboot @setuid @swap";

     

       844
       854
        
             };

     

       845
       855
        
           };

     

       846
       856

+17 -11

nixos/modules/virtualisation/nixos-containers.nix

···

       35
       35
        
             ''

     

       36
       36
        
               #! ${pkgs.runtimeShell} -e

     

       37
       37
        
       

     

       38
       38
       +
               # Exit early if we're asked to shut down.

     

       39
       39
       +
               trap "exit 0" SIGRTMIN+3

     

       40
       40
       +
       

     

       38
       41
        
               # Initialise the container side of the veth pair.

     

       39
       42
        
               if [ -n "$HOST_ADDRESS" ]   || [ -n "$HOST_ADDRESS6" ]  ||

     

       40
       43
        
                  [ -n "$LOCAL_ADDRESS" ]  || [ -n "$LOCAL_ADDRESS6" ] ||

     
···

       60
       63
        
       

     

       61
       64
        
               ${concatStringsSep "\n" (mapAttrsToList renderExtraVeth cfg.extraVeths)}

     

       62
       65
        
       

     

       63
       63
       -
               # Start the regular stage 1 script.

     

       64
       64
       -
               exec "$1"

     

       66
       66
       +
               # Start the regular stage 2 script.

     

       67
       67
       +
               # We source instead of exec to not lose an early stop signal, which is

     

       68
       68
       +
               # also the only _reliable_ shutdown signal we have since early stop

     

       69
       69
       +
               # does not execute ExecStop* commands.

     

       70
       70
       +
               set +e

     

       71
       71
       +
               . "$1"

     

       65
       72
        
             ''

     

       66
       73
        
           );

     

       67
       74
        
       

     
···

       127
       134
        
             ''}

     

       128
       135
        
       

     

       129
       136
        
             # Run systemd-nspawn without startup notification (we'll

     

       130
       130
       -
             # wait for the container systemd to signal readiness).

     

       137
       137
       +
             # wait for the container systemd to signal readiness)

     

       138
       138
       +
             # Kill signal handling means systemd-nspawn will pass a system-halt signal

     

       139
       139
       +
             # to the container systemd when it receives SIGTERM for container shutdown;

     

       140
       140
       +
             # containerInit and stage2 have to handle this as well.

     

       131
       141
        
             exec ${config.systemd.package}/bin/systemd-nspawn \

     

       132
       142
        
               --keep-unit \

     

       133
       143
        
               -M "$INSTANCE" -D "$root" $extraFlags \

     

       134
       144
        
               $EXTRA_NSPAWN_FLAGS \

     

       135
       145
        
               --notify-ready=yes \

     

       146
       146
       +
               --kill-signal=SIGRTMIN+3 \

     

       136
       147
        
               --bind-ro=/nix/store \

     

       137
       148
        
               --bind-ro=/nix/var/nix/db \

     

       138
       149
        
               --bind-ro=/nix/var/nix/daemon-socket \

     
···

       259
       270
        
           Slice = "machine.slice";

     

       260
       271
        
           Delegate = true;

     

       261
       272
        
       

     

       262
       262
       -
           # Hack: we don't want to kill systemd-nspawn, since we call

     

       263
       263
       -
           # "machinectl poweroff" in preStop to shut down the

     

       264
       264
       -
           # container cleanly. But systemd requires sending a signal

     

       265
       265
       -
           # (at least if we want remaining processes to be killed

     

       266
       266
       -
           # after the timeout). So send an ignored signal.

     

       273
       273
       +
           # We rely on systemd-nspawn turning a SIGTERM to itself into a shutdown

     

       274
       274
       +
           # signal (SIGRTMIN+3) for the inner container.

     

       267
       275
        
           KillMode = "mixed";

     

       268
       268
       -
           KillSignal = "WINCH";

     

       276
       276
       +
           KillSignal = "TERM";

     

       269
       277
        
       

     

       270
       278
        
           DevicePolicy = "closed";

     

       271
       279
        
           DeviceAllow = map (d: "${d.node} ${d.modifier}") cfg.allowedDevices;

     
···

       746
       754
        
             script = startScript dummyConfig;

     

       747
       755
        
       

     

       748
       756
        
             postStart = postStartScript dummyConfig;

     

       749
       749
       -
       

     

       750
       750
       -
             preStop = "machinectl poweroff $INSTANCE";

     

       751
       757
        
       

     

       752
       758
        
             restartIfChanged = false;

     

       753
       759

+20

nixos/tests/containers-imperative.nix

···

       111
       111
        
                 machine.succeed(f"nixos-container stop {id1}")

     

       112
       112
        
                 machine.succeed(f"nixos-container start {id1}")

     

       113
       113
        
       

     

       114
       114
       +
             # clear serial backlog for next tests

     

       115
       115
       +
             machine.succeed("logger eat console backlog 3ea46eb2-7f82-4f70-b810-3f00e3dd4c4d")

     

       116
       116
       +
             machine.wait_for_console_text(

     

       117
       117
       +
                 "eat console backlog 3ea46eb2-7f82-4f70-b810-3f00e3dd4c4d"

     

       118
       118
       +
             )

     

       119
       119
       +
       

     

       120
       120
       +
             with subtest("Stop a container early"):

     

       121
       121
       +
                 machine.succeed(f"nixos-container stop {id1}")

     

       122
       122
       +
                 machine.succeed(f"nixos-container start {id1} &")

     

       123
       123
       +
                 machine.wait_for_console_text("Stage 2")

     

       124
       124
       +
                 machine.succeed(f"nixos-container stop {id1}")

     

       125
       125
       +
                 machine.wait_for_console_text(f"Container {id1} exited successfully")

     

       126
       126
       +
                 machine.succeed(f"nixos-container start {id1}")

     

       127
       127
       +
       

     

       128
       128
       +
             with subtest("Stop a container without machined (regression test for #109695)"):

     

       129
       129
       +
                 machine.systemctl("stop systemd-machined")

     

       130
       130
       +
                 machine.succeed(f"nixos-container stop {id1}")

     

       131
       131
       +
                 machine.wait_for_console_text(f"Container {id1} has been shut down")

     

       132
       132
       +
                 machine.succeed(f"nixos-container start {id1}")

     

       133
       133
       +
       

     

       114
       134
        
             with subtest("tmpfiles are present"):

     

       115
       135
        
                 machine.log("creating container tmpfiles")

     

       116
       136
        
                 machine.succeed(

+5 -1

nixos/tests/zigbee2mqtt.nix

···

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

     

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

     

       2
       2
        
       

     

       3
       3
        
         {

     

       4
       4
        
           machine = { pkgs, ... }:

     
···

       6
       6
        
               services.zigbee2mqtt = {

     

       7
       7
        
                 enable = true;

     

       8
       8
        
               };

     

       9
       9
       +
       

     

       10
       10
       +
               systemd.services.zigbee2mqtt.serviceConfig.DevicePolicy = lib.mkForce "auto";

     

       9
       11
        
             };

     

       10
       12
        
       

     

       11
       13
        
           testScript = ''

     
···

       14
       16
        
             machine.succeed(

     

       15
       17
        
                 "journalctl -eu zigbee2mqtt | grep \"Error: Error while opening serialport 'Error: Error: No such file or directory, cannot open /dev/ttyACM0'\""

     

       16
       18
        
             )

     

       19
       19
       +
       

     

       20
       20
       +
             machine.log(machine.succeed("systemd-analyze security zigbee2mqtt.service"))

     

       17
       21
        
           '';

     

       18
       22
        
         }

     

       19
       23
        
       )

+8 -8

pkgs/applications/audio/kid3/default.nix

···

       6
       6
        
       , cmake

     

       7
       7
        
       , docbook_xml_dtd_45

     

       8
       8
        
       , docbook_xsl

     

       9
       9
       -
       , ffmpeg_3

     

       9
       9
       +
       , ffmpeg

     

       10
       10
        
       , flac

     

       11
       11
        
       , id3lib

     

       12
       12
        
       , libogg

     
···

       31
       31
        
         version = "3.8.6";

     

       32
       32
        
       

     

       33
       33
        
         src = fetchurl {

     

       34
       34
       -
           url = "mirror://sourceforge/project/kid3/kid3/${version}/${pname}-${version}.tar.gz";

     

       35
       35
       -
           sha256 = "sha256-ce+MWCJzAnN+u+07f0dvn0jnbqiUlS2RbcM9nAj5bgg=";

     

       34
       34
       +
           url = "https://download.kde.org/stable/${pname}/${version}/${pname}-${version}.tar.xz";

     

       35
       35
       +
           hash = "sha256-R4gAWlCw8RezhYbw1XDo+wdp797IbLoM3wqHwr+ul6k=";

     

       36
       36
        
         };

     

       37
       37
        
       

     

       38
       38
        
         nativeBuildInputs = [

     

       39
       39
        
           cmake

     

       40
       40
       +
           docbook_xml_dtd_45

     

       41
       41
       +
           docbook_xsl

     

       40
       42
        
           pkg-config

     

       43
       43
       +
           python3

     

       41
       44
        
           wrapQtAppsHook

     

       42
       45
        
         ];

     

       43
       46
        
         buildInputs = [

     

       44
       47
        
           automoc4

     

       45
       48
        
           chromaprint

     

       46
       46
       -
           docbook_xml_dtd_45

     

       47
       47
       -
           docbook_xsl

     

       48
       48
       -
           ffmpeg_3

     

       49
       49
       +
           ffmpeg

     

       49
       50
        
           flac

     

       50
       51
        
           id3lib

     

       51
       52
        
           libogg

     
···

       53
       54
        
           libxslt

     

       54
       55
        
           mp4v2

     

       55
       56
        
           phonon

     

       56
       56
       -
           python3

     

       57
       57
        
           qtbase

     

       58
       58
        
           qtmultimedia

     

       59
       59
        
           qtquickcontrols

     
···

       71
       71
        
         '';

     

       72
       72
        
       

     

       73
       73
        
         meta = with lib; {

     

       74
       74
       +
           homepage = "https://kid3.kde.org/";

     

       74
       75
        
           description = "A simple and powerful audio tag editor";

     

       75
       76
        
           longDescription = ''

     

       76
       77
        
             If you want to easily tag multiple MP3, Ogg/Vorbis, FLAC, MPC, MP4/AAC,

     
···

       101
       102
        
             - Edit synchronized lyrics and event timing codes, import and export

     

       102
       103
        
               LRC files.

     

       103
       104
        
           '';

     

       104
       104
       -
           homepage = "http://kid3.sourceforge.net/";

     

       105
       105
        
           license = licenses.lgpl2Plus;

     

       106
       106
        
           maintainers = [ maintainers.AndersonTorres ];

     

       107
       107
        
           platforms = platforms.linux;

+2 -2

pkgs/applications/audio/quodlibet/default.nix

···

       1
       1
        
       { lib, stdenv, fetchurl, python3, wrapGAppsHook, gettext, libsoup, gnome3, gtk3, gdk-pixbuf, librsvg,

     

       2
       2
        
         tag ? "", xvfb_run, dbus, glibcLocales, glib, glib-networking, gobject-introspection, hicolor-icon-theme,

     

       3
       3
        
         gst_all_1, withGstPlugins ? true,

     

       4
       4
       -
         xineBackend ? false, xineLib,

     

       4
       4
       +
         xineBackend ? false, xine-lib,

     

       5
       5
        
         withDbusPython ? false, withPyInotify ? false, withMusicBrainzNgs ? false, withPahoMqtt ? false,

     

       6
       6
        
         webkitgtk ? null,

     

       7
       7
        
         keybinder3 ? null, gtksourceview ? null, libmodplug ? null, kakasi ? null, libappindicator-gtk3 ? null }:

     
···

       23
       23
        
         checkInputs = [ gdk-pixbuf hicolor-icon-theme ] ++ (with python3.pkgs; [ pytest pytest_xdist polib xvfb_run dbus.daemon glibcLocales ]);

     

       24
       24
        
       

     

       25
       25
        
         buildInputs = [ gnome3.adwaita-icon-theme libsoup glib glib-networking gtk3 webkitgtk gdk-pixbuf keybinder3 gtksourceview libmodplug libappindicator-gtk3 kakasi gobject-introspection ]

     

       26
       26
       -
           ++ (if xineBackend then [ xineLib ] else with gst_all_1;

     

       26
       26
       +
           ++ (if xineBackend then [ xine-lib ] else with gst_all_1;

     

       27
       27
        
           [ gstreamer gst-plugins-base ] ++ optionals withGstPlugins [ gst-plugins-good gst-plugins-ugly gst-plugins-bad ]);

     

       28
       28
        
       

     

       29
       29
        
         propagatedBuildInputs = with python3.pkgs; [ pygobject3 pycairo mutagen gst-python feedparser ]

+3 -3

pkgs/applications/misc/eaglemode/default.nix

···

       1
       1
        
       { lib, stdenv, fetchurl, perl, libX11, libXinerama, libjpeg, libpng, libtiff, pkg-config,

     

       2
       2
       -
       librsvg, glib, gtk2, libXext, libXxf86vm, poppler, xineLib, ghostscript, makeWrapper }:

     

       2
       2
       +
       librsvg, glib, gtk2, libXext, libXxf86vm, poppler, xine-lib, ghostscript, makeWrapper }:

     

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         pname = "eaglemode";

     
···

       12
       12
        
       

     

       13
       13
        
         nativeBuildInputs = [ pkg-config ];

     

       14
       14
        
         buildInputs = [ perl libX11 libXinerama libjpeg libpng libtiff

     

       15
       15
       -
           librsvg glib gtk2 libXxf86vm libXext poppler xineLib ghostscript makeWrapper ];

     

       15
       15
       +
           librsvg glib gtk2 libXxf86vm libXext poppler xine-lib ghostscript makeWrapper ];

     

       16
       16
        
       

     

       17
       17
        
         # The program tries to dlopen Xxf86vm, Xext and Xinerama, so we use the

     

       18
       18
        
         # trick on NIX_LDFLAGS and dontPatchELF to make it find them.

     

       19
       19
       -
         # I use 'yes y' to skip a build error linking with xineLib,

     

       19
       19
       +
         # I use 'yes y' to skip a build error linking with xine-lib,

     

       20
       20
        
         # because xine stopped exporting "_x_vo_new_port"

     

       21
       21
        
         #  https://sourceforge.net/projects/eaglemode/forums/forum/808824/topic/5115261

     

       22
       22
        
         buildPhase = ''

+3 -3

pkgs/applications/networking/sync/rclone/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "rclone";

     

       8
       8
       -
         version = "1.55.0";

     

       8
       8
       +
         version = "1.55.1";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = pname;

     

       12
       12
        
           repo = pname;

     

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

     

       14
       14
       -
           sha256 = "01pvcns3n735s848wc11q40pkkv646gn3cxkma866k44a9c2wirl";

     

       14
       14
       +
           sha256 = "1fyi12qz2igcf9rqsp9gmcgfnmgy4g04s2b03b95ml6klbf73cns";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         vendorSha256 = "05f9nx5sa35q2szfkmnkhvqli8jlqja8ghiwyxk7cvgjl7fgd6zk";

     

       17
       17
       +
         vendorSha256 = "199z3j62xw9h8yviyv4jfls29y2ri9511hcyp5ix8ahgk6ypz8vw";

     

       18
       18
        
       

     

       19
       19
        
         subPackages = [ "." ];

     

       20
       20

+47 -43

pkgs/applications/video/aegisub/default.nix

···

       3
       3
        
       , stdenv

     

       4
       4
        
       , fetchurl

     

       5
       5
        
       , fetchpatch

     

       6
       6
       -
       , libX11

     

       7
       7
       -
       , wxGTK

     

       8
       8
       -
       , libiconv

     

       6
       6
       +
       , boost

     

       7
       7
       +
       , ffmpeg

     

       8
       8
       +
       , ffms

     

       9
       9
       +
       , fftw

     

       9
       10
        
       , fontconfig

     

       10
       11
        
       , freetype

     

       11
       11
       -
       , libGLU

     

       12
       12
       +
       , icu

     

       13
       13
       +
       , intltool

     

       12
       14
        
       , libGL

     

       15
       15
       +
       , libGLU

     

       16
       16
       +
       , libX11

     

       13
       17
        
       , libass

     

       14
       14
       -
       , fftw

     

       15
       15
       -
       , ffms

     

       16
       16
       -
       , ffmpeg_3

     

       18
       18
       +
       , libiconv

     

       17
       19
        
       , pkg-config

     

       20
       20
       +
       , wxGTK

     

       18
       21
        
       , zlib

     

       19
       19
       -
       , icu

     

       20
       20
       -
       , boost

     

       21
       21
       -
       , intltool

     

       22
       22
        
       

     

       23
       23
        
       , spellcheckSupport ? true

     

       24
       24
        
       , hunspell ? null

     
···

       46
       46
        
       assert pulseaudioSupport -> (libpulseaudio != null);

     

       47
       47
        
       assert portaudioSupport -> (portaudio != null);

     

       48
       48
        
       

     

       49
       49
       -
       with lib;

     

       50
       50
       -
       stdenv.mkDerivation

     

       51
       51
       -
        rec {

     

       49
       49
       +
       let

     

       50
       50
       +
         inherit (lib) optional;

     

       51
       51
       +
       in

     

       52
       52
       +
       stdenv.mkDerivation rec {

     

       52
       53
        
         pname = "aegisub";

     

       53
       54
        
         version = "3.2.2";

     

       54
       55
        
       

     

       55
       56
        
         src = fetchurl {

     

       56
       57
        
           url = "http://ftp.aegisub.org/pub/releases/${pname}-${version}.tar.xz";

     

       57
       57
       -
           sha256 = "11b83qazc8h0iidyj1rprnnjdivj1lpphvpa08y53n42bfa36pn5";

     

       58
       58
       +
           hash = "sha256-xV4zlFuC2FE8AupueC8Ncscmrc03B+lbjAAi9hUeaIU=";

     

       58
       59
        
         };

     

       59
       60
        
       

     

       60
       61
        
         patches = [

     

       61
       62
        
           # Compatibility with ICU 59

     

       62
       63
        
           (fetchpatch {

     

       63
       64
        
             url = "https://github.com/Aegisub/Aegisub/commit/dd67db47cb2203e7a14058e52549721f6ff16a49.patch";

     

       64
       64
       -
             sha256 = "07qqlckiyy64lz8zk1as0vflk9kqnjb340420lp9f0xj93ncssj7";

     

       65
       65
       +
             sha256 = "sha256-R2rN7EiyA5cuBYIAMpa0eKZJ3QZahfnRp8R4HyejGB8=";

     

       65
       66
        
           })

     

       66
       67
        
       

     

       67
       68
        
           # Compatbility with Boost 1.69

     

       68
       69
        
           (fetchpatch {

     

       69
       70
        
             url = "https://github.com/Aegisub/Aegisub/commit/c3c446a8d6abc5127c9432387f50c5ad50012561.patch";

     

       70
       70
       -
             sha256 = "1n8wmjka480j43b1pr30i665z8hdy6n3wdiz1ls81wyv7ai5yygf";

     

       71
       71
       +
             sha256 = "sha256-7nlfojrb84A0DT82PqzxDaJfjIlg5BvWIBIgoqasHNk=";

     

       71
       72
        
           })

     

       72
       73
        
       

     

       73
       74
        
           # Compatbility with make 4.3

     

       74
       75
        
           (fetchpatch {

     

       75
       76
        
             url = "https://github.com/Aegisub/Aegisub/commit/6bd3f4c26b8fc1f76a8b797fcee11e7611d59a39.patch";

     

       76
       76
       -
             sha256 = "1s9cc5rikrqb9ivjbag4b8yxcyjsmmmw744394d5xq8xi4k12vxc";

     

       77
       77
       +
             sha256 = "sha256-rG8RJokd4V4aSYOQw2utWnrWPVrkqSV3TAvnGXNhLOk=";

     

       77
       78
        
           })

     

       78
       79
        
         ];

     

       79
       80
        
       

     

       80
       81
        
         nativeBuildInputs = [

     

       81
       81
       -
           pkg-config

     

       82
       82
        
           intltool

     

       83
       83
       +
           pkg-config

     

       83
       84
        
         ];

     

       84
       84
       -
       

     

       85
       85
       -
         buildInputs = with lib; [

     

       86
       86
       -
           libX11

     

       87
       87
       -
           wxGTK

     

       85
       85
       +
         buildInputs = [

     

       86
       86
       +
           boost

     

       87
       87
       +
           ffmpeg

     

       88
       88
       +
           ffms

     

       89
       89
       +
           fftw

     

       88
       90
        
           fontconfig

     

       89
       91
        
           freetype

     

       90
       90
       -
           libGLU

     

       92
       92
       +
           icu

     

       91
       93
        
           libGL

     

       94
       94
       +
           libGLU

     

       95
       95
       +
           libX11

     

       92
       96
        
           libass

     

       93
       93
       -
           fftw

     

       94
       94
       -
           ffms

     

       95
       95
       -
           ffmpeg_3

     

       97
       97
       +
           libiconv

     

       98
       98
       +
           wxGTK

     

       96
       99
        
           zlib

     

       97
       97
       -
           icu

     

       98
       98
       -
           boost

     

       99
       99
       -
           libiconv

     

       100
       100
        
         ]

     

       101
       101
       -
           ++ optional spellcheckSupport hunspell

     

       102
       102
       -
           ++ optional automationSupport lua

     

       103
       103
       -
           ++ optional openalSupport openal

     

       104
       104
       -
           ++ optional alsaSupport alsaLib

     

       105
       105
       -
           ++ optional pulseaudioSupport libpulseaudio

     

       106
       106
       -
           ++ optional portaudioSupport portaudio

     

       107
       107
       -
           ;

     

       101
       101
       +
         ++ optional alsaSupport alsaLib

     

       102
       102
       +
         ++ optional automationSupport lua

     

       103
       103
       +
         ++ optional openalSupport openal

     

       104
       104
       +
         ++ optional portaudioSupport portaudio

     

       105
       105
       +
         ++ optional pulseaudioSupport libpulseaudio

     

       106
       106
       +
         ++ optional spellcheckSupport hunspell

     

       107
       107
       +
         ;

     

       108
       108
        
       

     

       109
       109
        
         enableParallelBuilding = true;

     

       110
       110
        
       

     

       111
       111
       -
         hardeningDisable = [ "bindnow" "relro" ];

     

       111
       111
       +
         hardeningDisable = [

     

       112
       112
       +
           "bindnow"

     

       113
       113
       +
           "relro"

     

       114
       114
       +
         ];

     

       112
       115
        
       

     

       113
       113
       -
         # compat with icu61+ https://github.com/unicode-org/icu/blob/release-64-2/icu4c/readme.html#L554

     

       116
       116
       +
         # compat with icu61+

     

       117
       117
       +
         # https://github.com/unicode-org/icu/blob/release-64-2/icu4c/readme.html#L554

     

       114
       118
        
         CXXFLAGS = [ "-DU_USING_ICU_NAMESPACE=1" ];

     

       115
       119
        
       

     

       116
       120
        
         # this is fixed upstream though not yet in an officially released version,

     
···

       119
       123
        
       

     

       120
       124
        
         postInstall = "ln -s $out/bin/aegisub-* $out/bin/aegisub";

     

       121
       125
        
       

     

       122
       122
       -
         meta = {

     

       126
       126
       +
         meta = with lib; {

     

       127
       127
       +
           homepage = "https://github.com/Aegisub/Aegisub";

     

       123
       128
        
           description = "An advanced subtitle editor";

     

       124
       129
        
           longDescription = ''

     

       125
       130
        
             Aegisub is a free, cross-platform open source tool for creating and

     
···

       127
       132
        
             audio, and features many powerful tools for styling them, including a

     

       128
       133
        
             built-in real-time video preview.

     

       129
       134
        
           '';

     

       130
       130
       -
           homepage = "http://www.aegisub.org/";

     

       131
       131
       -
           # The Aegisub sources are itself BSD/ISC,

     

       132
       132
       -
           # but they are linked against GPL'd softwares

     

       133
       133
       -
           # - so the resulting program will be GPL

     

       135
       135
       +
           # The Aegisub sources are itself BSD/ISC, but they are linked against GPL'd

     

       136
       136
       +
           # softwares - so the resulting program will be GPL

     

       134
       137
        
           license = licenses.bsd3;

     

       135
       138
        
           maintainers = [ maintainers.AndersonTorres ];

     

       136
       139
        
           platforms = [ "i686-linux" "x86_64-linux" ];

     

       137
       140
        
         };

     

       138
       141
        
       }

     

       142
       142
       +
       # TODO [ AndersonTorres ]: update to fork release

+79 -56

pkgs/applications/video/dvdstyler/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, pkg-config

     

       2
       2
       -
       , flex, bison, gettext

     

       3
       3
       -
       , xineUI, wxSVG

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , bison

     

       5
       5
       +
       , cdrtools

     

       6
       6
       +
       , docbook5

     

       7
       7
       +
       , dvdauthor

     

       8
       8
       +
       , dvdplusrwtools

     

       9
       9
       +
       , flex

     

       4
       10
        
       , fontconfig

     

       5
       5
       -
       , xmlto, docbook5, zip

     

       6
       6
       -
       , cdrtools, dvdauthor, dvdplusrwtools

     

       11
       11
       +
       , gettext

     

       12
       12
       +
       , makeWrapper

     

       13
       13
       +
       , pkg-config

     

       14
       14
       +
       , wxSVG

     

       15
       15
       +
       , xine-ui

     

       16
       16
       +
       , xmlto

     

       17
       17
       +
       , zip

     

       18
       18
       +
       

     

       7
       19
        
       , dvdisasterSupport ? true, dvdisaster ? null

     

       8
       20
        
       , thumbnailSupport ? true, libgnomeui ? null

     

       9
       21
        
       , udevSupport ? true, udev ? null

     

       10
       22
        
       , dbusSupport ? true, dbus ? null

     

       11
       11
       -
       , makeWrapper }:

     

       23
       23
       +
       }:

     

       12
       24
        
       

     

       13
       13
       -
       with lib;

     

       14
       14
       -
       stdenv.mkDerivation rec {

     

       15
       15
       -
       

     

       25
       25
       +
       let

     

       26
       26
       +
         inherit (lib) optionals makeBinPath;

     

       27
       27
       +
       in stdenv.mkDerivation rec {

     

       16
       28
        
         pname = "dvdstyler";

     

       17
       17
       -
         srcName = "DVDStyler-${version}";

     

       18
       29
        
         version = "3.1.2";

     

       19
       30
        
       

     

       20
       31
        
         src = fetchurl {

     

       21
       21
       -
           url = "mirror://sourceforge/project/dvdstyler/dvdstyler/${version}/${srcName}.tar.bz2";

     

       32
       32
       +
           url = "mirror://sourceforge/project/dvdstyler/dvdstyler/${version}/DVDStyler-${version}.tar.bz2";

     

       22
       33
        
           sha256 = "03lsblqficcadlzkbyk8agh5rqcfz6y6dqvy9y866wqng3163zq4";

     

       23
       34
        
         };

     

       24
       35
        
       

     

       25
       25
       -
         nativeBuildInputs =

     

       26
       26
       -
         [ pkg-config ];

     

       27
       27
       -
       

     

       28
       28
       -
         packagesToBinPath =

     

       29
       29
       -
         [ cdrtools dvdauthor dvdplusrwtools ];

     

       30
       30
       -
       

     

       31
       31
       -
         buildInputs =

     

       32
       32
       -
         [ flex bison gettext xineUI

     

       33
       33
       -
           wxSVG fontconfig xmlto

     

       34
       34
       -
           docbook5 zip makeWrapper ]

     

       35
       35
       -
         ++ packagesToBinPath

     

       36
       36
       +
         nativeBuildInputs = [

     

       37
       37
       +
           pkg-config

     

       38
       38
       +
         ];

     

       39
       39
       +
         buildInputs = [

     

       40
       40
       +
           bison

     

       41
       41
       +
           cdrtools

     

       42
       42
       +
           docbook5

     

       43
       43
       +
           dvdauthor

     

       44
       44
       +
           dvdplusrwtools

     

       45
       45
       +
           flex

     

       46
       46
       +
           fontconfig

     

       47
       47
       +
           gettext

     

       48
       48
       +
           makeWrapper

     

       49
       49
       +
           wxSVG

     

       50
       50
       +
           xine-ui

     

       51
       51
       +
           xmlto

     

       52
       52
       +
           zip

     

       53
       53
       +
        ]

     

       36
       54
        
         ++ optionals dvdisasterSupport [ dvdisaster ]

     

       37
       55
        
         ++ optionals udevSupport [ udev ]

     

       38
       56
        
         ++ optionals dbusSupport [ dbus ]

     

       39
       57
        
         ++ optionals thumbnailSupport [ libgnomeui ];

     

       40
       58
        
       

     

       41
       41
       -
         binPath = makeBinPath packagesToBinPath;

     

       42
       59
        
       

     

       43
       43
       -
         postInstall = ''

     

       44
       44
       -
           wrapProgram $out/bin/dvdstyler \

     

       45
       45
       -
             --prefix PATH ":" "${binPath}"

     

       46
       46
       -
         '';

     

       60
       60
       +
         postInstall = let

     

       61
       61
       +
           binPath = makeBinPath [

     

       62
       62
       +
             cdrtools

     

       63
       63
       +
             dvdauthor

     

       64
       64
       +
             dvdplusrwtools

     

       65
       65
       +
           ]; in

     

       66
       66
       +
           ''

     

       67
       67
       +
              wrapProgram $out/bin/dvdstyler --prefix PATH ":" "${binPath}"

     

       68
       68
       +
           '';

     

       47
       69
        
       

     

       48
       70
        
         meta = with lib; {

     

       71
       71
       +
           homepage = "https://www.dvdstyler.org/";

     

       49
       72
        
           description = "A DVD authoring software";

     

       50
       73
        
           longDescription = ''

     

       51
       51
       -
           DVDStyler is a cross-platform free DVD authoring application for the

     

       52
       52
       -
           creation of professional-looking DVDs. It allows not only burning of video

     

       53
       53
       -
           files on DVD that can be played practically on any standalone DVD player,

     

       54
       54
       -
           but also creation of individually designed DVD menus. It is Open Source

     

       55
       55
       -
           Software and is completely free.

     

       74
       74
       +
             DVDStyler is a cross-platform free DVD authoring application for the

     

       75
       75
       +
             creation of professional-looking DVDs. It allows not only burning of video

     

       76
       76
       +
             files on DVD that can be played practically on any standalone DVD player,

     

       77
       77
       +
             but also creation of individually designed DVD menus. It is Open Source

     

       78
       78
       +
             Software and is completely free.

     

       56
       79
        
       

     

       57
       57
       -
           Some of its features include:

     

       58
       58
       -
           -  create and burn DVD video with interactive menus

     

       59
       59
       -
           - design your own DVD menu or select one from the list of ready to use menu

     

       60
       60
       -
             templates

     

       61
       61
       -
           - create photo slideshow

     

       62
       62
       -
           - add multiple subtitle and audio tracks

     

       63
       63
       -
           - support of AVI, MOV, MP4, MPEG, OGG, WMV and other file formats

     

       64
       64
       -
           - support of MPEG-2, MPEG-4, DivX, Xvid, MP2, MP3, AC-3 and other audio and

     

       65
       65
       -
             video formats

     

       66
       66
       -
           - support of multi-core processor

     

       67
       67
       -
           - use MPEG and VOB files without reencoding

     

       68
       68
       -
           - put files with different audio/video format on one DVD (support of

     

       69
       69
       -
             titleset)

     

       70
       70
       -
           - user-friendly interface with support of drag & drop

     

       71
       71
       -
           - flexible menu creation on the basis of scalable vector graphic

     

       72
       72
       -
           - import of image file for background

     

       73
       73
       -
           - place buttons, text, images and other graphic objects anywhere on the menu

     

       74
       74
       -
             screen

     

       75
       75
       -
           - change the font/color and other parameters of buttons and graphic objects

     

       76
       76
       -
           - scale any button or graphic object

     

       77
       77
       -
           - copy any menu object or whole menu

     

       78
       78
       -
           - customize navigation using DVD scripting

     

       80
       80
       +
             Some of its features include:

     

       81
       81
       +
       

     

       82
       82
       +
             - create and burn DVD video with interactive menus

     

       83
       83
       +
             - design your own DVD menu or select one from the list of ready to use menu

     

       84
       84
       +
               templates

     

       85
       85
       +
             - create photo slideshow

     

       86
       86
       +
             - add multiple subtitle and audio tracks

     

       87
       87
       +
             - support of AVI, MOV, MP4, MPEG, OGG, WMV and other file formats

     

       88
       88
       +
             - support of MPEG-2, MPEG-4, DivX, Xvid, MP2, MP3, AC-3 and other audio and

     

       89
       89
       +
               video formats

     

       90
       90
       +
             - support of multi-core processor

     

       91
       91
       +
             - use MPEG and VOB files without reencoding

     

       92
       92
       +
             - put files with different audio/video format on one DVD (support of

     

       93
       93
       +
               titleset)

     

       94
       94
       +
             - user-friendly interface with support of drag & drop

     

       95
       95
       +
             - flexible menu creation on the basis of scalable vector graphic

     

       96
       96
       +
             - import of image file for background

     

       97
       97
       +
             - place buttons, text, images and other graphic objects anywhere on the menu

     

       98
       98
       +
               screen

     

       99
       99
       +
             - change the font/color and other parameters of buttons and graphic objects

     

       100
       100
       +
             - scale any button or graphic object

     

       101
       101
       +
             - copy any menu object or whole menu

     

       102
       102
       +
             - customize navigation using DVD scripting

     

       79
       103
        
           '';

     

       80
       80
       -
           homepage = "http://www.dvdstyler.org/";

     

       81
       81
       -
           license = with licenses; gpl2;

     

       104
       104
       +
           license = licenses.gpl2Plus;

     

       82
       105
        
           maintainers = with maintainers; [ AndersonTorres ];

     

       83
       106
        
           platforms = with platforms; linux;

     

       84
       107
        
         };

+4 -4

pkgs/applications/video/vdr/xineliboutput/default.nix

···

       1
       1
        
       { stdenv, fetchurl, lib, vdr

     

       2
       2
        
       , libav, libcap, libvdpau

     

       3
       3
       -
       , xineLib, libjpeg, libextractor, libglvnd, libGLU

     

       3
       3
       +
       , xine-lib, libjpeg, libextractor, libglvnd, libGLU

     

       4
       4
        
       , libX11, libXext, libXrender, libXrandr

     

       5
       5
        
       , makeWrapper

     

       6
       6
        
       }: let

     
···

       34
       34
        
           postFixup = ''

     

       35
       35
        
             for f in $out/bin/*; do

     

       36
       36
        
               wrapProgram $f \

     

       37
       37
       -
                 --prefix XINE_PLUGIN_PATH ":" "${makeXinePluginPath [ "$out" xineLib ]}"

     

       37
       37
       +
                 --prefix XINE_PLUGIN_PATH ":" "${makeXinePluginPath [ "$out" xine-lib ]}"

     

       38
       38
        
             done

     

       39
       39
        
           '';

     

       40
       40
        
       

     
···

       53
       53
        
             libXrender

     

       54
       54
        
             libX11

     

       55
       55
        
             vdr

     

       56
       56
       -
             xineLib

     

       56
       56
       +
             xine-lib

     

       57
       57
        
           ];

     

       58
       58
        
       

     

       59
       59
       -
           passthru.requiredXinePlugins = [ xineLib self ];

     

       59
       59
       +
           passthru.requiredXinePlugins = [ xine-lib self ];

     

       60
       60
        
       

     

       61
       61
        
           meta = with lib;{

     

       62
       62
        
             homepage = "https://sourceforge.net/projects/xineliboutput/";

+45 -16

pkgs/applications/video/xine-ui/default.nix

···

       1
       1
       -
       {lib, stdenv, fetchurl, pkg-config, xorg, libpng, xineLib, readline, ncurses, curl

     

       2
       2
       -
       , lirc, shared-mime-info, libjpeg }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , curl

     

       5
       5
       +
       , libjpeg

     

       6
       6
       +
       , libpng

     

       7
       7
       +
       , lirc

     

       8
       8
       +
       , ncurses

     

       9
       9
       +
       , pkg-config

     

       10
       10
       +
       , readline

     

       11
       11
       +
       , shared-mime-info

     

       12
       12
       +
       , xine-lib

     

       13
       13
       +
       , xorg

     

       14
       14
       +
       }:

     

       3
       15
        
       

     

       4
       16
        
       stdenv.mkDerivation rec {

     

       5
       5
       -
         name = "xine-ui-0.99.12";

     

       17
       17
       +
         pname = "xine-ui";

     

       18
       18
       +
         version = "0.99.12";

     

       6
       19
        
       

     

       7
       20
        
         src = fetchurl {

     

       8
       8
       -
           url = "mirror://sourceforge/xine/${name}.tar.xz";

     

       21
       21
       +
           url = "mirror://sourceforge/xine/${pname}-${version}.tar.xz";

     

       9
       22
        
           sha256 = "10zmmss3hm8gjjyra20qhdc0lb1m6sym2nb2w62bmfk8isfw9gsl";

     

       10
       23
        
         };

     

       11
       24
        
       

     

       12
       12
       -
         nativeBuildInputs = [ pkg-config shared-mime-info ];

     

       13
       13
       -
       

     

       14
       14
       -
         buildInputs =

     

       15
       15
       -
           [ xineLib libpng readline ncurses curl lirc libjpeg

     

       16
       16
       -
             xorg.xlibsWrapper xorg.libXext xorg.libXv xorg.libXxf86vm xorg.libXtst xorg.xorgproto

     

       17
       17
       -
             xorg.libXinerama xorg.libXi xorg.libXft

     

       18
       18
       -
           ];

     

       25
       25
       +
         nativeBuildInputs = [

     

       26
       26
       +
           pkg-config

     

       27
       27
       +
           shared-mime-info

     

       28
       28
       +
         ];

     

       29
       29
       +
         buildInputs = [

     

       30
       30
       +
           curl

     

       31
       31
       +
           libjpeg

     

       32
       32
       +
           libpng

     

       33
       33
       +
           lirc

     

       34
       34
       +
           ncurses

     

       35
       35
       +
           readline

     

       36
       36
       +
           xine-lib

     

       37
       37
       +
         ] ++ (with xorg; [

     

       38
       38
       +
           libXext

     

       39
       39
       +
           libXft

     

       40
       40
       +
           libXi

     

       41
       41
       +
           libXinerama

     

       42
       42
       +
           libXtst

     

       43
       43
       +
           libXv

     

       44
       44
       +
           libXxf86vm

     

       45
       45
       +
           xlibsWrapper

     

       46
       46
       +
           xorgproto

     

       47
       47
       +
         ]);

     

       19
       48
        
       

     

       20
       20
       -
         patchPhase = ''sed -e '/curl\/types\.h/d' -i src/xitk/download.c'';

     

       49
       49
       +
         postPatch = "sed -e '/curl\/types\.h/d' -i src/xitk/download.c";

     

       21
       50
        
       

     

       22
       51
        
         configureFlags = [ "--with-readline=${readline.dev}" ];

     

       23
       52
        
       

     

       24
       53
        
         LIRC_CFLAGS="-I${lirc}/include";

     

       25
       54
        
         LIRC_LIBS="-L ${lirc}/lib -llirc_client";

     

       26
       26
       -
       #NIX_LDFLAGS = "-lXext -lgcc_s";

     

       27
       55
        
       

     

       28
       56
        
         meta = with lib; {

     

       29
       29
       -
           homepage = "http://www.xine-project.org/";

     

       30
       30
       -
           description = "Xlib-based interface to Xine, a video player";

     

       57
       57
       +
           homepage = "http://xinehq.de/";

     

       58
       58
       +
           description = "Xlib-based frontend for Xine video player";

     

       59
       59
       +
           license = licenses.gpl2Plus;

     

       60
       60
       +
           maintainers = with maintainers; [ AndersonTorres ];

     

       31
       61
        
           platforms = platforms.linux;

     

       32
       32
       -
           license = licenses.gpl2;

     

       33
       62
        
         };

     

       34
       63
        
       }

+3 -3

pkgs/applications/window-managers/leftwm/default.nix

···

       6
       6
        
       

     

       7
       7
        
       rustPlatform.buildRustPackage rec {

     

       8
       8
        
         pname = "leftwm";

     

       9
       9
       -
         version = "0.2.6";

     

       9
       9
       +
         version = "0.2.7";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "leftwm";

     

       13
       13
        
           repo = "leftwm";

     

       14
       14
        
           rev = version;

     

       15
       15
       -
           sha256 = "sha256-hirT0gScC2LFPvygywgPiSVDUE/Zd++62wc26HlufYU=";

     

       15
       15
       +
           sha256 = "sha256-nRPt+Tyfq62o+3KjsXkHQHUMMslHFGNBd3s2pTb7l4w=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         cargoSha256 = "sha256-j57LHPU3U3ipUGQDrZ8KCuELOVJ3BxhLXsJePOO6rTM=";

     

       18
       18
       +
         cargoSha256 = "sha256-lmzA7XM8B5QJI4Wo0cKeMR3+np6jT6mdGzTry4g87ng=";

     

       19
       19
        
       

     

       20
       20
        
         nativeBuildInputs = [ makeWrapper ];

     

       21
       21
        
         buildInputs = [ libX11 libXinerama ];

+2 -2

pkgs/data/misc/hackage/default.nix

···

       1
       1
        
       { fetchurl }:

     

       2
       2
        
       

     

       3
       3
        
       fetchurl {

     

       4
       4
       -
         url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/1aad60ed9679a7597f3fc3515a0fe26fdb896e55.tar.gz";

     

       5
       5
       -
         sha256 = "0a7lm1ki8rz7m13x4zxlr1nkd93227xgmxbhvsmrj9fa4nc5bvyy";

     

       4
       4
       +
         url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/d202e2aff06500ede787ed63544476f6d41e9eb7.tar.gz";

     

       5
       5
       +
         sha256 = "00hmclrhr3a2h9vshsl909g0zgymlamx491lkhwr5kgb3qx9sfh2";

     

       6
       6
        
       }

+5 -2

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

···

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

     

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

     

       66
       66
        
             rev = "refs/tags/" + super.git-annex.version;

     

       67
       67
       -
             sha256 = "13n62v3cdkx23fywdccczcr8vsf0vmjbimmgin766bf428jlhh6h";

     

       67
       67
       +
             sha256 = "1wig8nw2rxgq86y88m1f1qf93z5yckidf1cs33ribmhqa1hs300p";

     

       68
       68
        
           };

     

       69
       69
        
         }).override {

     

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

     
···

       284
       284
        
         hsbencher = dontCheck super.hsbencher;

     

       285
       285
        
         hsexif = dontCheck super.hsexif;

     

       286
       286
        
         hspec-server = dontCheck super.hspec-server;

     

       287
       287
       -
         HTF = dontCheck super.HTF;

     

       287
       287
       +
         HTF = overrideCabal super.HTF (orig: {

     

       288
       288
       +
           # The scripts in scripts/ are needed to build the test suite.

     

       289
       289
       +
           preBuild = "patchShebangs --build scripts";

     

       290
       290
       +
         });

     

       288
       291
        
         htsn = dontCheck super.htsn;

     

       289
       292
        
         htsn-import = dontCheck super.htsn-import;

     

       290
       293
        
         http-link-header = dontCheck super.http-link-header; # non deterministic failure https://hydra.nixos.org/build/75041105

+2 -2

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

···

       79
       79
        
       

     

       80
       80
        
         # Apply patches from head.hackage.

     

       81
       81
        
         alex = appendPatch (dontCheck super.alex) (pkgs.fetchpatch {

     

       82
       82
       -
           url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/alex-3.2.5.patch";

     

       83
       83
       -
           sha256 = "0q8x49k3jjwyspcmidwr6b84s4y43jbf4wqfxfm6wz8x2dxx6nwh";

     

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

     

       83
       83
       +
           sha256 = "1rzs764a0nhx002v4fadbys98s6qblw4kx4g46galzjf5f7n2dn4";

     

       84
       84
        
         });

     

       85
       85
        
         doctest = dontCheck (doJailbreak super.doctest_0_18_1);

     

       86
       86
        
         generic-deriving = appendPatch (doJailbreak super.generic-deriving) (pkgs.fetchpatch {

+97 -46

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

···

       101
       101
        
         - gi-secret < 0.0.13

     

       102
       102
        
         - gi-vte < 2.91.28

     

       103
       103
        
       

     

       104
       104
       -
         # Stackage Nightly 2021-04-15

     

       104
       104
       +
         # Stackage Nightly 2021-04-28

     

       105
       105
        
         - abstract-deque ==0.3

     

       106
       106
        
         - abstract-par ==0.3.3

     

       107
       107
        
         - AC-Angle ==1.0

     
···

       319
       319
        
         - base64-string ==0.2

     

       320
       320
        
         - base-compat ==0.11.2

     

       321
       321
        
         - base-compat-batteries ==0.11.2

     

       322
       322
       -
         - basement ==0.0.11

     

       322
       322
       +
         - basement ==0.0.12

     

       323
       323
        
         - base-orphans ==0.8.4

     

       324
       324
        
         - base-prelude ==1.4

     

       325
       325
        
         - base-unicode-symbols ==0.2.4.2

     
···

       437
       437
        
         - calendar-recycling ==0.0.0.1

     

       438
       438
        
         - call-stack ==0.3.0

     

       439
       439
        
         - can-i-haz ==0.3.1.0

     

       440
       440
       +
         - capability ==0.4.0.0

     

       440
       441
        
         - ca-province-codes ==1.0.0.0

     

       441
       442
        
         - cardano-coin-selection ==1.0.1

     

       442
       443
        
         - carray ==0.1.6.8

     
···

       531
       532
        
         - composite-aeson ==0.7.5.0

     

       532
       533
        
         - composite-aeson-path ==0.7.5.0

     

       533
       534
        
         - composite-aeson-refined ==0.7.5.0

     

       535
       535
       +
         - composite-aeson-throw ==0.1.0.0

     

       534
       536
        
         - composite-base ==0.7.5.0

     

       535
       537
        
         - composite-binary ==0.7.5.0

     

       536
       538
        
         - composite-ekg ==0.7.5.0

     
···

       710
       712
        
         - distributed-closure ==0.4.2.0

     

       711
       713
        
         - distribution-opensuse ==1.1.1

     

       712
       714
        
         - distributive ==0.6.2.1

     

       713
       713
       -
         - dl-fedora ==0.8

     

       715
       715
       +
         - dl-fedora ==0.9

     

       714
       716
        
         - dlist ==0.8.0.8

     

       715
       717
        
         - dlist-instances ==0.1.1.1

     

       716
       718
        
         - dlist-nonempty ==0.1.1

     
···

       825
       827
        
         - expiring-cache-map ==0.0.6.1

     

       826
       828
        
         - explicit-exception ==0.1.10

     

       827
       829
        
         - exp-pairs ==0.2.1.0

     

       828
       828
       -
         - express ==0.1.4

     

       830
       830
       +
         - express ==0.1.6

     

       829
       831
        
         - extended-reals ==0.2.4.0

     

       830
       832
        
         - extensible-effects ==5.0.0.1

     

       831
       833
        
         - extensible-exceptions ==0.1.1.4

     

       832
       834
        
         - extra ==1.7.9

     

       833
       835
        
         - extractable-singleton ==0.0.1

     

       834
       834
       -
         - extrapolate ==0.4.2

     

       836
       836
       +
         - extrapolate ==0.4.4

     

       835
       837
        
         - fail ==4.9.0.0

     

       836
       838
        
         - failable ==1.2.4.0

     

       837
       839
        
         - fakedata ==0.8.0

     
···

       901
       903
        
         - forma ==1.1.3

     

       902
       904
        
         - format-numbers ==0.1.0.1

     

       903
       905
        
         - formatting ==6.3.7

     

       904
       904
       -
         - foundation ==0.0.25

     

       906
       906
       +
         - foundation ==0.0.26.1

     

       907
       907
       +
         - fourmolu ==0.3.0.0

     

       905
       908
        
         - free ==5.1.5

     

       906
       909
        
         - free-categories ==0.2.0.2

     

       907
       910
        
         - freenect ==1.2.1

     
···

       988
       991
        
         - ghc-lib ==8.10.4.20210206

     

       989
       992
        
         - ghc-lib-parser ==8.10.4.20210206

     

       990
       993
        
         - ghc-lib-parser-ex ==8.10.0.19

     

       991
       991
       -
         - ghc-parser ==0.2.2.0

     

       994
       994
       +
         - ghc-parser ==0.2.3.0

     

       992
       995
        
         - ghc-paths ==0.1.0.12

     

       993
       996
        
         - ghc-prof ==1.4.1.8

     

       994
       997
        
         - ghc-source-gen ==0.4.0.0

     
···

       1081
       1084
        
         - hashmap ==1.3.3

     

       1082
       1085
        
         - hashtables ==1.2.4.1

     

       1083
       1086
        
         - haskeline ==0.8.1.2

     

       1087
       1087
       +
         - haskell-awk ==1.2

     

       1084
       1088
        
         - haskell-gi ==0.24.7

     

       1085
       1089
        
         - haskell-gi-base ==0.24.5

     

       1086
       1090
        
         - haskell-gi-overloading ==1.0

     
···

       1089
       1093
        
         - haskell-lsp ==0.22.0.0

     

       1090
       1094
        
         - haskell-lsp-types ==0.22.0.0

     

       1091
       1095
        
         - haskell-names ==0.9.9

     

       1096
       1096
       +
         - HaskellNet ==0.6

     

       1092
       1097
        
         - haskell-src ==1.0.3.1

     

       1093
       1098
        
         - haskell-src-exts ==1.23.1

     

       1094
       1099
        
         - haskell-src-exts-util ==0.2.5

     
···

       1187
       1192
        
         - hslua-module-path ==0.1.0.1

     

       1188
       1193
        
         - hslua-module-system ==0.2.2.1

     

       1189
       1194
        
         - hslua-module-text ==0.3.0.1

     

       1190
       1190
       -
         - HsOpenSSL ==0.11.6.2

     

       1195
       1195
       +
         - HsOpenSSL ==0.11.7

     

       1191
       1196
        
         - HsOpenSSL-x509-system ==0.1.0.4

     

       1192
       1197
        
         - hsp ==0.10.0

     

       1193
       1193
       -
         - hspec ==2.7.9

     

       1198
       1198
       +
         - hspec ==2.7.10

     

       1194
       1199
        
         - hspec-attoparsec ==0.1.0.2

     

       1195
       1200
        
         - hspec-checkers ==0.1.0.2

     

       1196
       1201
        
         - hspec-contrib ==0.5.1

     

       1197
       1197
       -
         - hspec-core ==2.7.9

     

       1198
       1198
       -
         - hspec-discover ==2.7.9

     

       1202
       1202
       +
         - hspec-core ==2.7.10

     

       1203
       1203
       +
         - hspec-discover ==2.7.10

     

       1199
       1204
        
         - hspec-expectations ==0.8.2

     

       1200
       1205
        
         - hspec-expectations-json ==1.0.0.3

     

       1201
       1206
        
         - hspec-expectations-lifted ==0.10.0

     
···

       1228
       1233
        
         - html-entities ==1.1.4.5

     

       1229
       1234
        
         - html-entity-map ==0.1.0.0

     

       1230
       1235
        
         - htoml ==1.0.0.3

     

       1231
       1231
       -
         - http2 ==2.0.6

     

       1236
       1236
       +
         - http2 ==3.0.1

     

       1232
       1237
        
         - HTTP ==4000.3.16

     

       1233
       1238
        
         - http-api-data ==0.4.2

     

       1234
       1239
        
         - http-client ==0.6.4.1

     
···

       1252
       1257
        
         - HUnit-approx ==1.1.1.1

     

       1253
       1258
        
         - hunit-dejafu ==2.0.0.4

     

       1254
       1259
        
         - hvect ==0.4.0.0

     

       1255
       1255
       -
         - hvega ==0.11.0.0

     

       1260
       1260
       +
         - hvega ==0.11.0.1

     

       1256
       1261
        
         - hw-balancedparens ==0.4.1.1

     

       1257
       1262
        
         - hw-bits ==0.7.2.1

     

       1258
       1263
        
         - hw-conduit ==0.2.1.0

     
···

       1302
       1307
        
         - ieee754 ==0.8.0

     

       1303
       1308
        
         - if ==0.1.0.0

     

       1304
       1309
        
         - iff ==0.0.6

     

       1305
       1305
       -
         - ihaskell ==0.10.1.2

     

       1310
       1310
       +
         - ihaskell ==0.10.2.0

     

       1306
       1311
        
         - ihs ==0.1.0.3

     

       1307
       1312
        
         - ilist ==0.4.0.1

     

       1308
       1313
        
         - imagesize-conduit ==1.1

     
···

       1330
       1335
        
         - inliterate ==0.1.0

     

       1331
       1336
        
         - input-parsers ==0.2.2

     

       1332
       1337
        
         - insert-ordered-containers ==0.2.4

     

       1333
       1333
       -
         - inspection-testing ==0.4.3.0

     

       1338
       1338
       +
         - inspection-testing ==0.4.4.0

     

       1334
       1339
        
         - instance-control ==0.1.2.0

     

       1335
       1340
        
         - int-cast ==0.2.0.0

     

       1336
       1341
        
         - integer-logarithms ==1.0.3.1

     
···

       1356
       1361
        
         - io-streams ==1.5.2.0

     

       1357
       1362
        
         - io-streams-haproxy ==1.0.1.0

     

       1358
       1363
        
         - ip6addr ==1.0.2

     

       1364
       1364
       +
         - ipa ==0.3

     

       1359
       1365
        
         - iproute ==1.7.11

     

       1360
       1366
        
         - IPv6Addr ==2.0.2

     

       1361
       1367
        
         - ipynb ==0.1.0.1

     
···

       1410
       1416
        
         - kind-generics ==0.4.1.0

     

       1411
       1417
        
         - kind-generics-th ==0.2.2.2

     

       1412
       1418
        
         - kmeans ==0.1.3

     

       1419
       1419
       +
         - koji ==0.0.1

     

       1413
       1420
        
         - koofr-client ==1.0.0.3

     

       1414
       1421
        
         - krank ==0.2.2

     

       1415
       1422
        
         - kubernetes-webhook-haskell ==0.2.0.3

     
···

       1422
       1429
        
         - language-bash ==0.9.2

     

       1423
       1430
        
         - language-c ==0.8.3

     

       1424
       1431
        
         - language-c-quote ==0.12.2.1

     

       1425
       1425
       -
         - language-docker ==9.2.0

     

       1432
       1432
       +
         - language-docker ==9.3.0

     

       1426
       1433
        
         - language-java ==0.2.9

     

       1427
       1434
        
         - language-javascript ==0.7.1.0

     

       1428
       1435
        
         - language-protobuf ==1.0.1

     
···

       1440
       1447
        
         - lazy-csv ==0.5.1

     

       1441
       1448
        
         - lazyio ==0.1.0.4

     

       1442
       1449
        
         - lca ==0.4

     

       1443
       1443
       -
         - leancheck ==0.9.3

     

       1450
       1450
       +
         - leancheck ==0.9.4

     

       1444
       1451
        
         - leancheck-instances ==0.0.4

     

       1445
       1452
        
         - leapseconds-announced ==2017.1.0.1

     

       1446
       1453
        
         - learn-physics ==0.6.5

     
···

       1470
       1477
        
         - lifted-async ==0.10.2

     

       1471
       1478
        
         - lifted-base ==0.2.3.12

     

       1472
       1479
        
         - lift-generics ==0.2

     

       1480
       1480
       +
         - lift-type ==0.1.0.1

     

       1473
       1481
        
         - line ==4.0.1

     

       1474
       1482
        
         - linear ==1.21.5

     

       1475
       1483
        
         - linear-circuit ==0.1.0.2

     
···

       1659
       1667
        
         - mwc-random ==0.14.0.0

     

       1660
       1668
        
         - mwc-random-monad ==0.7.3.1

     

       1661
       1669
        
         - mx-state-codes ==1.0.0.0

     

       1662
       1662
       -
         - mysql ==0.2

     

       1670
       1670
       +
         - mysql ==0.2.0.1

     

       1663
       1671
        
         - mysql-simple ==0.4.5

     

       1664
       1672
        
         - n2o ==0.11.1

     

       1665
       1673
        
         - nagios-check ==0.3.2

     
···

       1689
       1697
        
         - network-ip ==0.3.0.3

     

       1690
       1698
        
         - network-messagepack-rpc ==0.1.2.0

     

       1691
       1699
        
         - network-messagepack-rpc-websocket ==0.1.1.1

     

       1700
       1700
       +
         - network-run ==0.2.4

     

       1692
       1701
        
         - network-simple ==0.4.5

     

       1693
       1702
        
         - network-simple-tls ==0.4

     

       1694
       1703
        
         - network-transport ==0.5.4

     
···

       1713
       1722
        
         - no-value ==1.0.0.0

     

       1714
       1723
        
         - nowdoc ==0.1.1.0

     

       1715
       1724
        
         - nqe ==0.6.3

     

       1716
       1716
       -
         - nri-env-parser ==0.1.0.6

     

       1717
       1717
       -
         - nri-observability ==0.1.0.1

     

       1718
       1718
       -
         - nri-prelude ==0.5.0.3

     

       1725
       1725
       +
         - nri-env-parser ==0.1.0.7

     

       1726
       1726
       +
         - nri-observability ==0.1.0.2

     

       1727
       1727
       +
         - nri-prelude ==0.6.0.0

     

       1719
       1728
        
         - nsis ==0.3.3

     

       1720
       1729
        
         - numbers ==3000.2.0.2

     

       1721
       1730
        
         - numeric-extras ==0.1

     
···

       1743
       1752
        
         - oo-prototypes ==0.1.0.0

     

       1744
       1753
        
         - opaleye ==0.7.1.0

     

       1745
       1754
        
         - OpenAL ==1.7.0.5

     

       1746
       1746
       -
         - openapi3 ==3.0.2.0

     

       1755
       1755
       +
         - openapi3 ==3.1.0

     

       1747
       1756
        
         - open-browser ==0.2.1.0

     

       1748
       1757
        
         - openexr-write ==0.1.0.2

     

       1749
       1758
        
         - OpenGL ==3.0.3.0

     
···

       1777
       1786
        
         - pagination ==0.2.2

     

       1778
       1787
        
         - pagure-cli ==0.2

     

       1779
       1788
        
         - pandoc ==2.13

     

       1789
       1789
       +
         - pandoc-dhall-decoder ==0.1.0.1

     

       1780
       1790
        
         - pandoc-plot ==1.1.1

     

       1791
       1791
       +
         - pandoc-throw ==0.1.0.0

     

       1781
       1792
        
         - pandoc-types ==1.22

     

       1782
       1793
        
         - pantry ==0.5.1.5

     

       1783
       1794
        
         - parallel ==3.2.2.0

     
···

       1861
       1872
        
         - pipes-safe ==2.3.3

     

       1862
       1873
        
         - pipes-wai ==3.2.0

     

       1863
       1874
        
         - pkcs10 ==0.2.0.0

     

       1864
       1864
       -
         - pkgtreediff ==0.4

     

       1875
       1875
       +
         - pkgtreediff ==0.4.1

     

       1865
       1876
        
         - place-cursor-at ==1.0.1

     

       1866
       1877
        
         - placeholders ==0.1

     

       1867
       1878
        
         - plaid ==0.1.0.4

     
···

       1874
       1885
        
         - poly-arity ==0.1.0

     

       1875
       1886
        
         - polynomials-bernstein ==1.1.2

     

       1876
       1887
        
         - polyparse ==1.13

     

       1888
       1888
       +
         - polysemy ==1.5.0.0

     

       1889
       1889
       +
         - polysemy-plugin ==0.3.0.0

     

       1877
       1890
        
         - pooled-io ==0.0.2.2

     

       1878
       1891
        
         - port-utils ==0.2.1.0

     

       1879
       1892
        
         - posix-paths ==0.2.1.6

     
···

       1929
       1942
        
         - promises ==0.3

     

       1930
       1943
        
         - prompt ==0.1.1.2

     

       1931
       1944
        
         - prospect ==0.1.0.0

     

       1932
       1932
       -
         - proto3-wire ==1.2.0

     

       1945
       1945
       +
         - proto3-wire ==1.2.1

     

       1933
       1946
        
         - protobuf ==0.2.1.3

     

       1934
       1947
        
         - protobuf-simple ==0.1.1.0

     

       1935
       1948
        
         - protocol-buffers ==2.4.17

     
···

       1998
       2011
        
         - rate-limit ==1.4.2

     

       1999
       2012
        
         - ratel-wai ==1.1.5

     

       2000
       2013
        
         - rattle ==0.2

     

       2001
       2001
       -
         - rattletrap ==11.0.1

     

       2014
       2014
       +
         - rattletrap ==11.1.0

     

       2002
       2015
        
         - Rattus ==0.5

     

       2003
       2016
        
         - rawfilepath ==0.2.4

     

       2004
       2017
        
         - rawstring-qm ==0.2.3.0

     
···

       2059
       2072
        
         - resolv ==0.1.2.0

     

       2060
       2073
        
         - resource-pool ==0.2.3.2

     

       2061
       2074
        
         - resourcet ==1.2.4.2

     

       2062
       2062
       -
         - resourcet-pool ==0.1.0.0

     

       2063
       2075
        
         - result ==0.2.6.0

     

       2064
       2076
        
         - rethinkdb-client-driver ==0.0.25

     

       2065
       2077
        
         - retry ==0.8.1.2

     
···

       2103
       2115
        
         - sample-frame ==0.0.3

     

       2104
       2116
        
         - sample-frame-np ==0.0.4.1

     

       2105
       2117
        
         - sampling ==0.3.5

     

       2118
       2118
       +
         - sandwich ==0.1.0.3

     

       2119
       2119
       +
         - sandwich-slack ==0.1.0.3

     

       2120
       2120
       +
         - sandwich-webdriver ==0.1.0.4

     

       2106
       2121
        
         - say ==0.1.0.1

     

       2107
       2122
        
         - sbp ==2.6.3

     

       2108
       2123
        
         - scalpel ==0.6.2

     
···

       2146
       2161
        
         - serf ==0.1.1.0

     

       2147
       2162
        
         - serialise ==0.2.3.0

     

       2148
       2163
        
         - servant ==0.18.2

     

       2164
       2164
       +
         - servant-auth ==0.4.0.0

     

       2165
       2165
       +
         - servant-auth-client ==0.4.1.0

     

       2166
       2166
       +
         - servant-auth-docs ==0.2.10.0

     

       2167
       2167
       +
         - servant-auth-server ==0.4.6.0

     

       2168
       2168
       +
         - servant-auth-swagger ==0.2.10.1

     

       2149
       2169
        
         - servant-blaze ==0.9.1

     

       2150
       2170
        
         - servant-client ==0.18.2

     

       2151
       2171
        
         - servant-client-core ==0.18.2

     

       2152
       2172
        
         - servant-conduit ==0.15.1

     

       2153
       2173
        
         - servant-docs ==0.11.8

     

       2174
       2174
       +
         - servant-elm ==0.7.2

     

       2154
       2175
        
         - servant-errors ==0.1.6.0

     

       2155
       2176
        
         - servant-exceptions ==0.2.1

     

       2156
       2177
        
         - servant-exceptions-server ==0.2.1

     
···

       2158
       2179
        
         - servant-http-streams ==0.18.2

     

       2159
       2180
        
         - servant-machines ==0.15.1

     

       2160
       2181
        
         - servant-multipart ==0.12

     

       2161
       2161
       -
         - servant-openapi3 ==2.0.1.1

     

       2182
       2182
       +
         - servant-openapi3 ==2.0.1.2

     

       2162
       2183
        
         - servant-pipes ==0.15.2

     

       2163
       2184
        
         - servant-rawm ==1.0.0.0

     

       2164
       2185
        
         - servant-server ==0.18.2

     

       2165
       2186
        
         - servant-swagger ==1.1.10

     

       2166
       2166
       -
         - servant-swagger-ui ==0.3.4.3.37.2

     

       2167
       2167
       -
         - servant-swagger-ui-core ==0.3.4

     

       2187
       2187
       +
         - servant-swagger-ui ==0.3.5.3.47.1

     

       2188
       2188
       +
         - servant-swagger-ui-core ==0.3.5

     

       2168
       2189
        
         - serverless-haskell ==0.12.6

     

       2169
       2190
        
         - serversession ==1.0.2

     

       2170
       2191
        
         - serversession-frontend-wai ==1.0

     
···

       2240
       2261
        
         - sop-core ==0.5.0.1

     

       2241
       2262
        
         - sort ==1.0.0.0

     

       2242
       2263
        
         - sorted-list ==0.2.1.0

     

       2243
       2243
       -
         - sourcemap ==0.1.6

     

       2264
       2264
       +
         - sourcemap ==0.1.6.1

     

       2244
       2265
        
         - sox ==0.2.3.1

     

       2245
       2266
        
         - soxlib ==0.0.3.1

     

       2246
       2267
        
         - spacecookie ==1.0.0.0

     
···

       2248
       2269
        
         - sparse-tensor ==0.2.1.5

     

       2249
       2270
        
         - spatial-math ==0.5.0.1

     

       2250
       2271
        
         - special-values ==0.1.0.0

     

       2251
       2251
       -
         - speculate ==0.4.4

     

       2272
       2272
       +
         - speculate ==0.4.6

     

       2252
       2273
        
         - speedy-slice ==0.3.2

     

       2253
       2274
        
         - Spintax ==0.3.6

     

       2254
       2275
        
         - splice ==0.6.1.1

     
···

       2289
       2310
        
         - storable-record ==0.0.5

     

       2290
       2311
        
         - storable-tuple ==0.0.3.3

     

       2291
       2312
        
         - storablevector ==0.2.13.1

     

       2292
       2292
       -
         - store ==0.7.10

     

       2313
       2313
       +
         - store ==0.7.11

     

       2293
       2314
        
         - store-core ==0.4.4.4

     

       2294
       2315
        
         - store-streaming ==0.2.0.3

     

       2295
       2316
        
         - stratosphere ==0.59.1

     
···

       2459
       2480
        
         - th-test-utils ==1.1.0

     

       2460
       2481
        
         - th-utilities ==0.2.4.3

     

       2461
       2482
        
         - thyme ==0.3.5.5

     

       2462
       2462
       -
         - tidal ==1.7.3

     

       2483
       2483
       +
         - tidal ==1.7.4

     

       2463
       2484
        
         - tile ==0.3.0.0

     

       2464
       2485
        
         - time-compat ==1.9.5

     

       2465
       2486
        
         - timeit ==2.0

     
···

       2645
       2666
        
         - wai-rate-limit-redis ==0.1.0.0

     

       2646
       2667
        
         - wai-saml2 ==0.2.1.2

     

       2647
       2668
        
         - wai-session ==0.3.3

     

       2669
       2669
       +
         - wai-session-redis ==0.1.0.1

     

       2648
       2670
        
         - wai-slack-middleware ==0.2.0

     

       2649
       2671
        
         - wai-websockets ==3.0.1.2

     

       2650
       2672
        
         - wakame ==0.1.0.0

     

       2651
       2651
       -
         - warp ==3.3.14

     

       2673
       2673
       +
         - warp ==3.3.15

     

       2652
       2674
        
         - warp-tls ==3.3.0

     

       2653
       2675
        
         - warp-tls-uid ==0.2.0.6

     

       2654
       2676
        
         - wave ==0.2.0

     
···

       2670
       2692
        
         - Win32 ==2.6.1.0

     

       2671
       2693
        
         - Win32-notify ==0.3.0.3

     

       2672
       2694
        
         - windns ==0.1.0.1

     

       2673
       2673
       -
         - witch ==0.0.0.5

     

       2695
       2695
       +
         - witch ==0.2.0.2

     

       2674
       2696
        
         - witherable ==0.4.1

     

       2675
       2697
        
         - within ==0.2.0.1

     

       2676
       2698
        
         - with-location ==0.1.0

     
···

       2707
       2729
        
         - xlsx-tabular ==0.2.2.1

     

       2708
       2730
        
         - xml ==1.3.14

     

       2709
       2731
        
         - xml-basic ==0.1.3.1

     

       2710
       2710
       -
         - xml-conduit ==1.9.1.0

     

       2732
       2732
       +
         - xml-conduit ==1.9.1.1

     

       2711
       2733
        
         - xml-conduit-writer ==0.1.1.2

     

       2712
       2734
        
         - xmlgen ==0.6.2.2

     

       2713
       2735
        
         - xml-hamlet ==0.5.0.1

     
···

       2726
       2748
        
         - xxhash-ffi ==0.2.0.0

     

       2727
       2749
        
         - yaml ==0.11.5.0

     

       2728
       2750
        
         - yamlparse-applicative ==0.1.0.3

     

       2729
       2729
       -
         - yesod ==1.6.1.0

     

       2730
       2730
       -
         - yesod-auth ==1.6.10.2

     

       2731
       2731
       -
         - yesod-auth-hashdb ==1.7.1.5

     

       2751
       2751
       +
         - yesod ==1.6.1.1

     

       2752
       2752
       +
         - yesod-auth ==1.6.10.3

     

       2753
       2753
       +
         - yesod-auth-hashdb ==1.7.1.6

     

       2732
       2754
        
         - yesod-auth-oauth2 ==0.6.3.0

     

       2733
       2755
        
         - yesod-bin ==1.6.1

     

       2734
       2756
        
         - yesod-core ==1.6.19.0

     

       2735
       2757
        
         - yesod-fb ==0.6.1

     

       2736
       2758
        
         - yesod-form ==1.6.7

     

       2737
       2759
        
         - yesod-gitrev ==0.2.1

     

       2738
       2738
       -
         - yesod-markdown ==0.12.6.8

     

       2760
       2760
       +
         - yesod-markdown ==0.12.6.9

     

       2739
       2761
        
         - yesod-newsfeed ==1.7.0.0

     

       2740
       2762
        
         - yesod-page-cursor ==2.0.0.6

     

       2741
       2763
        
         - yesod-paginator ==1.1.1.0

     
···

       2857
       2879
        
         cdepillabout:

     

       2858
       2880
        
           - pretty-simple

     

       2859
       2881
        
           - spago

     

       2860
       2860
       -
         rkrzr:

     

       2861
       2861
       -
           - icepeak

     

       2862
       2882
        
         terlar:

     

       2863
       2883
        
           - nix-diff

     

       2864
       2884
        
         maralorn:

     
···

       3195
       3215
        
         - afv

     

       3196
       3216
        
         - ag-pictgen

     

       3197
       3217
        
         - Agata

     

       3218
       3218
       +
         - agda-language-server

     

       3198
       3219
        
         - agda-server

     

       3199
       3220
        
         - agda-snippets

     

       3200
       3221
        
         - agda-snippets-hakyll

     
···

       3399
       3420
        
         - asn1-data

     

       3400
       3421
        
         - assert

     

       3401
       3422
        
         - assert4hs

     

       3423
       3423
       +
         - assert4hs-core

     

       3424
       3424
       +
         - assert4hs-hspec

     

       3402
       3425
        
         - assert4hs-tasty

     

       3403
       3426
        
         - assertions

     

       3404
       3427
        
         - asset-map

     
···

       3802
       3825
        
         - boring-window-switcher

     

       3803
       3826
        
         - bot

     

       3804
       3827
        
         - botpp

     

       3828
       3828
       +
         - bottom

     

       3805
       3829
        
         - bound-extras

     

       3806
       3830
        
         - bounded-array

     

       3807
       3831
        
         - bowntz

     
···

       4027
       4051
        
         - catnplus

     

       4028
       4052
        
         - cautious-file

     

       4029
       4053
        
         - cautious-gen

     

       4054
       4054
       +
         - cayene-lpp

     

       4030
       4055
        
         - cayley-client

     

       4031
       4056
        
         - CBOR

     

       4032
       4057
        
         - CC-delcont-alt

     
···

       4305
       4330
        
         - computational-algebra

     

       4306
       4331
        
         - computational-geometry

     

       4307
       4332
        
         - computations

     

       4333
       4333
       +
         - ConClusion

     

       4308
       4334
        
         - concraft

     

       4309
       4335
        
         - concraft-hr

     

       4310
       4336
        
         - concraft-pl

     
···

       4879
       4905
        
         - docker

     

       4880
       4906
        
         - docker-build-cacher

     

       4881
       4907
        
         - dockercook

     

       4908
       4908
       +
         - dockerfile-creator

     

       4882
       4909
        
         - docopt

     

       4883
       4910
        
         - docrecords

     

       4884
       4911
        
         - DocTest

     
···

       5543
       5570
        
         - funpat

     

       5544
       5571
        
         - funsat

     

       5545
       5572
        
         - funspection

     

       5573
       5573
       +
         - fused-effects-exceptions

     

       5546
       5574
        
         - fused-effects-resumable

     

       5547
       5575
        
         - fused-effects-squeal

     

       5548
       5576
        
         - fused-effects-th

     
···

       5612
       5640
        
         - generic-lens-labels

     

       5613
       5641
        
         - generic-lucid-scaffold

     

       5614
       5642
        
         - generic-maybe

     

       5643
       5643
       +
         - generic-optics

     

       5615
       5644
        
         - generic-override-aeson

     

       5616
       5645
        
         - generic-pretty

     

       5617
       5646
        
         - generic-server

     
···

       5699
       5728
        
         - ghcup

     

       5700
       5729
        
         - ght

     

       5701
       5730
        
         - gi-cairo-again

     

       5731
       5731
       +
         - gi-gmodule

     

       5702
       5732
        
         - gi-graphene

     

       5703
       5733
        
         - gi-gsk

     

       5704
       5734
        
         - gi-gstaudio

     
···

       5708
       5738
        
         - gi-gtksheet

     

       5709
       5739
        
         - gi-handy

     

       5710
       5740
        
         - gi-poppler

     

       5741
       5741
       +
         - gi-vips

     

       5711
       5742
        
         - gi-wnck

     

       5712
       5743
        
         - giak

     

       5713
       5744
        
         - Gifcurry

     
···

       5837
       5868
        
         - gpah

     

       5838
       5869
        
         - GPipe

     

       5839
       5870
        
         - GPipe-Collada

     

       5871
       5871
       +
         - GPipe-Core

     

       5840
       5872
        
         - GPipe-Examples

     

       5841
       5873
        
         - GPipe-GLFW

     

       5874
       5874
       +
         - GPipe-GLFW4

     

       5842
       5875
        
         - GPipe-TextureLoad

     

       5843
       5876
        
         - gps

     

       5844
       5877
        
         - gps2htmlReport

     
···

       6564
       6597
        
         - hipchat-hs

     

       6565
       6598
        
         - hipe

     

       6566
       6599
        
         - Hipmunk-Utils

     

       6600
       6600
       +
         - hipsql-api

     

       6601
       6601
       +
         - hipsql-client

     

       6602
       6602
       +
         - hipsql-server

     

       6567
       6603
        
         - hircules

     

       6568
       6604
        
         - hirt

     

       6569
       6605
        
         - Hish

     
···

       6945
       6981
        
         - htdp-image

     

       6946
       6982
        
         - hTensor

     

       6947
       6983
        
         - htestu

     

       6948
       6948
       -
         - HTF

     

       6949
       6984
        
         - HTicTacToe

     

       6950
       6985
        
         - htiled

     

       6951
       6986
        
         - htlset

     
···

       6983
       7018
        
         - http-server

     

       6984
       7019
        
         - http-shed

     

       6985
       7020
        
         - http-wget

     

       7021
       7021
       +
         - http2-client

     

       7022
       7022
       +
         - http2-client-exe

     

       6986
       7023
        
         - http2-client-grpc

     

       6987
       7024
        
         - http2-grpc-proto-lens

     

       6988
       7025
        
         - http2-grpc-proto3-wire

     
···

       7093
       7130
        
         - iban

     

       7094
       7131
        
         - ical

     

       7095
       7132
        
         - ice40-prim

     

       7133
       7133
       +
         - icepeak

     

       7096
       7134
        
         - IcoGrid

     

       7097
       7135
        
         - iconv-typed

     

       7098
       7136
        
         - ide-backend

     
···

       7274
       7312
        
         - isobmff-builder

     

       7275
       7313
        
         - isohunt

     

       7276
       7314
        
         - isotope

     

       7315
       7315
       +
         - it-has

     

       7277
       7316
        
         - itcli

     

       7278
       7317
        
         - itemfield

     

       7279
       7318
        
         - iter-stats

     
···

       8639
       8678
        
         - ois-input-manager

     

       8640
       8679
        
         - olwrapper

     

       8641
       8680
        
         - om-actor

     

       8681
       8681
       +
         - om-doh

     

       8642
       8682
        
         - om-elm

     

       8643
       8683
        
         - om-fail

     

       8644
       8684
        
         - om-http-logging

     
···

       8674
       8714
        
         - openai-servant

     

       8675
       8715
        
         - openapi-petstore

     

       8676
       8716
        
         - openapi-typed

     

       8677
       8677
       -
         - openapi3

     

       8678
       8717
        
         - openapi3-code-generator

     

       8679
       8718
        
         - opench-meteo

     

       8680
       8719
        
         - OpenCL

     
···

       8728
       8767
        
         - org-mode-lucid

     

       8729
       8768
        
         - organize-imports

     

       8730
       8769
        
         - orgmode

     

       8731
       8731
       -
         - orgstat

     

       8732
       8770
        
         - origami

     

       8733
       8771
        
         - orizentic

     

       8734
       8772
        
         - OrPatterns

     
···

       8911
       8949
        
         - perfecthash

     

       8912
       8950
        
         - perhaps

     

       8913
       8951
        
         - periodic

     

       8952
       8952
       +
         - periodic-client

     

       8953
       8953
       +
         - periodic-client-exe

     

       8954
       8954
       +
         - periodic-common

     

       8914
       8955
        
         - periodic-server

     

       8915
       8956
        
         - perm

     

       8916
       8957
        
         - permutation

     
···

       9085
       9126
        
         - polynomial

     

       9086
       9127
        
         - polysemy-chronos

     

       9087
       9128
        
         - polysemy-conc

     

       9129
       9129
       +
         - polysemy-extra

     

       9130
       9130
       +
         - polysemy-fskvstore

     

       9088
       9131
        
         - polysemy-http

     

       9132
       9132
       +
         - polysemy-kvstore-jsonfile

     

       9089
       9133
        
         - polysemy-log

     

       9090
       9134
        
         - polysemy-log-co

     

       9091
       9135
        
         - polysemy-log-di

     
···

       9097
       9141
        
         - polysemy-resume

     

       9098
       9142
        
         - polysemy-test

     

       9099
       9143
        
         - polysemy-time

     

       9144
       9144
       +
         - polysemy-vinyl

     

       9145
       9145
       +
         - polysemy-zoo

     

       9100
       9146
        
         - polyseq

     

       9101
       9147
        
         - polytypeable

     

       9102
       9148
        
         - polytypeable-utils

     
···

       9626
       9672
        
         - remote-monad

     

       9627
       9673
        
         - remotion

     

       9628
       9674
        
         - render-utf8

     

       9675
       9675
       +
         - reorder-expression

     

       9629
       9676
        
         - repa-algorithms

     

       9630
       9677
        
         - repa-array

     

       9631
       9678
        
         - repa-bytestring

     
···

       9874
       9921
        
         - scalpel-search

     

       9875
       9922
        
         - scan-metadata

     

       9876
       9923
        
         - scan-vector-machine

     

       9924
       9924
       +
         - scanner-attoparsec

     

       9877
       9925
        
         - scc

     

       9878
       9926
        
         - scenegraph

     

       9879
       9927
        
         - scgi

     
···

       9994
       10042
        
         - servant-auth-token-rocksdb

     

       9995
       10043
        
         - servant-auth-wordpress

     

       9996
       10044
        
         - servant-avro

     

       10045
       10045
       +
         - servant-benchmark

     

       9997
       10046
        
         - servant-cassava

     

       9998
       10047
        
         - servant-checked-exceptions

     

       9999
       10048
        
         - servant-checked-exceptions-core

     
···

       10028
       10077
        
         - servant-multipart

     

       10029
       10078
        
         - servant-namedargs

     

       10030
       10079
        
         - servant-nix

     

       10031
       10031
       -
         - servant-openapi3

     

       10032
       10080
        
         - servant-pagination

     

       10033
       10081
        
         - servant-pandoc

     

       10034
       10082
        
         - servant-polysemy

     
···

       11380
       11428
        
         - vector-clock

     

       11381
       11429
        
         - vector-conduit

     

       11382
       11430
        
         - vector-endian

     

       11431
       11431
       +
         - vector-fftw

     

       11383
       11432
        
         - vector-functorlazy

     

       11384
       11433
        
         - vector-heterogenous

     

       11385
       11434
        
         - vector-instances-collections

     
···

       11493
       11542
        
         - wai-session-alt

     

       11494
       11543
        
         - wai-session-mysql

     

       11495
       11544
        
         - wai-session-postgresql

     

       11545
       11545
       +
         - wai-session-redis

     

       11496
       11546
        
         - wai-static-cache

     

       11497
       11547
        
         - wai-thrift

     

       11498
       11548
        
         - wai-throttler

     
···

       11502
       11552
        
         - wallpaper

     

       11503
       11553
        
         - warc

     

       11504
       11554
        
         - warp-dynamic

     

       11555
       11555
       +
         - warp-grpc

     

       11505
       11556
        
         - warp-static

     

       11506
       11557
        
         - warp-systemd

     

       11507
       11558
        
         - warped

+876 -889

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

···

       3486
       3486
        
              broken = true;

     

       3487
       3487
        
            }) {};

     

       3488
       3488
        
       

     

       3489
       3489
       +
         "ConClusion" = callPackage

     

       3490
       3490
       +
           ({ mkDerivation, aeson, attoparsec, base, cmdargs, containers

     

       3491
       3491
       +
            , formatting, hmatrix, massiv, optics, PSQueue, rio, text

     

       3492
       3492
       +
            }:

     

       3493
       3493
       +
            mkDerivation {

     

       3494
       3494
       +
              pname = "ConClusion";

     

       3495
       3495
       +
              version = "0.0.1";

     

       3496
       3496
       +
              sha256 = "1qdwirr2gp5aq8dl5ibj1gb9mg2qd1jhpg610wy4yx2ymy4msg1p";

     

       3497
       3497
       +
              isLibrary = true;

     

       3498
       3498
       +
              isExecutable = true;

     

       3499
       3499
       +
              libraryHaskellDepends = [

     

       3500
       3500
       +
                aeson attoparsec base containers formatting hmatrix massiv PSQueue

     

       3501
       3501
       +
                rio

     

       3502
       3502
       +
              ];

     

       3503
       3503
       +
              executableHaskellDepends = [

     

       3504
       3504
       +
                aeson attoparsec base cmdargs containers formatting hmatrix massiv

     

       3505
       3505
       +
                optics PSQueue rio text

     

       3506
       3506
       +
              ];

     

       3507
       3507
       +
              description = "Cluster algorithms, PCA, and chemical conformere analysis";

     

       3508
       3508
       +
              license = lib.licenses.agpl3Only;

     

       3509
       3509
       +
              hydraPlatforms = lib.platforms.none;

     

       3510
       3510
       +
              broken = true;

     

       3511
       3511
       +
            }) {};

     

       3512
       3512
       +
       

     

       3489
       3513
        
         "Concurrent-Cache" = callPackage

     

       3490
       3514
        
           ({ mkDerivation, base }:

     

       3491
       3515
        
            mkDerivation {

     
···

       6505
       6529
        
            }:

     

       6506
       6530
        
            mkDerivation {

     

       6507
       6531
        
              pname = "Frames-map-reduce";

     

       6508
       6508
       -
              version = "0.4.0.0";

     

       6509
       6509
       -
              sha256 = "1ajqkzg3q59hg1gwbamff72j9sxljqq7sghrqw5xbnxfd4867dcf";

     

       6532
       6532
       +
              version = "0.4.1.1";

     

       6533
       6533
       +
              sha256 = "0cxk86bbl6mbpg7ywb5cm8kfixl508gww8yxq6vwyrxbs7q4j25z";

     

       6510
       6534
        
              libraryHaskellDepends = [

     

       6511
       6535
        
                base containers foldl Frames hashable map-reduce-folds newtype

     

       6512
       6536
        
                profunctors vinyl

     
···

       6521
       6545
        
            }) {};

     

       6522
       6546
        
       

     

       6523
       6547
        
         "Frames-streamly" = callPackage

     

       6524
       6524
       -
           ({ mkDerivation, base, exceptions, Frames, primitive, streamly

     

       6525
       6525
       -
            , text, vinyl

     

       6548
       6548
       +
           ({ mkDerivation, base, binary, bytestring

     

       6549
       6549
       +
            , bytestring-strict-builder, cereal, clock, exceptions

     

       6550
       6550
       +
            , fast-builder, foldl, Frames, mtl, primitive, relude, streamly

     

       6551
       6551
       +
            , streamly-bytestring, strict, text, vector, vinyl

     

       6526
       6552
        
            }:

     

       6527
       6553
        
            mkDerivation {

     

       6528
       6554
        
              pname = "Frames-streamly";

     

       6529
       6529
       -
              version = "0.1.0.2";

     

       6530
       6530
       -
              sha256 = "0i007clm5q2rjmj7qfyig4sajk2bi1fc57w132j4vrvgp3p9p4rr";

     

       6555
       6555
       +
              version = "0.1.1.0";

     

       6556
       6556
       +
              sha256 = "16cxgar58q9gfbs8apl4a9z3ghdxb6m042di7hwhldqy0gn584fp";

     

       6531
       6557
        
              enableSeparateDataOutput = true;

     

       6532
       6558
        
              libraryHaskellDepends = [

     

       6533
       6533
       -
                base exceptions Frames primitive streamly text vinyl

     

       6559
       6559
       +
                base exceptions Frames primitive relude streamly strict text vinyl

     

       6560
       6560
       +
              ];

     

       6561
       6561
       +
              testHaskellDepends = [

     

       6562
       6562
       +
                base binary bytestring bytestring-strict-builder cereal clock

     

       6563
       6563
       +
                fast-builder foldl Frames mtl primitive relude streamly

     

       6564
       6564
       +
                streamly-bytestring strict text vector vinyl

     

       6534
       6565
        
              ];

     

       6535
       6535
       -
              testHaskellDepends = [ base Frames streamly text vinyl ];

     

       6536
       6566
        
              description = "A streamly layer for Frames I/O";

     

       6537
       6567
        
              license = lib.licenses.bsd3;

     

       6538
       6568
        
            }) {};

     
···

       6898
       6928
        
              benchmarkHaskellDepends = [ base criterion lens ];

     

       6899
       6929
        
              description = "Typesafe functional GPU graphics programming";

     

       6900
       6930
        
              license = lib.licenses.mit;

     

       6931
       6931
       +
              hydraPlatforms = lib.platforms.none;

     

       6932
       6932
       +
              broken = true;

     

       6901
       6933
        
            }) {};

     

       6902
       6934
        
       

     

       6903
       6935
        
         "GPipe-Examples" = callPackage

     
···

       6960
       6992
        
              ];

     

       6961
       6993
        
              description = "GLFW OpenGL context creation for GPipe";

     

       6962
       6994
        
              license = lib.licenses.mit;

     

       6995
       6995
       +
              hydraPlatforms = lib.platforms.none;

     

       6996
       6996
       +
              broken = true;

     

       6963
       6997
        
            }) {};

     

       6964
       6998
        
       

     

       6965
       6999
        
         "GPipe-TextureLoad" = callPackage

     
···

       9469
       9503
        
              ];

     

       9470
       9504
        
              description = "The Haskell Test Framework";

     

       9471
       9505
        
              license = lib.licenses.lgpl21Only;

     

       9472
       9472
       -
              hydraPlatforms = lib.platforms.none;

     

       9473
       9473
       -
              broken = true;

     

       9474
       9506
        
            }) {};

     

       9475
       9507
        
       

     

       9476
       9508
        
         "HTTP" = callPackage

     
···

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

     

       10856
       10888
        
            mkDerivation {

     

       10857
       10889
        
              pname = "HsOpenSSL";

     

       10858
       10858
       -
              version = "0.11.6.2";

     

       10859
       10859
       -
              sha256 = "160fpl2lcardzf4gy5dimhad69gvkkvnpp5nqbf8fcxzm4vgg76y";

     

       10860
       10860
       -
              setupHaskellDepends = [ base Cabal ];

     

       10861
       10861
       -
              libraryHaskellDepends = [ base bytestring network time ];

     

       10862
       10862
       -
              librarySystemDepends = [ openssl ];

     

       10863
       10863
       -
              testHaskellDepends = [ base bytestring ];

     

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

     

       10865
       10865
       -
              license = lib.licenses.publicDomain;

     

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

     

       10867
       10867
       -
       

     

       10868
       10868
       -
         "HsOpenSSL_0_11_7" = callPackage

     

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

     

       10870
       10870
       -
            mkDerivation {

     

       10871
       10871
       -
              pname = "HsOpenSSL";

     

       10872
       10890
        
              version = "0.11.7";

     

       10873
       10891
        
              sha256 = "0kji758bi8agcjvpbb3hpppv55qm9g2r02mamiv568zwmlkkxsm3";

     

       10874
       10892
        
              setupHaskellDepends = [ base Cabal ];

     
···

       10877
       10895
        
              testHaskellDepends = [ base bytestring ];

     

       10878
       10896
        
              description = "Partial OpenSSL binding for Haskell";

     

       10879
       10897
        
              license = lib.licenses.publicDomain;

     

       10880
       10880
       -
              hydraPlatforms = lib.platforms.none;

     

       10881
       10898
        
            }) {inherit (pkgs) openssl;};

     

       10882
       10899
        
       

     

       10883
       10900
        
         "HsOpenSSL-x509-system" = callPackage

     
···

       13855
       13872
        
              pname = "MonadRandom";

     

       13856
       13873
        
              version = "0.5.3";

     

       13857
       13874
        
              sha256 = "17qaw1gg42p9v6f87dj5vih7l88lddbyd8880ananj8avanls617";

     

       13875
       13875
       +
              revision = "1";

     

       13876
       13876
       +
              editedCabalFile = "1wpgmcv704i7x38jwalnbmx8c10vdw269gbvzjxaj4rlvff3s4sq";

     

       13858
       13877
        
              libraryHaskellDepends = [

     

       13859
       13878
        
                base mtl primitive random transformers transformers-compat

     

       13860
       13879
        
              ];

     
···

       16257
       16276
        
              license = lib.licenses.bsd3;

     

       16258
       16277
        
              hydraPlatforms = lib.platforms.none;

     

       16259
       16278
        
              broken = true;

     

       16279
       16279
       +
            }) {};

     

       16280
       16280
       +
       

     

       16281
       16281
       +
         "Probnet" = callPackage

     

       16282
       16282
       +
           ({ mkDerivation, base }:

     

       16283
       16283
       +
            mkDerivation {

     

       16284
       16284
       +
              pname = "Probnet";

     

       16285
       16285
       +
              version = "0.1.0.2";

     

       16286
       16286
       +
              sha256 = "1jk1y51rda8j4lan2az906fwb5hgqb8s50p0xrhchnf654scm851";

     

       16287
       16287
       +
              libraryHaskellDepends = [ base ];

     

       16288
       16288
       +
              description = "Geometric Extrapolation of Integer Sequences with error prediction";

     

       16289
       16289
       +
              license = lib.licenses.mit;

     

       16260
       16290
        
            }) {};

     

       16261
       16291
        
       

     

       16262
       16292
        
         "PropLogic" = callPackage

     
···

       22096
       22126
        
            }:

     

       22097
       22127
        
            mkDerivation {

     

       22098
       22128
        
              pname = "Z-IO";

     

       22099
       22099
       -
              version = "0.7.1.0";

     

       22100
       22100
       -
              sha256 = "18d2q9fg4ydqpnrzvpcx1arjv4yl2966aax68fz3izgmsbp95k0l";

     

       22129
       22129
       +
              version = "0.8.0.0";

     

       22130
       22130
       +
              sha256 = "000ziih2c33v5mbf9sljkrr0x9hxv31cq77blva6xy32zzh12yz3";

     

       22101
       22131
        
              isLibrary = true;

     

       22102
       22132
        
              isExecutable = true;

     

       22103
       22133
        
              libraryHaskellDepends = [

     
···

       22124
       22154
        
            }:

     

       22125
       22155
        
            mkDerivation {

     

       22126
       22156
        
              pname = "Z-MessagePack";

     

       22127
       22127
       -
              version = "0.4.0.1";

     

       22128
       22128
       -
              sha256 = "1i1ycf1bhahbh7d9rvz4hl5jq16mld8sya2h2xrxlvg9yqab19hy";

     

       22157
       22157
       +
              version = "0.4.1.0";

     

       22158
       22158
       +
              sha256 = "0sq4w488dyhk3nxgdw394i9n79j45hhxp3yzgw2fpmjh9xwfv1m9";

     

       22129
       22159
        
              libraryHaskellDepends = [

     

       22130
       22160
        
                base containers deepseq hashable integer-gmp primitive QuickCheck

     

       22131
       22161
        
                scientific tagged time unordered-containers Z-Data Z-IO

     
···

       22148
       22178
        
            }:

     

       22149
       22179
        
            mkDerivation {

     

       22150
       22180
        
              pname = "Z-YAML";

     

       22151
       22151
       -
              version = "0.3.2.0";

     

       22152
       22152
       -
              sha256 = "01v0vza54lpxijg4znp2pcnjw2z6ybvx453xqy7ljwf9289csfq8";

     

       22181
       22181
       +
              version = "0.3.3.0";

     

       22182
       22182
       +
              sha256 = "012flgd88rwya7g5lkbla4841pzq2b1b9m4jkmggk38kpbrhf515";

     

       22153
       22183
        
              libraryHaskellDepends = [

     

       22154
       22184
        
                base primitive scientific transformers unordered-containers Z-Data

     

       22155
       22185
        
                Z-IO

     
···

       25611
       25641
        
              ];

     

       25612
       25642
        
              description = "LSP server for Agda";

     

       25613
       25643
        
              license = lib.licenses.mit;

     

       25644
       25644
       +
              hydraPlatforms = lib.platforms.none;

     

       25645
       25645
       +
              broken = true;

     

       25614
       25646
        
            }) {};

     

       25615
       25647
        
       

     

       25616
       25648
        
         "agda-server" = callPackage

     
···

       34124
       34156
        
              testToolDepends = [ hspec-discover ];

     

       34125
       34157
        
              description = "A set of assertion for writing more readable tests cases";

     

       34126
       34158
        
              license = lib.licenses.mit;

     

       34159
       34159
       +
              hydraPlatforms = lib.platforms.none;

     

       34160
       34160
       +
              broken = true;

     

       34127
       34161
        
            }) {};

     

       34128
       34162
        
       

     

       34129
       34163
        
         "assert4hs-hspec" = callPackage

     
···

       34136
       34170
        
              testHaskellDepends = [ assert4hs-core base hspec HUnit ];

     

       34137
       34171
        
              description = "integration point of assert4hs and hspec";

     

       34138
       34172
        
              license = lib.licenses.mit;

     

       34173
       34173
       +
              hydraPlatforms = lib.platforms.none;

     

       34174
       34174
       +
              broken = true;

     

       34139
       34175
        
            }) {};

     

       34140
       34176
        
       

     

       34141
       34177
        
         "assert4hs-tasty" = callPackage

     
···

       38764
       38800
        
           ({ mkDerivation, base, ghc-prim }:

     

       38765
       38801
        
            mkDerivation {

     

       38766
       38802
        
              pname = "basement";

     

       38767
       38767
       -
              version = "0.0.11";

     

       38768
       38768
       -
              sha256 = "0srlws74yiraqaapgcjd9p5d1fwb3zr9swcz74jpjm55fls2nn37";

     

       38769
       38769
       -
              revision = "3";

     

       38770
       38770
       -
              editedCabalFile = "1indgsrk0yhkbqlxj39qqb5xqicwkmcliggb8wn87vgfswxpi1dn";

     

       38803
       38803
       +
              version = "0.0.12";

     

       38804
       38804
       +
              sha256 = "12zsnxkgv86im2prslk6ddhy0zwpawwjc1h4ff63kpxp2xdl7i2k";

     

       38771
       38805
        
              libraryHaskellDepends = [ base ghc-prim ];

     

       38772
       38806
        
              description = "Foundation scrap box of array & string";

     

       38773
       38807
        
              license = lib.licenses.bsd3;

     
···

       40428
       40462
        
              license = lib.licenses.bsd3;

     

       40429
       40463
        
            }) {};

     

       40430
       40464
        
       

     

       40465
       40465
       +
         "bifunctors_5_5_11" = callPackage

     

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

     

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

     

       40468
       40468
       +
            , th-abstraction, transformers, transformers-compat

     

       40469
       40469
       +
            }:

     

       40470
       40470
       +
            mkDerivation {

     

       40471
       40471
       +
              pname = "bifunctors";

     

       40472
       40472
       +
              version = "5.5.11";

     

       40473
       40473
       +
              sha256 = "070964w7gz578379lyj6xvdbcf367csmz22cryarjr5bz9r9csrb";

     

       40474
       40474
       +
              libraryHaskellDepends = [

     

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

     

       40476
       40476
       +
                th-abstraction transformers

     

       40477
       40477
       +
              ];

     

       40478
       40478
       +
              testHaskellDepends = [

     

       40479
       40479
       +
                base hspec QuickCheck template-haskell transformers

     

       40480
       40480
       +
                transformers-compat

     

       40481
       40481
       +
              ];

     

       40482
       40482
       +
              testToolDepends = [ hspec-discover ];

     

       40483
       40483
       +
              description = "Bifunctors";

     

       40484
       40484
       +
              license = lib.licenses.bsd3;

     

       40485
       40485
       +
              hydraPlatforms = lib.platforms.none;

     

       40486
       40486
       +
            }) {};

     

       40487
       40487
       +
       

     

       40431
       40488
        
         "bighugethesaurus" = callPackage

     

       40432
       40489
        
           ({ mkDerivation, base, HTTP, split }:

     

       40433
       40490
        
            mkDerivation {

     
···

       44493
       44550
        
            }:

     

       44494
       44551
        
            mkDerivation {

     

       44495
       44552
        
              pname = "blucontrol";

     

       44496
       44496
       -
              version = "0.3.0.0";

     

       44497
       44497
       -
              sha256 = "0xh1qxfmrfjdsprl5m748j5z9w0qmww8gkj8lhghfskdzxhy0qic";

     

       44553
       44553
       +
              version = "0.3.0.1";

     

       44554
       44554
       +
              sha256 = "06hmk4pg5qfcj6smzpn549d1jcsvcbgi2pxgvgvn9k7lab9cb5kg";

     

       44498
       44555
        
              isLibrary = true;

     

       44499
       44556
        
              isExecutable = true;

     

       44500
       44557
        
              libraryHaskellDepends = [

     
···

       45475
       45532
        
              ];

     

       45476
       45533
        
              description = "Encoding and decoding for the Bottom spec";

     

       45477
       45534
        
              license = lib.licenses.asl20;

     

       45535
       45535
       +
              hydraPlatforms = lib.platforms.none;

     

       45536
       45536
       +
              broken = true;

     

       45478
       45537
        
            }) {};

     

       45479
       45538
        
       

     

       45480
       45539
        
         "bound" = callPackage

     
···

       45929
       45988
        
              ];

     

       45930
       45989
        
              description = "A declarative terminal user interface library";

     

       45931
       45990
        
              license = lib.licenses.bsd3;

     

       45991
       45991
       +
            }) {};

     

       45992
       45992
       +
       

     

       45993
       45993
       +
         "brick_0_62" = callPackage

     

       45994
       45994
       +
           ({ mkDerivation, base, bytestring, config-ini, containers

     

       45995
       45995
       +
            , contravariant, data-clist, deepseq, directory, dlist, exceptions

     

       45996
       45996
       +
            , filepath, microlens, microlens-mtl, microlens-th, QuickCheck, stm

     

       45997
       45997
       +
            , template-haskell, text, text-zipper, transformers, unix, vector

     

       45998
       45998
       +
            , vty, word-wrap

     

       45999
       45999
       +
            }:

     

       46000
       46000
       +
            mkDerivation {

     

       46001
       46001
       +
              pname = "brick";

     

       46002
       46002
       +
              version = "0.62";

     

       46003
       46003
       +
              sha256 = "1f74m9yxwqv3xs1jhhpww2higfz3w0v1niff257wshhrvrkigh36";

     

       46004
       46004
       +
              isLibrary = true;

     

       46005
       46005
       +
              isExecutable = true;

     

       46006
       46006
       +
              libraryHaskellDepends = [

     

       46007
       46007
       +
                base bytestring config-ini containers contravariant data-clist

     

       46008
       46008
       +
                deepseq directory dlist exceptions filepath microlens microlens-mtl

     

       46009
       46009
       +
                microlens-th stm template-haskell text text-zipper transformers

     

       46010
       46010
       +
                unix vector vty word-wrap

     

       46011
       46011
       +
              ];

     

       46012
       46012
       +
              testHaskellDepends = [

     

       46013
       46013
       +
                base containers microlens QuickCheck vector

     

       46014
       46014
       +
              ];

     

       46015
       46015
       +
              description = "A declarative terminal user interface library";

     

       46016
       46016
       +
              license = lib.licenses.bsd3;

     

       46017
       46017
       +
              hydraPlatforms = lib.platforms.none;

     

       45932
       46018
        
            }) {};

     

       45933
       46019
        
       

     

       45934
       46020
        
         "brick-dropdownmenu" = callPackage

     
···

       47466
       47552
        
            }) {};

     

       47467
       47553
        
       

     

       47468
       47554
        
         "bv-sized" = callPackage

     

       47469
       47469
       -
           ({ mkDerivation, base, bitwise, bytestring, hedgehog, panic

     

       47470
       47470
       -
            , parameterized-utils, tasty, tasty-hedgehog, th-lift

     

       47555
       47555
       +
           ({ mkDerivation, base, bitwise, bytestring, deepseq, hedgehog

     

       47556
       47556
       +
            , MonadRandom, panic, parameterized-utils, random, tasty

     

       47557
       47557
       +
            , tasty-hedgehog, th-lift

     

       47471
       47558
        
            }:

     

       47472
       47559
        
            mkDerivation {

     

       47473
       47560
        
              pname = "bv-sized";

     

       47474
       47474
       -
              version = "1.0.2";

     

       47475
       47475
       -
              sha256 = "0lx7cm7404r71ciksv8g58797k6x02zh337ra88syhj7nzlnij5w";

     

       47561
       47561
       +
              version = "1.0.3";

     

       47562
       47562
       +
              sha256 = "1bqzj9gmx8lvfw037y4f3hibbcq6zafhm6xhjdhnvmlyc963n9v9";

     

       47476
       47563
        
              libraryHaskellDepends = [

     

       47477
       47477
       -
                base bitwise bytestring panic parameterized-utils th-lift

     

       47564
       47564
       +
                base bitwise bytestring deepseq panic parameterized-utils random

     

       47565
       47565
       +
                th-lift

     

       47478
       47566
        
              ];

     

       47479
       47567
        
              testHaskellDepends = [

     

       47480
       47480
       -
                base bytestring hedgehog parameterized-utils tasty tasty-hedgehog

     

       47568
       47568
       +
                base bytestring hedgehog MonadRandom parameterized-utils tasty

     

       47569
       47569
       +
                tasty-hedgehog

     

       47481
       47570
        
              ];

     

       47482
       47571
        
              description = "a bitvector datatype that is parameterized by the vector width";

     

       47483
       47572
        
              license = lib.licenses.bsd3;

     
···

       50416
       50505
        
            }:

     

       50417
       50506
        
            mkDerivation {

     

       50418
       50507
        
              pname = "calamity";

     

       50419
       50419
       -
              version = "0.1.28.4";

     

       50420
       50420
       -
              sha256 = "07ibhr3xngpwl7pq9ykbf6pxzlp8yx49d0qrlhyn7hj5xbswkv3f";

     

       50508
       50508
       +
              version = "0.1.28.5";

     

       50509
       50509
       +
              sha256 = "09ja2imqhz7kr97fhfskj1g7s7q88yrpa0p2s1n55fwkn1f2d3bs";

     

       50421
       50510
        
              libraryHaskellDepends = [

     

       50422
       50511
        
                aeson async base bytestring colour concurrent-extra connection

     

       50423
       50512
        
                containers data-default-class data-flags deepseq deque df1 di-core

     
···

       52429
       52518
        
              testHaskellDepends = [ base base16-bytestring hspec ];

     

       52430
       52519
        
              description = "Cayenne Low Power Payload";

     

       52431
       52520
        
              license = lib.licenses.bsd3;

     

       52521
       52521
       +
              hydraPlatforms = lib.platforms.none;

     

       52522
       52522
       +
              broken = true;

     

       52432
       52523
        
            }) {};

     

       52433
       52524
        
       

     

       52434
       52525
        
         "cayenne-lpp" = callPackage

     
···

       58068
       58159
        
            }:

     

       58069
       58160
        
            mkDerivation {

     

       58070
       58161
        
              pname = "cobot-io";

     

       58071
       58071
       -
              version = "0.1.3.18";

     

       58072
       58072
       -
              sha256 = "1xyri98rlg4ph9vyjicivq8vb1kk085pbpv43ydw6qvpqlp97wk5";

     

       58162
       58162
       +
              version = "0.1.3.19";

     

       58163
       58163
       +
              sha256 = "1gs4q04iyzzfwij58bbmhz2app3gf4xj0dnd4x4bhkgwj7gmvf4m";

     

       58073
       58164
        
              libraryHaskellDepends = [

     

       58074
       58165
        
                array attoparsec base binary bytestring containers data-msgpack

     

       58075
       58166
        
                deepseq http-conduit hyraxAbif lens linear mtl split text vector

     
···

       58123
       58214
        
              broken = true;

     

       58124
       58215
        
            }) {};

     

       58125
       58216
        
       

     

       58217
       58217
       +
         "code-conjure" = callPackage

     

       58218
       58218
       +
           ({ mkDerivation, base, express, leancheck, speculate

     

       58219
       58219
       +
            , template-haskell

     

       58220
       58220
       +
            }:

     

       58221
       58221
       +
            mkDerivation {

     

       58222
       58222
       +
              pname = "code-conjure";

     

       58223
       58223
       +
              version = "0.1.0";

     

       58224
       58224
       +
              sha256 = "0zagchakak4mrdpgy23d2wfb357dc6fn78fpcjs1ik025wmldy88";

     

       58225
       58225
       +
              libraryHaskellDepends = [

     

       58226
       58226
       +
                base express leancheck speculate template-haskell

     

       58227
       58227
       +
              ];

     

       58228
       58228
       +
              testHaskellDepends = [ base express leancheck speculate ];

     

       58229
       58229
       +
              description = "conjure Haskell functions out of partial definitions";

     

       58230
       58230
       +
              license = lib.licenses.bsd3;

     

       58231
       58231
       +
            }) {};

     

       58232
       58232
       +
       

     

       58126
       58233
        
         "code-page" = callPackage

     

       58127
       58234
        
           ({ mkDerivation, base }:

     

       58128
       58235
        
            mkDerivation {

     
···

       58758
       58865
        
              broken = true;

     

       58759
       58866
        
            }) {};

     

       58760
       58867
        
       

     

       58868
       58868
       +
         "collect-errors" = callPackage

     

       58869
       58869
       +
           ({ mkDerivation, base, containers, QuickCheck }:

     

       58870
       58870
       +
            mkDerivation {

     

       58871
       58871
       +
              pname = "collect-errors";

     

       58872
       58872
       +
              version = "0.1.0.0";

     

       58873
       58873
       +
              sha256 = "1zspgncbnn8zqixlxm3hrck3mk4j3n91515456w8dy220a0bzbhc";

     

       58874
       58874
       +
              libraryHaskellDepends = [ base containers QuickCheck ];

     

       58875
       58875
       +
              description = "Error monad with a Float instance";

     

       58876
       58876
       +
              license = lib.licenses.bsd3;

     

       58877
       58877
       +
            }) {};

     

       58878
       58878
       +
       

     

       58761
       58879
        
         "collection-json" = callPackage

     

       58762
       58880
        
           ({ mkDerivation, aeson, base, bytestring, hspec, hspec-discover

     

       58763
       58881
        
            , network-arbitrary, network-uri, network-uri-json, QuickCheck

     
···

       59201
       59319
        
            }) {};

     

       59202
       59320
        
       

     

       59203
       59321
        
         "combinat" = callPackage

     

       59204
       59204
       -
           ({ mkDerivation, array, base, containers, QuickCheck, random, tasty

     

       59205
       59205
       -
            , tasty-hunit, tasty-quickcheck, test-framework

     

       59206
       59206
       -
            , test-framework-quickcheck2, transformers

     

       59322
       59322
       +
           ({ mkDerivation, array, base, compact-word-vectors, containers

     

       59323
       59323
       +
            , QuickCheck, random, tasty, tasty-hunit, tasty-quickcheck

     

       59324
       59324
       +
            , test-framework, test-framework-quickcheck2, transformers

     

       59207
       59325
        
            }:

     

       59208
       59326
        
            mkDerivation {

     

       59209
       59327
        
              pname = "combinat";

     

       59210
       59210
       -
              version = "0.2.9.0";

     

       59211
       59211
       -
              sha256 = "1y617qyhqh2k6d51j94c0xnj54i7b86d87n0j12idxlkaiv4j5sw";

     

       59212
       59212
       -
              revision = "1";

     

       59213
       59213
       -
              editedCabalFile = "0yjvvxfmyzjhh0q050cc2wkhaahzixsw7hf27n8dky3n4cxd5bix";

     

       59328
       59328
       +
              version = "0.2.10.0";

     

       59329
       59329
       +
              sha256 = "125yf5ycya722k85iph3dqv63bpj1a862c0ahs2y0snyd2qd6h35";

     

       59214
       59330
        
              libraryHaskellDepends = [

     

       59215
       59215
       -
                array base containers random transformers

     

       59331
       59331
       +
                array base compact-word-vectors containers random transformers

     

       59216
       59332
        
              ];

     

       59217
       59333
        
              testHaskellDepends = [

     

       59218
       59218
       -
                array base containers QuickCheck random tasty tasty-hunit

     

       59219
       59219
       -
                tasty-quickcheck test-framework test-framework-quickcheck2

     

       59220
       59220
       -
                transformers

     

       59334
       59334
       +
                array base compact-word-vectors containers QuickCheck random tasty

     

       59335
       59335
       +
                tasty-hunit tasty-quickcheck test-framework

     

       59336
       59336
       +
                test-framework-quickcheck2 transformers

     

       59221
       59337
        
              ];

     

       59222
       59338
        
              description = "Generate and manipulate various combinatorial objects";

     

       59223
       59339
        
              license = lib.licenses.bsd3;

     
···

       59866
       59982
        
            }:

     

       59867
       59983
        
            mkDerivation {

     

       59868
       59984
        
              pname = "compact-word-vectors";

     

       59869
       59869
       -
              version = "0.2.0.1";

     

       59870
       59870
       -
              sha256 = "0ix8l6vvnf62vp6716gmypwqsrs6x5pzcx5yfj24bn4gk0xak3lm";

     

       59985
       59985
       +
              version = "0.2.0.2";

     

       59986
       59986
       +
              sha256 = "1yjlymp2b8is72xvdb29rf7hc1n96zmda1j3z5alzbp4py00jww8";

     

       59871
       59987
        
              libraryHaskellDepends = [ base primitive ];

     

       59872
       59988
        
              testHaskellDepends = [

     

       59873
       59989
        
                base primitive QuickCheck random tasty tasty-hunit tasty-quickcheck

     
···

       67103
       67219
        
            }:

     

       67104
       67220
        
            mkDerivation {

     

       67105
       67221
        
              pname = "csound-catalog";

     

       67106
       67106
       -
              version = "0.7.4";

     

       67107
       67107
       -
              sha256 = "1ca70yk13b239383q9d8fwc4qd6jm22dqinfhasd88b4iv9p46h8";

     

       67222
       67222
       +
              version = "0.7.5";

     

       67223
       67223
       +
              sha256 = "1ly2s8lxy4wdcvkvsj9nw71r5dbsxpb0z8kzvywj9a5clqid109y";

     

       67108
       67224
        
              libraryHaskellDepends = [

     

       67109
       67225
        
                base csound-expression csound-sampler sharc-timbre transformers

     

       67110
       67226
        
              ];

     
···

       67131
       67247
        
            }:

     

       67132
       67248
        
            mkDerivation {

     

       67133
       67249
        
              pname = "csound-expression";

     

       67134
       67134
       -
              version = "5.3.4";

     

       67135
       67135
       -
              sha256 = "0v5mv2yhw114y7hixh3qjy88sfrry7xfyzkwwk1dpwnq8yycp0ir";

     

       67250
       67250
       +
              version = "5.4.1";

     

       67251
       67251
       +
              sha256 = "0dyafw91ycsr71sxf7z3fbvfbp9vh8l260l9ygfxlrg37971l4pj";

     

       67136
       67252
        
              libraryHaskellDepends = [

     

       67137
       67253
        
                base Boolean colour containers csound-expression-dynamic

     

       67138
       67254
        
                csound-expression-opcodes csound-expression-typed data-default

     
···

       67149
       67265
        
            }:

     

       67150
       67266
        
            mkDerivation {

     

       67151
       67267
        
              pname = "csound-expression-dynamic";

     

       67152
       67152
       -
              version = "0.3.6";

     

       67153
       67153
       -
              sha256 = "1s4gyn4rpkpfpb0glbb39hnzkw9vr4his3s4a4azx894cymyhzg0";

     

       67268
       67268
       +
              version = "0.3.7";

     

       67269
       67269
       +
              sha256 = "1qx9qig18y89k4sxpn333hvqz74c6f56nbvaf8dfbawx5asar0jm";

     

       67154
       67270
        
              libraryHaskellDepends = [

     

       67155
       67271
        
                array base Boolean containers data-default data-fix data-fix-cse

     

       67156
       67272
        
                deriving-compat hashable transformers wl-pprint

     
···

       67165
       67281
        
            }:

     

       67166
       67282
        
            mkDerivation {

     

       67167
       67283
        
              pname = "csound-expression-opcodes";

     

       67168
       67168
       -
              version = "0.0.5.0";

     

       67169
       67169
       -
              sha256 = "1qif8nx3652883zf84w4d0l2lzlbrk9n25rn4i5mxcmlv9px06ha";

     

       67284
       67284
       +
              version = "0.0.5.1";

     

       67285
       67285
       +
              sha256 = "0h1a9yklsqbykhdinmk8znm7kfg0jd1k394cx2lirpdxn136kbcm";

     

       67170
       67286
        
              libraryHaskellDepends = [

     

       67171
       67287
        
                base csound-expression-dynamic csound-expression-typed transformers

     

       67172
       67288
        
              ];

     
···

       67182
       67298
        
            }:

     

       67183
       67299
        
            mkDerivation {

     

       67184
       67300
        
              pname = "csound-expression-typed";

     

       67185
       67185
       -
              version = "0.2.4";

     

       67186
       67186
       -
              sha256 = "1hqmwlgx0dcci7z76w4i5xcq10c4jigzbm7fvf0xxwffmhf6j752";

     

       67301
       67301
       +
              version = "0.2.5";

     

       67302
       67302
       +
              sha256 = "1bid3wxg879l69w8c1vcana0xxrggxv30dw9bqi8zww2w23id54q";

     

       67187
       67303
        
              enableSeparateDataOutput = true;

     

       67188
       67304
        
              libraryHaskellDepends = [

     

       67189
       67305
        
                base Boolean colour containers csound-expression-dynamic

     
···

       67198
       67314
        
           ({ mkDerivation, base, csound-expression, transformers }:

     

       67199
       67315
        
            mkDerivation {

     

       67200
       67316
        
              pname = "csound-sampler";

     

       67201
       67201
       -
              version = "0.0.10.0";

     

       67202
       67202
       -
              sha256 = "0mi7w39adkn5l1h05arfap3c0ddb8j65wv96i3jrswpc3ljf3b2y";

     

       67317
       67317
       +
              version = "0.0.10.1";

     

       67318
       67318
       +
              sha256 = "1c2g83a0n4y1fvq3amj9m2hygg9rbpl5x8zsicb52qjm7vjing2i";

     

       67203
       67319
        
              libraryHaskellDepends = [ base csound-expression transformers ];

     

       67204
       67320
        
              description = "A musical sampler based on Csound";

     

       67205
       67321
        
              license = lib.licenses.bsd3;

     
···

       67282
       67398
        
            }) {};

     

       67283
       67399
        
       

     

       67284
       67400
        
         "css-selectors" = callPackage

     

       67285
       67285
       -
           ({ mkDerivation, aeson, alex, array, base, blaze-markup

     

       67286
       67286
       -
            , data-default, Decimal, happy, QuickCheck, shakespeare

     

       67401
       67401
       +
           ({ mkDerivation, aeson, alex, array, base, binary, blaze-markup

     

       67402
       67402
       +
            , bytestring, data-default, Decimal, happy, QuickCheck, shakespeare

     

       67287
       67403
        
            , template-haskell, test-framework, test-framework-quickcheck2

     

       67288
       67288
       -
            , text

     

       67404
       67404
       +
            , text, zlib

     

       67289
       67405
        
            }:

     

       67290
       67406
        
            mkDerivation {

     

       67291
       67407
        
              pname = "css-selectors";

     

       67292
       67292
       -
              version = "0.2.1.0";

     

       67293
       67293
       -
              sha256 = "1kcxbvp96imhkdrd7w9g2z4d586lmdcpnbgl8g5w04ri85qsq162";

     

       67408
       67408
       +
              version = "0.3.0.0";

     

       67409
       67409
       +
              sha256 = "1p7zzp40gvl5nq2zrb19cjw47w3sf20qwi3mplxq67ryzljmbaz4";

     

       67294
       67410
        
              libraryHaskellDepends = [

     

       67295
       67295
       -
                aeson array base blaze-markup data-default Decimal QuickCheck

     

       67296
       67296
       -
                shakespeare template-haskell text

     

       67411
       67411
       +
                aeson array base binary blaze-markup bytestring data-default

     

       67412
       67412
       +
                Decimal QuickCheck shakespeare template-haskell text zlib

     

       67297
       67413
        
              ];

     

       67298
       67414
        
              libraryToolDepends = [ alex happy ];

     

       67299
       67415
        
              testHaskellDepends = [

     

       67300
       67300
       -
                base QuickCheck test-framework test-framework-quickcheck2 text

     

       67416
       67416
       +
                base binary QuickCheck test-framework test-framework-quickcheck2

     

       67417
       67417
       +
                text

     

       67301
       67418
        
              ];

     

       67302
       67419
        
              description = "Parsing, rendering and manipulating css selectors in Haskell";

     

       67303
       67420
        
              license = lib.licenses.bsd3;

     
···

       76198
       76315
        
            }:

     

       76199
       76316
        
            mkDerivation {

     

       76200
       76317
        
              pname = "diohsc";

     

       76201
       76201
       -
              version = "0.1.5";

     

       76202
       76202
       -
              sha256 = "10336q53ghvj15gxxrdh1s10amfbyl7m69pgzg0rjxrs1p2bx7s7";

     

       76318
       76318
       +
              version = "0.1.6";

     

       76319
       76319
       +
              sha256 = "0hzixid47jv5jwv5rs91baa8bpfkq4hn3y8ndra34w5qvmg3nlii";

     

       76203
       76320
        
              isLibrary = false;

     

       76204
       76321
        
              isExecutable = true;

     

       76205
       76322
        
              executableHaskellDepends = [

     
···

       76674
       76791
        
            }:

     

       76675
       76792
        
            mkDerivation {

     

       76676
       76793
        
              pname = "discord-haskell";

     

       76677
       76677
       -
              version = "1.8.5";

     

       76678
       76678
       -
              sha256 = "0hp3w1d5pwfj06m72dl44cp67h99b3c43kv641vz6dff7xk75hsm";

     

       76794
       76794
       +
              version = "1.8.6";

     

       76795
       76795
       +
              sha256 = "0mmppadd1hmmdgbfjwzhy28kibzssbsnr5dxjiqf3hahmll74qjl";

     

       76679
       76796
        
              isLibrary = true;

     

       76680
       76797
        
              isExecutable = true;

     

       76681
       76798
        
              libraryHaskellDepends = [

     
···

       77911
       78028
        
       

     

       77912
       78029
        
         "dl-fedora" = callPackage

     

       77913
       78030
        
           ({ mkDerivation, base, bytestring, directory, extra, filepath

     

       77914
       77914
       -
            , http-directory, http-types, optparse-applicative, regex-posix

     

       77915
       77915
       -
            , simple-cmd, simple-cmd-args, text, time, unix, xdg-userdirs

     

       77916
       77916
       -
            }:

     

       77917
       77917
       -
            mkDerivation {

     

       77918
       77918
       -
              pname = "dl-fedora";

     

       77919
       77919
       -
              version = "0.8";

     

       77920
       77920
       -
              sha256 = "1pd0cslszd9srr9bpcxzrm84cnk5r78xs79ig32528z0anc5ghcr";

     

       77921
       77921
       -
              isLibrary = false;

     

       77922
       77922
       -
              isExecutable = true;

     

       77923
       77923
       -
              executableHaskellDepends = [

     

       77924
       77924
       -
                base bytestring directory extra filepath http-directory http-types

     

       77925
       77925
       -
                optparse-applicative regex-posix simple-cmd simple-cmd-args text

     

       77926
       77926
       -
                time unix xdg-userdirs

     

       77927
       77927
       -
              ];

     

       77928
       77928
       -
              testHaskellDepends = [ base simple-cmd ];

     

       77929
       77929
       -
              description = "Fedora image download tool";

     

       77930
       77930
       -
              license = lib.licenses.gpl3Only;

     

       77931
       77931
       -
              hydraPlatforms = lib.platforms.none;

     

       77932
       77932
       -
              broken = true;

     

       77933
       77933
       -
            }) {};

     

       77934
       77934
       -
       

     

       77935
       77935
       -
         "dl-fedora_0_9" = callPackage

     

       77936
       77936
       -
           ({ mkDerivation, base, bytestring, directory, extra, filepath

     

       77937
       78031
        
            , http-client, http-client-tls, http-directory, http-types

     

       77938
       78032
        
            , optparse-applicative, regex-posix, simple-cmd, simple-cmd-args

     

       77939
       78033
        
            , text, time, unix, xdg-userdirs

     
···

       78587
       78681
        
                th-lift th-lift-instances time

     

       78588
       78682
        
              ];

     

       78589
       78683
        
              license = lib.licenses.bsd3;

     

       78684
       78684
       +
              hydraPlatforms = lib.platforms.none;

     

       78685
       78685
       +
              broken = true;

     

       78590
       78686
        
            }) {};

     

       78591
       78687
        
       

     

       78592
       78688
        
         "doclayout" = callPackage

     
···

       83791
       83887
        
              broken = true;

     

       83792
       83888
        
            }) {};

     

       83793
       83889
        
       

     

       83890
       83890
       +
         "ema" = callPackage

     

       83891
       83891
       +
           ({ mkDerivation, aeson, async, base, blaze-html, blaze-markup

     

       83892
       83892
       +
            , commonmark, commonmark-extensions, commonmark-pandoc, containers

     

       83893
       83893
       +
            , data-default, directory, filepath, filepattern, fsnotify

     

       83894
       83894
       +
            , http-types, lvar, monad-logger, monad-logger-extras

     

       83895
       83895
       +
            , neat-interpolation, optparse-applicative, pandoc-types

     

       83896
       83896
       +
            , profunctors, relude, safe-exceptions, shower, stm, tagged, text

     

       83897
       83897
       +
            , time, unliftio, wai, wai-middleware-static, wai-websockets, warp

     

       83898
       83898
       +
            , websockets

     

       83899
       83899
       +
            }:

     

       83900
       83900
       +
            mkDerivation {

     

       83901
       83901
       +
              pname = "ema";

     

       83902
       83902
       +
              version = "0.1.0.0";

     

       83903
       83903
       +
              sha256 = "0b7drwqcdap52slnw59vx3mhpabcl72p7rinnfkzsh74jfx21vz0";

     

       83904
       83904
       +
              isLibrary = true;

     

       83905
       83905
       +
              isExecutable = true;

     

       83906
       83906
       +
              libraryHaskellDepends = [

     

       83907
       83907
       +
                aeson async base blaze-html blaze-markup commonmark

     

       83908
       83908
       +
                commonmark-extensions commonmark-pandoc containers data-default

     

       83909
       83909
       +
                directory filepath filepattern fsnotify http-types lvar

     

       83910
       83910
       +
                monad-logger monad-logger-extras neat-interpolation

     

       83911
       83911
       +
                optparse-applicative pandoc-types profunctors relude

     

       83912
       83912
       +
                safe-exceptions shower stm tagged text time unliftio wai

     

       83913
       83913
       +
                wai-middleware-static wai-websockets warp websockets

     

       83914
       83914
       +
              ];

     

       83915
       83915
       +
              executableHaskellDepends = [ base ];

     

       83916
       83916
       +
              description = "Static site generator library with hot reload";

     

       83917
       83917
       +
              license = lib.licenses.agpl3Only;

     

       83918
       83918
       +
            }) {};

     

       83919
       83919
       +
       

     

       83794
       83920
        
         "emacs-keys" = callPackage

     

       83795
       83921
        
           ({ mkDerivation, base, doctest, split, tasty, tasty-hspec

     

       83796
       83922
        
            , tasty-quickcheck, template-haskell, th-lift, xkbcommon

     
···

       87571
       87697
        
            }:

     

       87572
       87698
        
            mkDerivation {

     

       87573
       87699
        
              pname = "exiftool";

     

       87574
       87574
       -
              version = "0.1.0.0";

     

       87575
       87575
       -
              sha256 = "015f0ai0x6iv49k4ljz8058509h8z8kkgnp7p9l4s8z54sgqfw8y";

     

       87576
       87576
       -
              revision = "1";

     

       87577
       87577
       -
              editedCabalFile = "06w0g76jddjykbvym2zgcwjsa33alm1rwshhzaw0pqm573mqbp26";

     

       87700
       87700
       +
              version = "0.1.1.0";

     

       87701
       87701
       +
              sha256 = "1z0zk9axilxp3l13n0h83csia4lvahmqkwhlfp9mswbdy8v8fqm0";

     

       87578
       87702
        
              libraryHaskellDepends = [

     

       87579
       87703
        
                aeson base base64 bytestring hashable process scientific

     

       87580
       87704
        
                string-conversions temporary text unordered-containers vector

     
···

       88199
       88323
        
           ({ mkDerivation, base, leancheck, template-haskell }:

     

       88200
       88324
        
            mkDerivation {

     

       88201
       88325
        
              pname = "express";

     

       88202
       88202
       -
              version = "0.1.4";

     

       88203
       88203
       -
              sha256 = "0rhrlynb950n2c79s3gz0vyd6b34crlhzlva0w91qbzn9dpfrays";

     

       88326
       88326
       +
              version = "0.1.6";

     

       88327
       88327
       +
              sha256 = "1yfbym97j3ih6zvlkg0d08qiivi7cyv61lbyc6qi094apazacq6c";

     

       88204
       88328
        
              libraryHaskellDepends = [ base template-haskell ];

     

       88205
       88329
        
              testHaskellDepends = [ base leancheck ];

     

       88206
       88330
        
              benchmarkHaskellDepends = [ base leancheck ];

     
···

       88676
       88800
        
            }:

     

       88677
       88801
        
            mkDerivation {

     

       88678
       88802
        
              pname = "extrapolate";

     

       88679
       88679
       -
              version = "0.4.2";

     

       88680
       88680
       -
              sha256 = "1dhljcsqahpyn3khxjbxc15ih1r6kgqcagr5gbpg1d705ji7y3j0";

     

       88803
       88803
       +
              version = "0.4.4";

     

       88804
       88804
       +
              sha256 = "0indkjjahlh1isnal93w3iliy59azgdmi9lmdqz4jkbpd421zava";

     

       88681
       88805
        
              libraryHaskellDepends = [

     

       88682
       88806
        
                base express leancheck speculate template-haskell

     

       88683
       88807
        
              ];

     
···

       89381
       89505
        
              maintainers = with lib.maintainers; [ sternenseemann ];

     

       89382
       89506
        
            }) {};

     

       89383
       89507
        
       

     

       89508
       89508
       +
         "fast-logger_3_0_5" = callPackage

     

       89509
       89509
       +
           ({ mkDerivation, array, auto-update, base, bytestring, directory

     

       89510
       89510
       +
            , easy-file, filepath, hspec, hspec-discover, text, unix-compat

     

       89511
       89511
       +
            , unix-time

     

       89512
       89512
       +
            }:

     

       89513
       89513
       +
            mkDerivation {

     

       89514
       89514
       +
              pname = "fast-logger";

     

       89515
       89515
       +
              version = "3.0.5";

     

       89516
       89516
       +
              sha256 = "1mbnah6n8lig494523czcd95dfn01f438qai9pf20wpa2gdbz4x6";

     

       89517
       89517
       +
              libraryHaskellDepends = [

     

       89518
       89518
       +
                array auto-update base bytestring directory easy-file filepath text

     

       89519
       89519
       +
                unix-compat unix-time

     

       89520
       89520
       +
              ];

     

       89521
       89521
       +
              testHaskellDepends = [ base bytestring directory hspec ];

     

       89522
       89522
       +
              testToolDepends = [ hspec-discover ];

     

       89523
       89523
       +
              description = "A fast logging system";

     

       89524
       89524
       +
              license = lib.licenses.bsd3;

     

       89525
       89525
       +
              hydraPlatforms = lib.platforms.none;

     

       89526
       89526
       +
              maintainers = with lib.maintainers; [ sternenseemann ];

     

       89527
       89527
       +
            }) {};

     

       89528
       89528
       +
       

     

       89384
       89529
        
         "fast-math" = callPackage

     

       89385
       89530
        
           ({ mkDerivation, base }:

     

       89386
       89531
        
            mkDerivation {

     
···

       95171
       95316
        
           ({ mkDerivation, base, basement, gauge, ghc-prim }:

     

       95172
       95317
        
            mkDerivation {

     

       95173
       95318
        
              pname = "foundation";

     

       95174
       95174
       -
              version = "0.0.25";

     

       95175
       95175
       -
              sha256 = "0q6kx57ygmznlpf8n499hid4x6mj3180paijx0a8dgi9hh7man61";

     

       95176
       95176
       -
              revision = "1";

     

       95177
       95177
       -
              editedCabalFile = "1ps5sk50sf4b5hd87k3jqykqrwcw2wzyp50rcy6pghd61h83cjg2";

     

       95319
       95319
       +
              version = "0.0.26.1";

     

       95320
       95320
       +
              sha256 = "1hri3raqf6nhh6631gfm2yrkv4039gb0cqfa9cqmjp8bbqv28w5d";

     

       95178
       95321
        
              libraryHaskellDepends = [ base basement ghc-prim ];

     

       95179
       95322
        
              testHaskellDepends = [ base basement ];

     

       95180
       95323
        
              benchmarkHaskellDepends = [ base basement gauge ];

     
···

       95616
       95759
        
              license = lib.licenses.bsd3;

     

       95617
       95760
        
            }) {};

     

       95618
       95761
        
       

     

       95619
       95619
       -
         "free_5_1_6" = callPackage

     

       95762
       95762
       +
         "free_5_1_7" = callPackage

     

       95620
       95763
        
           ({ mkDerivation, base, comonad, containers, distributive

     

       95621
       95764
        
            , exceptions, indexed-traversable, mtl, profunctors, semigroupoids

     

       95622
       95765
        
            , template-haskell, th-abstraction, transformers, transformers-base

     

       95623
       95766
        
            }:

     

       95624
       95767
        
            mkDerivation {

     

       95625
       95768
        
              pname = "free";

     

       95626
       95626
       -
              version = "5.1.6";

     

       95627
       95627
       -
              sha256 = "017cyz0d89560m3a2g2gpf8imzdzzlrd1rv0m6s2lvj41i2dhzfc";

     

       95769
       95769
       +
              version = "5.1.7";

     

       95770
       95770
       +
              sha256 = "121b81wxjk30nc27ivwzxjxi1dcwc30y0gy8l6wac3dxwvkx2c5j";

     

       95628
       95771
        
              libraryHaskellDepends = [

     

       95629
       95772
        
                base comonad containers distributive exceptions indexed-traversable

     

       95630
       95773
        
                mtl profunctors semigroupoids template-haskell th-abstraction

     
···

       97676
       97819
        
              testToolDepends = [ markdown-unlit ];

     

       97677
       97820
        
              description = "Handle exceptions thrown in IO with fused-effects";

     

       97678
       97821
        
              license = lib.licenses.bsd3;

     

       97822
       97822
       +
              hydraPlatforms = lib.platforms.none;

     

       97823
       97823
       +
              broken = true;

     

       97679
       97824
        
            }) {};

     

       97680
       97825
        
       

     

       97681
       97826
        
         "fused-effects-lens" = callPackage

     
···

       99546
       99691
        
              pname = "generic-deriving";

     

       99547
       99692
        
              version = "1.14";

     

       99548
       99693
        
              sha256 = "00nbnxxkxyjfzj3zf6sxh3im24qv485w4jb1gj36c2wn4gjdbayh";

     

       99694
       99694
       +
              revision = "1";

     

       99695
       99695
       +
              editedCabalFile = "0g17hk01sxv5lmrlnmwqhkk73y3dy3xhy7l9myyg5qnw7hm7iin9";

     

       99549
       99696
        
              libraryHaskellDepends = [

     

       99550
       99697
        
                base containers ghc-prim template-haskell th-abstraction

     

       99551
       99698
        
              ];

     
···

       99755
       99902
        
              ];

     

       99756
       99903
        
              description = "Generically derive traversals, lenses and prisms";

     

       99757
       99904
        
              license = lib.licenses.bsd3;

     

       99905
       99905
       +
              hydraPlatforms = lib.platforms.none;

     

       99906
       99906
       +
              broken = true;

     

       99758
       99907
        
            }) {};

     

       99759
       99908
        
       

     

       99760
       99909
        
         "generic-optics-lite" = callPackage

     
···

       102029
       102178
        
           ({ mkDerivation, base, cpphs, ghc, happy }:

     

       102030
       102179
        
            mkDerivation {

     

       102031
       102180
        
              pname = "ghc-parser";

     

       102032
       102032
       -
              version = "0.2.2.0";

     

       102033
       102033
       -
              sha256 = "1pygg0538nah42ll0zai081y8hv8z7lwl0vr9l2k273i4fdif7hb";

     

       102181
       102181
       +
              version = "0.2.3.0";

     

       102182
       102182
       +
              sha256 = "1sm93n6w2zqkp4dhr604bk67sis1rb6jb6imsxr64vjfm7bkigln";

     

       102034
       102183
        
              libraryHaskellDepends = [ base ghc ];

     

       102035
       102184
        
              libraryToolDepends = [ cpphs happy ];

     

       102036
       102185
        
              description = "Haskell source parser from GHC";

     
···

       103857
       104006
        
              libraryPkgconfigDepends = [ gmodule ];

     

       103858
       104007
        
              description = "GModule bindings";

     

       103859
       104008
        
              license = lib.licenses.lgpl21Only;

     

       104009
       104009
       +
              hydraPlatforms = lib.platforms.none;

     

       104010
       104010
       +
              broken = true;

     

       103860
       104011
        
            }) {gmodule = null;};

     

       103861
       104012
        
       

     

       103862
       104013
        
         "gi-gobject" = callPackage

     
···

       104860
       105011
        
              libraryPkgconfigDepends = [ vips ];

     

       104861
       105012
        
              description = "libvips GObject bindings";

     

       104862
       105013
        
              license = lib.licenses.lgpl21Only;

     

       105014
       105014
       +
              hydraPlatforms = lib.platforms.none;

     

       105015
       105015
       +
              broken = true;

     

       104863
       105016
        
            }) {inherit (pkgs) vips;};

     

       104864
       105017
        
       

     

       104865
       105018
        
         "gi-vte" = callPackage

     
···

       105324
       105477
        
            , crypto-api, cryptonite, curl, data-default, DAV, dbus, deepseq

     

       105325
       105478
        
            , directory, disk-free-space, dlist, edit-distance, exceptions

     

       105326
       105479
        
            , fdo-notify, feed, filepath, filepath-bytestring, free, git

     

       105327
       105327
       -
            , git-lfs, gnupg, hinotify, hslogger, http-client

     

       105328
       105328
       -
            , http-client-restricted, http-client-tls, http-conduit, http-types

     

       105329
       105329
       -
            , IfElse, lsof, magic, memory, microlens, monad-control

     

       105330
       105330
       -
            , monad-logger, mountpoints, mtl, network, network-bsd

     

       105331
       105331
       -
            , network-info, network-multicast, network-uri, old-locale, openssh

     

       105332
       105332
       -
            , optparse-applicative, path-pieces, perl, persistent

     

       105333
       105333
       -
            , persistent-sqlite, persistent-template, process, QuickCheck

     

       105334
       105334
       -
            , random, regex-tdfa, resourcet, rsync, SafeSemaphore, sandi

     

       105335
       105335
       -
            , securemem, shakespeare, socks, split, stm, stm-chans, tagsoup

     

       105336
       105336
       -
            , tasty, tasty-hunit, tasty-quickcheck, tasty-rerun

     

       105337
       105337
       -
            , template-haskell, text, time, torrent, transformers, unix

     

       105338
       105338
       -
            , unix-compat, unliftio-core, unordered-containers, utf8-string

     

       105339
       105339
       -
            , uuid, vector, wai, wai-extra, warp, warp-tls, wget, which, yesod

     

       105340
       105340
       -
            , yesod-core, yesod-form, yesod-static

     

       105480
       105480
       +
            , git-lfs, gnupg, hinotify, http-client, http-client-restricted

     

       105481
       105481
       +
            , http-client-tls, http-conduit, http-types, IfElse, lsof, magic

     

       105482
       105482
       +
            , memory, microlens, monad-control, monad-logger, mountpoints, mtl

     

       105483
       105483
       +
            , network, network-bsd, network-info, network-multicast

     

       105484
       105484
       +
            , network-uri, old-locale, openssh, optparse-applicative

     

       105485
       105485
       +
            , path-pieces, perl, persistent, persistent-sqlite

     

       105486
       105486
       +
            , persistent-template, process, QuickCheck, random, regex-tdfa

     

       105487
       105487
       +
            , resourcet, rsync, SafeSemaphore, sandi, securemem, shakespeare

     

       105488
       105488
       +
            , socks, split, stm, stm-chans, tagsoup, tasty, tasty-hunit

     

       105489
       105489
       +
            , tasty-quickcheck, tasty-rerun, template-haskell, text, time

     

       105490
       105490
       +
            , torrent, transformers, unix, unix-compat, unliftio-core

     

       105491
       105491
       +
            , unordered-containers, utf8-string, uuid, vector, wai, wai-extra

     

       105492
       105492
       +
            , warp, warp-tls, wget, which, yesod, yesod-core, yesod-form

     

       105493
       105493
       +
            , yesod-static

     

       105341
       105494
        
            }:

     

       105342
       105495
        
            mkDerivation {

     

       105343
       105496
        
              pname = "git-annex";

     

       105344
       105344
       -
              version = "8.20210330";

     

       105345
       105345
       -
              sha256 = "07dhxlmnj48drgndcplafc7xhby0w3rks68fz9wsppxan929240p";

     

       105497
       105497
       +
              version = "8.20210428";

     

       105498
       105498
       +
              sha256 = "0xpvhpnl600874sa392wjfd2yd9s6ps2cq2qfkzyxxf90p9fcwg8";

     

       105346
       105499
        
              configureFlags = [

     

       105347
       105500
        
                "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"

     

       105348
       105501
        
                "-fnetworkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser"

     
···

       105352
       105505
        
              isExecutable = true;

     

       105353
       105506
        
              setupHaskellDepends = [

     

       105354
       105507
        
                async base bytestring Cabal data-default directory exceptions

     

       105355
       105355
       -
                filepath filepath-bytestring hslogger IfElse process split

     

       105356
       105356
       -
                transformers unix-compat utf8-string

     

       105508
       105508
       +
                filepath filepath-bytestring IfElse process split time transformers

     

       105509
       105509
       +
                unix-compat utf8-string

     

       105357
       105510
        
              ];

     

       105358
       105511
        
              executableHaskellDepends = [

     

       105359
       105512
        
                aeson async attoparsec aws base blaze-builder bloomfilter byteable

     
···

       105361
       105514
        
                connection containers crypto-api cryptonite data-default DAV dbus

     

       105362
       105515
        
                deepseq directory disk-free-space dlist edit-distance exceptions

     

       105363
       105516
        
                fdo-notify feed filepath filepath-bytestring free git-lfs hinotify

     

       105364
       105364
       -
                hslogger http-client http-client-restricted http-client-tls

     

       105365
       105365
       -
                http-conduit http-types IfElse magic memory microlens monad-control

     

       105366
       105366
       -
                monad-logger mountpoints mtl network network-bsd network-info

     

       105367
       105367
       -
                network-multicast network-uri old-locale optparse-applicative

     

       105368
       105368
       -
                path-pieces persistent persistent-sqlite persistent-template

     

       105369
       105369
       -
                process QuickCheck random regex-tdfa resourcet SafeSemaphore sandi

     

       105370
       105370
       -
                securemem shakespeare socks split stm stm-chans tagsoup tasty

     

       105371
       105371
       -
                tasty-hunit tasty-quickcheck tasty-rerun template-haskell text time

     

       105372
       105372
       -
                torrent transformers unix unix-compat unliftio-core

     

       105373
       105373
       -
                unordered-containers utf8-string uuid vector wai wai-extra warp

     

       105374
       105374
       -
                warp-tls yesod yesod-core yesod-form yesod-static

     

       105517
       105517
       +
                http-client http-client-restricted http-client-tls http-conduit

     

       105518
       105518
       +
                http-types IfElse magic memory microlens monad-control monad-logger

     

       105519
       105519
       +
                mountpoints mtl network network-bsd network-info network-multicast

     

       105520
       105520
       +
                network-uri old-locale optparse-applicative path-pieces persistent

     

       105521
       105521
       +
                persistent-sqlite persistent-template process QuickCheck random

     

       105522
       105522
       +
                regex-tdfa resourcet SafeSemaphore sandi securemem shakespeare

     

       105523
       105523
       +
                socks split stm stm-chans tagsoup tasty tasty-hunit

     

       105524
       105524
       +
                tasty-quickcheck tasty-rerun template-haskell text time torrent

     

       105525
       105525
       +
                transformers unix unix-compat unliftio-core unordered-containers

     

       105526
       105526
       +
                utf8-string uuid vector wai wai-extra warp warp-tls yesod

     

       105527
       105527
       +
                yesod-core yesod-form yesod-static

     

       105375
       105528
        
              ];

     

       105376
       105529
        
              executableSystemDepends = [

     

       105377
       105530
        
                bup curl git gnupg lsof openssh perl rsync wget which

     
···

       112817
       112970
        
              pname = "grpc-haskell";

     

       112818
       112971
        
              version = "0.1.0";

     

       112819
       112972
        
              sha256 = "1qqa4qn6ql8zvacaikd1a154ib7bah2h96fjfvd3hz6j79bbfqw4";

     

       112973
       112973
       +
              revision = "1";

     

       112974
       112974
       +
              editedCabalFile = "06yi4isj2qcd1nnc2vf6355wbqq33amhvcwg12jh0zbxpywrs45g";

     

       112820
       112975
        
              isLibrary = true;

     

       112821
       112976
        
              isExecutable = true;

     

       112822
       112977
        
              libraryHaskellDepends = [

     
···

       118537
       118692
        
              broken = true;

     

       118538
       118693
        
            }) {};

     

       118539
       118694
        
       

     

       118695
       118695
       +
         "hasbolt_0_1_4_5" = callPackage

     

       118696
       118696
       +
           ({ mkDerivation, base, binary, bytestring, connection, containers

     

       118697
       118697
       +
            , data-binary-ieee754, data-default, hspec, mtl, network

     

       118698
       118698
       +
            , QuickCheck, text

     

       118699
       118699
       +
            }:

     

       118700
       118700
       +
            mkDerivation {

     

       118701
       118701
       +
              pname = "hasbolt";

     

       118702
       118702
       +
              version = "0.1.4.5";

     

       118703
       118703
       +
              sha256 = "185qh24n6j3b5awwmm92hxravb3sq40l5q8vyng74296mjc65nkw";

     

       118704
       118704
       +
              libraryHaskellDepends = [

     

       118705
       118705
       +
                base binary bytestring connection containers data-binary-ieee754

     

       118706
       118706
       +
                data-default mtl network text

     

       118707
       118707
       +
              ];

     

       118708
       118708
       +
              testHaskellDepends = [

     

       118709
       118709
       +
                base bytestring containers hspec QuickCheck text

     

       118710
       118710
       +
              ];

     

       118711
       118711
       +
              description = "Haskell driver for Neo4j 3+ (BOLT protocol)";

     

       118712
       118712
       +
              license = lib.licenses.bsd3;

     

       118713
       118713
       +
              hydraPlatforms = lib.platforms.none;

     

       118714
       118714
       +
              broken = true;

     

       118715
       118715
       +
            }) {};

     

       118716
       118716
       +
       

     

       118540
       118717
        
         "hasbolt-extras" = callPackage

     

       118541
       118718
        
           ({ mkDerivation, aeson, aeson-casing, base, bytestring, containers

     

       118542
       118719
        
            , data-default, doctest, free, hasbolt, lens, mtl

     
···

       118545
       118722
        
            }:

     

       118546
       118723
        
            mkDerivation {

     

       118547
       118724
        
              pname = "hasbolt-extras";

     

       118548
       118548
       -
              version = "0.0.1.6";

     

       118549
       118549
       -
              sha256 = "0il6752lvq0li29aipc66syc7kd9h57439akshlpqpd25b536zd9";

     

       118725
       118725
       +
              version = "0.0.1.7";

     

       118726
       118726
       +
              sha256 = "1dnia4da5g9c8ckiap4wsacv6lccr69ai24i3n6mywdykhy159f1";

     

       118550
       118727
        
              isLibrary = true;

     

       118551
       118728
        
              isExecutable = true;

     

       118552
       118729
        
              libraryHaskellDepends = [

     
···

       126163
       126340
        
            }:

     

       126164
       126341
        
            mkDerivation {

     

       126165
       126342
        
              pname = "hedgehog-servant";

     

       126166
       126166
       -
              version = "0.0.0.1";

     

       126167
       126167
       -
              sha256 = "04plk39ni5m9arcphb4464bpl12r6aw2zfnzlzhpa1i49qlpivc3";

     

       126343
       126343
       +
              version = "0.0.1.1";

     

       126344
       126344
       +
              sha256 = "17dnj82jgbz23is22kqc60nz46vb4rhlsn1aimaynx7cld0g63vd";

     

       126168
       126345
        
              libraryHaskellDepends = [

     

       126169
       126346
        
                base bytestring case-insensitive hedgehog http-client http-media

     

       126170
       126347
        
                http-types servant servant-client servant-server string-conversions

     
···

       126388
       126565
        
              pname = "heidi";

     

       126389
       126566
        
              version = "0.1.0";

     

       126390
       126567
        
              sha256 = "1l4am8pqk3xrmjmjv48jia60d2vydpj2wy0iyxqiidnc7b8p5j8m";

     

       126568
       126568
       +
              revision = "1";

     

       126569
       126569
       +
              editedCabalFile = "0fbx6hkxdbrhh30j2bs3zrxknrlr6z29r7srxnpsgd4n0rkdajar";

     

       126391
       126570
        
              isLibrary = true;

     

       126392
       126571
        
              isExecutable = true;

     

       126393
       126572
        
              libraryHaskellDepends = [

     
···

       129109
       129288
        
            }:

     

       129110
       129289
        
            mkDerivation {

     

       129111
       129290
        
              pname = "hierarchical-env";

     

       129112
       129112
       -
              version = "0.1.0.0";

     

       129113
       129113
       -
              sha256 = "0syx9i9z9j75wbqsrwl8nqhr025df6vmgb4p767sdb7dncpqkph9";

     

       129291
       129291
       +
              version = "0.2.0.0";

     

       129292
       129292
       +
              sha256 = "1hslf8wppwbs9r40kfvxwnw6vxwa4fm2fjdfmxn0grpbpwz1qvf5";

     

       129114
       129293
        
              libraryHaskellDepends = [

     

       129115
       129294
        
                base method microlens microlens-mtl microlens-th rio

     

       129116
       129295
        
                template-haskell th-abstraction

     
···

       130058
       130237
        
              description = "Integration layer for \"json-pointer\" and \"aeson\"";

     

       130059
       130238
        
              description = "Integration layer for \"json-pointer\" and \"aeson\"";

     

       130060
       130239
        
              license = lib.licenses.bsd3;

     

       130240
       130240
       +
              hydraPlatforms = lib.platforms.none;

     

       130241
       130241
       +
              broken = true;

     

       130061
       130242
        
            }) {};

     

       130062
       130243
        
       

     

       130063
       130244
        
              description = "Integration layer for \"json-pointer\" and \"aeson\"";

     
···

       130080
       130261
        
              description = "Integration layer for \"json-pointer\" and \"aeson\"";

     

       130081
       130262
        
              ];

     

       130082
       130263
        
              license = lib.licenses.bsd3;

     

       130264
       130264
       +
              hydraPlatforms = lib.platforms.none;

     

       130265
       130265
       +
              broken = true;

     

       130083
       130266
        
            }) {};

     

       130084
       130267
        
       

     

       130085
       130268
        
              description = "Integration layer for \"json-pointer\" and \"aeson\"";

     
···

       130111
       130294
        
              description = "Integration layer for \"json-pointer\" and \"aeson\"";

     

       130112
       130295
        
              ];

     

       130113
       130296
        
              license = lib.licenses.bsd3;

     

       130297
       130297
       +
              hydraPlatforms = lib.platforms.none;

     

       130298
       130298
       +
              broken = true;

     

       130114
       130299
        
            }) {};

     

       130115
       130300
        
       

     

       130116
       130301
        
              description = "Integration layer for \"json-pointer\" and \"aeson\"";

     
···

       131305
       131490
        
            }:

     

       131306
       131491
        
            mkDerivation {

     

       131307
       131492
        
              description = "Integration layer for \"json-pointer\" and \"aeson\"";

     

       131308
       131308
       -
              version = "3.3";

     

       131309
       131309
       -
              description = "Integration layer for \"json-pointer\" and \"aeson\"";

     

       131493
       131493
       +
              version = "3.3.1";

     

       131494
       131494
       +
              sha256 = "12l2p5pbgh1wcn2bh0ax36sclwaiky8hf09ivgz453pb5ss0jghc";

     

       131310
       131495
        
              isLibrary = true;

     

       131311
       131496
        
              isExecutable = true;

     

       131312
       131497
        
              enableSeparateDataOutput = true;

     
···

       138680
       138865
        
            }:

     

       138681
       138866
        
            mkDerivation {

     

       138682
       138867
        
              pname = "hspec";

     

       138683
       138683
       -
              version = "2.7.9";

     

       138684
       138684
       -
              sha256 = "03k8djbzkl47x1kgsplbjjrwx8qqdb31zg9aw0c6ii3d8r49gkyn";

     

       138685
       138685
       -
              libraryHaskellDepends = [

     

       138686
       138686
       -
                base hspec-core hspec-discover hspec-expectations QuickCheck

     

       138687
       138687
       -
              ];

     

       138688
       138688
       -
              description = "A Testing Framework for Haskell";

     

       138689
       138689
       -
              license = lib.licenses.mit;

     

       138690
       138690
       -
            }) {};

     

       138691
       138691
       -
       

     

       138692
       138692
       -
         "hspec_2_7_10" = callPackage

     

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

     

       138694
       138694
       -
            , hspec-expectations, QuickCheck

     

       138695
       138695
       -
            }:

     

       138696
       138696
       -
            mkDerivation {

     

       138697
       138697
       -
              pname = "hspec";

     

       138698
       138868
        
              version = "2.7.10";

     

       138699
       138869
        
              sha256 = "0z0lwrmrqkglr78n6k2c36n4h68142bh785ys0x4jaibjshvs6rw";

     

       138700
       138870
        
              libraryHaskellDepends = [

     
···

       138702
       138872
        
              ];

     

       138703
       138873
        
              description = "A Testing Framework for Haskell";

     

       138704
       138874
        
              license = lib.licenses.mit;

     

       138705
       138705
       -
              hydraPlatforms = lib.platforms.none;

     

       138706
       138875
        
            }) {};

     

       138707
       138876
        
       

     

       138708
       138877
        
         "hspec-attoparsec" = callPackage

     
···

       138768
       138937
        
            }:

     

       138769
       138938
        
            mkDerivation {

     

       138770
       138939
        
              pname = "hspec-core";

     

       138771
       138771
       -
              version = "2.7.9";

     

       138772
       138772
       -
              sha256 = "0lqqvrdya7jszdxkzjnwd5g02w1ggmlfkh67bpcmzch6h0v609yj";

     

       138773
       138773
       -
              libraryHaskellDepends = [

     

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

     

       138775
       138775
       -
                filepath hspec-expectations HUnit QuickCheck quickcheck-io random

     

       138776
       138776
       -
                setenv stm tf-random transformers

     

       138777
       138777
       -
              ];

     

       138778
       138778
       -
              testHaskellDepends = [

     

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

     

       138780
       138780
       -
                filepath hspec-expectations hspec-meta HUnit process QuickCheck

     

       138781
       138781
       -
                quickcheck-io random setenv silently stm temporary tf-random

     

       138782
       138782
       -
                transformers

     

       138783
       138783
       -
              ];

     

       138784
       138784
       -
              testToolDepends = [ hspec-meta ];

     

       138785
       138785
       -
              testTarget = "--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'";

     

       138786
       138786
       -
              description = "A Testing Framework for Haskell";

     

       138787
       138787
       -
              license = lib.licenses.mit;

     

       138788
       138788
       -
            }) {};

     

       138789
       138789
       -
       

     

       138790
       138790
       -
         "hspec-core_2_7_10" = callPackage

     

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

     

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

     

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

     

       138794
       138794
       -
            , silently, stm, temporary, tf-random, transformers

     

       138795
       138795
       -
            }:

     

       138796
       138796
       -
            mkDerivation {

     

       138797
       138797
       -
              pname = "hspec-core";

     

       138798
       138940
        
              version = "2.7.10";

     

       138799
       138941
        
              sha256 = "12k9yp5gznrda449ir60d5wv3xl7nnyffkb5mhfc0svw9f8lxlv1";

     

       138800
       138942
        
              libraryHaskellDepends = [

     
···

       138812
       138954
        
              testTarget = "--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'";

     

       138813
       138955
        
              description = "A Testing Framework for Haskell";

     

       138814
       138956
        
              license = lib.licenses.mit;

     

       138815
       138815
       -
              hydraPlatforms = lib.platforms.none;

     

       138816
       138957
        
            }) {};

     

       138817
       138958
        
       

     

       138818
       138959
        
         "hspec-dirstream" = callPackage

     
···

       138838
       138979
        
            }:

     

       138839
       138980
        
            mkDerivation {

     

       138840
       138981
        
              pname = "hspec-discover";

     

       138841
       138841
       -
              version = "2.7.9";

     

       138842
       138842
       -
              sha256 = "1zr6h8r8ggi4482hnx0p2vsrkirfjimq8zy9yfiiyn5mkcqzxl4v";

     

       138843
       138843
       -
              isLibrary = true;

     

       138844
       138844
       -
              isExecutable = true;

     

       138845
       138845
       -
              libraryHaskellDepends = [ base directory filepath ];

     

       138846
       138846
       -
              executableHaskellDepends = [ base directory filepath ];

     

       138847
       138847
       -
              testHaskellDepends = [

     

       138848
       138848
       -
                base directory filepath hspec-meta QuickCheck

     

       138849
       138849
       -
              ];

     

       138850
       138850
       -
              testToolDepends = [ hspec-meta ];

     

       138851
       138851
       -
              description = "Automatically discover and run Hspec tests";

     

       138852
       138852
       -
              license = lib.licenses.mit;

     

       138853
       138853
       -
            }) {};

     

       138854
       138854
       -
       

     

       138855
       138855
       -
         "hspec-discover_2_7_10" = callPackage

     

       138856
       138856
       -
           ({ mkDerivation, base, directory, filepath, hspec-meta, QuickCheck

     

       138857
       138857
       -
            }:

     

       138858
       138858
       -
            mkDerivation {

     

       138859
       138859
       -
              pname = "hspec-discover";

     

       138860
       138982
        
              version = "2.7.10";

     

       138861
       138983
        
              sha256 = "13yzvd3b679skvs1insk4s0wc4zvmz6hs38kc8q0j6vzqq06smqa";

     

       138862
       138984
        
              isLibrary = true;

     
···

       138869
       138991
        
              testToolDepends = [ hspec-meta ];

     

       138870
       138992
        
              description = "Automatically discover and run Hspec tests";

     

       138871
       138993
        
              license = lib.licenses.mit;

     

       138872
       138872
       -
              hydraPlatforms = lib.platforms.none;

     

       138873
       138994
        
            }) {};

     

       138874
       138995
        
       

     

       138875
       138996
        
         "hspec-expectations" = callPackage

     
···

       142241
       142362
        
            }) {};

     

       142242
       142363
        
       

     

       142243
       142364
        
         "http2" = callPackage

     

       142244
       142244
       -
           ({ mkDerivation, aeson, aeson-pretty, array, base

     

       142245
       142245
       -
            , base16-bytestring, bytestring, case-insensitive, containers

     

       142246
       142246
       -
            , directory, doctest, filepath, gauge, Glob, heaps, hspec

     

       142247
       142247
       -
            , http-types, mwc-random, network, network-byte-order, psqueues

     

       142248
       142248
       -
            , stm, text, time-manager, unordered-containers, vector

     

       142249
       142249
       -
            }:

     

       142250
       142250
       -
            mkDerivation {

     

       142251
       142251
       -
              pname = "http2";

     

       142252
       142252
       -
              version = "2.0.6";

     

       142253
       142253
       -
              sha256 = "17m1avrppiz8i6qwjlgg77ha88sx8f8vvfa57z369aszhld6nx9a";

     

       142254
       142254
       -
              isLibrary = true;

     

       142255
       142255
       -
              isExecutable = true;

     

       142256
       142256
       -
              libraryHaskellDepends = [

     

       142257
       142257
       -
                array base bytestring case-insensitive containers http-types

     

       142258
       142258
       -
                network network-byte-order psqueues stm time-manager

     

       142259
       142259
       -
              ];

     

       142260
       142260
       -
              testHaskellDepends = [

     

       142261
       142261
       -
                aeson aeson-pretty array base base16-bytestring bytestring

     

       142262
       142262
       -
                case-insensitive containers directory doctest filepath Glob hspec

     

       142263
       142263
       -
                http-types network network-byte-order psqueues stm text

     

       142264
       142264
       -
                time-manager unordered-containers vector

     

       142265
       142265
       -
              ];

     

       142266
       142266
       -
              benchmarkHaskellDepends = [

     

       142267
       142267
       -
                array base bytestring case-insensitive containers gauge heaps

     

       142268
       142268
       -
                mwc-random network-byte-order psqueues stm

     

       142269
       142269
       -
              ];

     

       142270
       142270
       -
              description = "HTTP/2 library";

     

       142271
       142271
       -
              license = lib.licenses.bsd3;

     

       142272
       142272
       -
            }) {};

     

       142273
       142273
       -
       

     

       142274
       142274
       -
         "http2_3_0_1" = callPackage

     

       142275
       142365
        
           ({ mkDerivation, aeson, aeson-pretty, array, async, base

     

       142276
       142366
        
            , base16-bytestring, bytestring, case-insensitive, containers

     

       142277
       142367
        
            , cryptonite, directory, filepath, gauge, Glob, heaps, hspec

     
···

       142303
       142393
        
              ];

     

       142304
       142394
        
              description = "HTTP/2 library";

     

       142305
       142395
        
              license = lib.licenses.bsd3;

     

       142306
       142306
       -
              hydraPlatforms = lib.platforms.none;

     

       142307
       142396
        
            }) {};

     

       142308
       142397
        
       

     

       142309
       142398
        
         "http2-client" = callPackage

     
···

       142322
       142411
        
              testHaskellDepends = [ base ];

     

       142323
       142412
        
              description = "A native HTTP2 client library";

     

       142324
       142413
        
              license = lib.licenses.bsd3;

     

       142414
       142414
       +
              hydraPlatforms = lib.platforms.none;

     

       142415
       142415
       +
              broken = true;

     

       142325
       142416
        
            }) {};

     

       142326
       142417
        
       

     

       142327
       142418
        
         "http2-client-exe" = callPackage

     
···

       142341
       142432
        
              ];

     

       142342
       142433
        
              description = "A command-line http2 client";

     

       142343
       142434
        
              license = lib.licenses.bsd3;

     

       142435
       142435
       +
              hydraPlatforms = lib.platforms.none;

     

       142436
       142436
       +
              broken = true;

     

       142344
       142437
        
            }) {};

     

       142345
       142438
        
       

     

       142346
       142439
        
         "http2-client-grpc" = callPackage

     
···

       143249
       143342
        
            }:

     

       143250
       143343
        
            mkDerivation {

     

       143251
       143344
        
              pname = "hvega";

     

       143252
       143252
       -
              version = "0.11.0.0";

     

       143253
       143253
       -
              sha256 = "1lz5f04yi97wkqhyxvav262ayyvvl96xrgvgzyk1ca1g299dw866";

     

       143345
       143345
       +
              version = "0.11.0.1";

     

       143346
       143346
       +
              sha256 = "13w2637ylmmwv4kylf1rc2rvd85281a50p82x3888bc1cnzv536x";

     

       143254
       143347
        
              isLibrary = true;

     

       143255
       143348
        
              isExecutable = true;

     

       143256
       143349
        
              libraryHaskellDepends = [ aeson base text unordered-containers ];

     
···

       146038
       146131
        
              ];

     

       146039
       146132
        
              description = "A fast JSON document store with push notification support";

     

       146040
       146133
        
              license = lib.licenses.bsd3;

     

       146041
       146041
       -
              maintainers = with lib.maintainers; [ rkrzr ];

     

       146134
       146134
       +
              hydraPlatforms = lib.platforms.none;

     

       146135
       146135
       +
              broken = true;

     

       146042
       146136
        
            }) {};

     

       146043
       146137
        
       

     

       146044
       146138
        
         "icfpc2020-galaxy" = callPackage

     
···

       146722
       146816
        
       

     

       146723
       146817
        
         "ihaskell" = callPackage

     

       146724
       146818
        
           ({ mkDerivation, aeson, base, base64-bytestring, bytestring, cereal

     

       146725
       146725
       -
            , cmdargs, containers, directory, filepath, ghc, ghc-boot

     

       146726
       146726
       -
            , ghc-parser, ghc-paths, haskeline, haskell-src-exts, here, hlint

     

       146727
       146727
       -
            , hspec, hspec-contrib, http-client, http-client-tls, HUnit

     

       146819
       146819
       +
            , cmdargs, containers, directory, exceptions, filepath, ghc

     

       146820
       146820
       +
            , ghc-boot, ghc-parser, ghc-paths, haskeline, here, hlint, hspec

     

       146821
       146821
       +
            , hspec-contrib, http-client, http-client-tls, HUnit

     

       146728
       146822
        
            , ipython-kernel, mtl, parsec, process, random, raw-strings-qq

     

       146729
       146823
        
            , setenv, shelly, split, stm, strict, text, time, transformers

     

       146730
       146824
        
            , unix, unordered-containers, utf8-string, vector

     

       146731
       146825
        
            }:

     

       146732
       146826
        
            mkDerivation {

     

       146733
       146827
        
              pname = "ihaskell";

     

       146734
       146734
       -
              version = "0.10.1.2";

     

       146735
       146735
       -
              sha256 = "1gs2j0qgxzf346nlnq0zx12yj528ykxia5r3rlldpf6f01zs89v8";

     

       146828
       146828
       +
              version = "0.10.2.0";

     

       146829
       146829
       +
              sha256 = "061gpwclcykrs4pqhsb96hrbwnpmq0q6fx9701wk684v01xjfddk";

     

       146736
       146830
        
              isLibrary = true;

     

       146737
       146831
        
              isExecutable = true;

     

       146738
       146832
        
              enableSeparateDataOutput = true;

     

       146739
       146833
        
              libraryHaskellDepends = [

     

       146740
       146834
        
                aeson base base64-bytestring bytestring cereal cmdargs containers

     

       146741
       146741
       -
                directory filepath ghc ghc-boot ghc-parser ghc-paths haskeline

     

       146742
       146742
       -
                haskell-src-exts hlint http-client http-client-tls ipython-kernel

     

       146743
       146743
       -
                mtl parsec process random shelly split stm strict text time

     

       146835
       146835
       +
                directory exceptions filepath ghc ghc-boot ghc-parser ghc-paths

     

       146836
       146836
       +
                haskeline hlint http-client http-client-tls ipython-kernel mtl

     

       146837
       146837
       +
                parsec process random shelly split stm strict text time

     

       146744
       146838
        
                transformers unix unordered-containers utf8-string vector

     

       146745
       146839
        
              ];

     

       146746
       146840
        
              executableHaskellDepends = [

     
···

       149043
       149137
        
            }:

     

       149044
       149138
        
            mkDerivation {

     

       149045
       149139
        
              pname = "inspection-testing";

     

       149046
       149046
       -
              version = "0.4.3.0";

     

       149047
       149047
       -
              sha256 = "1pba3br5vd11svk9fpg5s977q55qlvhlf95nd5ay79bwdjm10hj3";

     

       149140
       149140
       +
              version = "0.4.4.0";

     

       149141
       149141
       +
              sha256 = "1zr7c7xpmnfwn2p84rqw69n1g91rdkh7d20awvj0s56nbdikgiyh";

     

       149048
       149142
        
              libraryHaskellDepends = [

     

       149049
       149143
        
                base containers ghc mtl template-haskell transformers

     

       149050
       149144
        
              ];

     
···

       149053
       149147
        
              license = lib.licenses.mit;

     

       149054
       149148
        
            }) {};

     

       149055
       149149
        
       

     

       149056
       149056
       -
         "inspection-testing_0_4_4_0" = callPackage

     

       149150
       149150
       +
         "inspection-testing_0_4_5_0" = callPackage

     

       149057
       149151
        
           ({ mkDerivation, base, containers, ghc, mtl, template-haskell

     

       149058
       149152
        
            , transformers

     

       149059
       149153
        
            }:

     

       149060
       149154
        
            mkDerivation {

     

       149061
       149155
        
              pname = "inspection-testing";

     

       149062
       149062
       -
              version = "0.4.4.0";

     

       149063
       149063
       -
              sha256 = "1zr7c7xpmnfwn2p84rqw69n1g91rdkh7d20awvj0s56nbdikgiyh";

     

       149156
       149156
       +
              version = "0.4.5.0";

     

       149157
       149157
       +
              sha256 = "1d8bi60m97yw4vxmajclg66xhaap8nj4dli8bxni0mf4mcm0px01";

     

       149064
       149158
        
              libraryHaskellDepends = [

     

       149065
       149159
        
                base containers ghc mtl template-haskell transformers

     

       149066
       149160
        
              ];

     
···

       149957
       150051
        
            }) {};

     

       149958
       150052
        
       

     

       149959
       150053
        
         "interval-algebra" = callPackage

     

       149960
       149960
       -
           ({ mkDerivation, base, hspec, QuickCheck, time, witherable }:

     

       150054
       150054
       +
           ({ mkDerivation, base, containers, hspec, QuickCheck, time

     

       150055
       150055
       +
            , witherable

     

       150056
       150056
       +
            }:

     

       149961
       150057
        
            mkDerivation {

     

       149962
       150058
        
              pname = "interval-algebra";

     

       149963
       149963
       -
              version = "0.3.3";

     

       149964
       149964
       -
              sha256 = "0njlirr5ymsdw27snixxf3c4dgj8grffqv94a1hz97k801a3axkh";

     

       149965
       149965
       -
              libraryHaskellDepends = [ base QuickCheck time witherable ];

     

       149966
       149966
       -
              testHaskellDepends = [ base hspec QuickCheck time ];

     

       150059
       150059
       +
              version = "0.4.0";

     

       150060
       150060
       +
              sha256 = "0852yv0d7c3gh6ggab6wvnk7g1pad02nnpbmzw98c9zkzw2zk9wh";

     

       150061
       150061
       +
              libraryHaskellDepends = [

     

       150062
       150062
       +
                base containers QuickCheck time witherable

     

       150063
       150063
       +
              ];

     

       150064
       150064
       +
              testHaskellDepends = [ base containers hspec QuickCheck time ];

     

       149967
       150065
        
              description = "An implementation of Allen's interval algebra for temporal logic";

     

       149968
       150066
        
              license = lib.licenses.bsd3;

     

       149969
       150067
        
            }) {};

     
···

       151650
       151748
        
              testHaskellDepends = [ base generic-lens QuickCheck ];

     

       151651
       151749
        
              description = "Automatically derivable Has instances";

     

       151652
       151750
        
              license = lib.licenses.bsd3;

     

       151751
       151751
       +
              hydraPlatforms = lib.platforms.none;

     

       151752
       151752
       +
              broken = true;

     

       151653
       151753
        
            }) {};

     

       151654
       151754
        
       

     

       151655
       151755
        
         "itanium-abi" = callPackage

     
···

       156757
       156857
        
            }:

     

       156758
       156858
        
            mkDerivation {

     

       156759
       156859
        
              pname = "kempe";

     

       156760
       156760
       -
              version = "0.2.0.1";

     

       156761
       156761
       -
              sha256 = "1xs2jism3r2pgvir1rr318dfrjagkagvzzdrs7n9070xzv3p3c5q";

     

       156860
       156860
       +
              version = "0.2.0.3";

     

       156861
       156861
       +
              sha256 = "0bki6h5qk78d3qgprn8k1av2xxlb43bxb07qqk4x1x5diy92mc5x";

     

       156762
       156862
        
              isLibrary = false;

     

       156763
       156863
        
              isExecutable = true;

     

       156764
       156864
        
              enableSeparateDataOutput = true;

     
···

       156772
       156872
        
                base bytestring optparse-applicative prettyprinter

     

       156773
       156873
        
              ];

     

       156774
       156874
        
              testHaskellDepends = [

     

       156775
       156775
       -
                base bytestring composition-prelude deepseq filepath prettyprinter

     

       156776
       156776
       -
                process tasty tasty-golden tasty-hunit temporary text

     

       156875
       156875
       +
                base bytestring composition-prelude deepseq extra filepath

     

       156876
       156876
       +
                prettyprinter process tasty tasty-golden tasty-hunit temporary text

     

       156777
       156877
        
              ];

     

       156778
       156878
        
              benchmarkHaskellDepends = [

     

       156779
       156879
        
                base bytestring criterion prettyprinter temporary text

     
···

       156953
       157053
        
              pname = "keycode";

     

       156954
       157054
        
              version = "0.2.2";

     

       156955
       157055
        
              sha256 = "046k8d1h5wwadf5z4pppjkc3g7v2zxlzb06s1xgixc42y5y41yan";

     

       156956
       156956
       -
              revision = "6";

     

       156957
       156957
       -
              editedCabalFile = "0acc224njxf8y7r381pnzxx6z3lvshs5mwfafkcrn36nb0wfplng";

     

       157056
       157056
       +
              revision = "7";

     

       157057
       157057
       +
              editedCabalFile = "1xfhm486mgkf744nbx94aw0b1lraj1yv29c57rbx1c2b84v2z8k2";

     

       156958
       157058
        
              libraryHaskellDepends = [

     

       156959
       157059
        
                base containers ghc-prim template-haskell

     

       156960
       157060
        
              ];

     
···

       159408
       159508
        
              license = lib.licenses.bsd3;

     

       159409
       159509
        
            }) {};

     

       159410
       159510
        
       

     

       159511
       159511
       +
         "language-c-quote_0_13" = callPackage

     

       159512
       159512
       +
           ({ mkDerivation, alex, array, base, bytestring, containers

     

       159513
       159513
       +
            , exception-mtl, exception-transformers, filepath, happy

     

       159514
       159514
       +
            , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb

     

       159515
       159515
       +
            , template-haskell, test-framework, test-framework-hunit

     

       159516
       159516
       +
            }:

     

       159517
       159517
       +
            mkDerivation {

     

       159518
       159518
       +
              pname = "language-c-quote";

     

       159519
       159519
       +
              version = "0.13";

     

       159520
       159520
       +
              sha256 = "02axz6498sg2rf24qds39n9gysc4lm3v354h2qyhrhadlfq8sf6d";

     

       159521
       159521
       +
              libraryHaskellDepends = [

     

       159522
       159522
       +
                array base bytestring containers exception-mtl

     

       159523
       159523
       +
                exception-transformers filepath haskell-src-meta mainland-pretty

     

       159524
       159524
       +
                mtl srcloc syb template-haskell

     

       159525
       159525
       +
              ];

     

       159526
       159526
       +
              libraryToolDepends = [ alex happy ];

     

       159527
       159527
       +
              testHaskellDepends = [

     

       159528
       159528
       +
                base bytestring HUnit mainland-pretty srcloc test-framework

     

       159529
       159529
       +
                test-framework-hunit

     

       159530
       159530
       +
              ];

     

       159531
       159531
       +
              description = "C/CUDA/OpenCL/Objective-C quasiquoting library";

     

       159532
       159532
       +
              license = lib.licenses.bsd3;

     

       159533
       159533
       +
              hydraPlatforms = lib.platforms.none;

     

       159534
       159534
       +
            }) {};

     

       159535
       159535
       +
       

     

       159411
       159536
        
         "language-c99" = callPackage

     

       159412
       159537
        
           ({ mkDerivation, base, pretty }:

     

       159413
       159538
        
            mkDerivation {

     
···

       159568
       159693
        
            }:

     

       159569
       159694
        
            mkDerivation {

     

       159570
       159695
        
              pname = "language-docker";

     

       159571
       159571
       -
              version = "9.2.0";

     

       159572
       159572
       -
              sha256 = "08nq78091w7dii823fy7bvp2gxn1j1fp1fj151z37hvf423w19ds";

     

       159573
       159573
       -
              libraryHaskellDepends = [

     

       159574
       159574
       -
                base bytestring containers data-default-class megaparsec

     

       159575
       159575
       -
                prettyprinter split text time

     

       159576
       159576
       -
              ];

     

       159577
       159577
       -
              testHaskellDepends = [

     

       159578
       159578
       -
                base bytestring containers data-default-class hspec HUnit

     

       159579
       159579
       -
                megaparsec prettyprinter QuickCheck split text time

     

       159580
       159580
       -
              ];

     

       159581
       159581
       -
              description = "Dockerfile parser, pretty-printer and embedded DSL";

     

       159582
       159582
       -
              license = lib.licenses.gpl3Only;

     

       159583
       159583
       -
            }) {};

     

       159584
       159584
       -
       

     

       159585
       159585
       -
         "language-docker_9_3_0" = callPackage

     

       159586
       159586
       -
           ({ mkDerivation, base, bytestring, containers, data-default-class

     

       159587
       159587
       -
            , hspec, HUnit, megaparsec, prettyprinter, QuickCheck, split, text

     

       159588
       159588
       -
            , time

     

       159589
       159589
       -
            }:

     

       159590
       159590
       -
            mkDerivation {

     

       159591
       159591
       -
              pname = "language-docker";

     

       159592
       159696
        
              version = "9.3.0";

     

       159593
       159697
        
              sha256 = "1n9v0b6lwr528b6919y11a8d27mhsp0mm870rx0rjg9l5j4mnbvn";

     

       159594
       159698
        
              libraryHaskellDepends = [

     
···

       159601
       159705
        
              ];

     

       159602
       159706
        
              description = "Dockerfile parser, pretty-printer and embedded DSL";

     

       159603
       159707
        
              license = lib.licenses.gpl3Only;

     

       159604
       159604
       -
              hydraPlatforms = lib.platforms.none;

     

       159605
       159708
        
            }) {};

     

       159606
       159709
        
       

     

       159607
       159710
        
         "language-dockerfile" = callPackage

     
···

       161608
       161711
        
           ({ mkDerivation, base, template-haskell }:

     

       161609
       161712
        
            mkDerivation {

     

       161610
       161713
        
              pname = "leancheck";

     

       161611
       161611
       -
              version = "0.9.3";

     

       161612
       161612
       -
              sha256 = "14wi7h07pipd56grhaqmhb8wmr52llgd3xb7fm8hi9fb1sfzmvg0";

     

       161613
       161613
       -
              libraryHaskellDepends = [ base template-haskell ];

     

       161614
       161614
       -
              testHaskellDepends = [ base ];

     

       161615
       161615
       -
              description = "Enumerative property-based testing";

     

       161616
       161616
       -
              license = lib.licenses.bsd3;

     

       161617
       161617
       -
            }) {};

     

       161618
       161618
       -
       

     

       161619
       161619
       -
         "leancheck_0_9_4" = callPackage

     

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

     

       161621
       161621
       -
            mkDerivation {

     

       161622
       161622
       -
              pname = "leancheck";

     

       161623
       161714
        
              version = "0.9.4";

     

       161624
       161715
        
              sha256 = "0w17ymj7k4sr9jwp9yrgh3l94l3kgjyxxnpxwj2sdqk8fvmjpkny";

     

       161625
       161716
        
              libraryHaskellDepends = [ base template-haskell ];

     

       161626
       161717
        
              testHaskellDepends = [ base ];

     

       161627
       161718
        
              description = "Enumerative property-based testing";

     

       161628
       161719
        
              license = lib.licenses.bsd3;

     

       161629
       161629
       -
              hydraPlatforms = lib.platforms.none;

     

       161630
       161720
        
            }) {};

     

       161631
       161721
        
       

     

       161632
       161722
        
         "leancheck-enum-instances" = callPackage

     
···

       164211
       164301
        
           ({ mkDerivation, base, template-haskell }:

     

       164212
       164302
        
            mkDerivation {

     

       164213
       164303
        
              pname = "lift-type";

     

       164214
       164214
       -
              version = "0.1.0.0";

     

       164215
       164215
       -
              sha256 = "0832xn7bfv1kwg02mmh6my11inljb066mci01b7p0xkcip1kmrhy";

     

       164216
       164216
       -
              revision = "1";

     

       164217
       164217
       -
              editedCabalFile = "1m89kzw7zrys8jjg7sbdpfq3bsqdvqr8bcszsnwvx0nmj1c6hciw";

     

       164304
       164304
       +
              version = "0.1.0.1";

     

       164305
       164305
       +
              sha256 = "1195iyf0s8zmibjmvd10bszyccp1a2g4wdysn7yk10d3j0q9xdxf";

     

       164218
       164306
        
              libraryHaskellDepends = [ base template-haskell ];

     

       164219
       164307
        
              testHaskellDepends = [ base template-haskell ];

     

       164308
       164308
       +
              description = "Lift a type from a Typeable constraint to a Template Haskell type";

     

       164220
       164309
        
              license = lib.licenses.bsd3;

     

       164221
       164310
        
            }) {};

     

       164222
       164311
        
       

     
···

       169556
       169645
        
              license = lib.licenses.bsd3;

     

       169557
       169646
        
              hydraPlatforms = lib.platforms.none;

     

       169558
       169647
        
              broken = true;

     

       169648
       169648
       +
            }) {};

     

       169649
       169649
       +
       

     

       169650
       169650
       +
         "lvar" = callPackage

     

       169651
       169651
       +
           ({ mkDerivation, base, containers, relude, stm }:

     

       169652
       169652
       +
            mkDerivation {

     

       169653
       169653
       +
              pname = "lvar";

     

       169654
       169654
       +
              version = "0.1.0.0";

     

       169655
       169655
       +
              sha256 = "1hllvr4nsjv3c3x5aybp05wr9pdvwlw101vq7c37ydnb91hbfdv4";

     

       169656
       169656
       +
              libraryHaskellDepends = [ base containers relude stm ];

     

       169657
       169657
       +
              description = "TMVar that can be listened to";

     

       169658
       169658
       +
              license = lib.licenses.bsd3;

     

       169559
       169659
        
            }) {};

     

       169560
       169660
        
       

     

       169561
       169661
        
         "lvish" = callPackage

     
···

       170823
       170923
        
              license = lib.licenses.bsd3;

     

       170824
       170924
        
            }) {};

     

       170825
       170925
        
       

     

       170926
       170926
       +
         "mainland-pretty_0_7_1" = callPackage

     

       170927
       170927
       +
           ({ mkDerivation, base, containers, srcloc, text, transformers }:

     

       170928
       170928
       +
            mkDerivation {

     

       170929
       170929
       +
              pname = "mainland-pretty";

     

       170930
       170930
       +
              version = "0.7.1";

     

       170931
       170931
       +
              sha256 = "19z2769rik6kwvsil2if2bfq2v59jmwv74jy3fy4q3q3zy4239p1";

     

       170932
       170932
       +
              libraryHaskellDepends = [

     

       170933
       170933
       +
                base containers srcloc text transformers

     

       170934
       170934
       +
              ];

     

       170935
       170935
       +
              description = "Pretty printing designed for printing source code";

     

       170936
       170936
       +
              license = lib.licenses.bsd3;

     

       170937
       170937
       +
              hydraPlatforms = lib.platforms.none;

     

       170938
       170938
       +
            }) {};

     

       170939
       170939
       +
       

     

       170826
       170940
        
         "majordomo" = callPackage

     

       170827
       170941
        
           ({ mkDerivation, base, bytestring, cmdargs, monad-loops, old-locale

     

       170828
       170942
        
            , threads, time, unix, zeromq-haskell

     
···

       171600
       171714
        
            }:

     

       171601
       171715
        
            mkDerivation {

     

       171602
       171716
        
              pname = "map-reduce-folds";

     

       171603
       171603
       -
              version = "0.1.0.5";

     

       171604
       171604
       -
              sha256 = "0a0xavn4dlcpkjw75lc8k9f8w8620m60s8q9r4c157010mb4w829";

     

       171717
       171717
       +
              version = "0.1.0.7";

     

       171718
       171718
       +
              sha256 = "0khwcxw5cxx3y9rryak7qb65q055lg6b7gsbj20rvskq300asbk0";

     

       171605
       171719
        
              libraryHaskellDepends = [

     

       171606
       171720
        
                base containers discrimination foldl hashable hashtables parallel

     

       171607
       171721
        
                profunctors split streaming streamly text unordered-containers

     
···

       174322
       174436
        
              pname = "memory";

     

       174323
       174437
        
              version = "0.15.0";

     

       174324
       174438
        
              sha256 = "0a9mxcddnqn4359hk59d6l2zbh0vp154yb5vs1a8jw4l38n8kzz3";

     

       174325
       174325
       -
              revision = "1";

     

       174326
       174326
       -
              editedCabalFile = "136qfj1cbg9571mlwywaqml75ijx3pcgvbpbgwxrqsl71ssj8w5y";

     

       174439
       174439
       +
              revision = "2";

     

       174440
       174440
       +
              editedCabalFile = "0fd40y5byy4cq4x6m66zxadxbw96gzswplgfyvdqnjlasq28xw68";

     

       174327
       174441
        
              libraryHaskellDepends = [

     

       174328
       174442
        
                base basement bytestring deepseq ghc-prim

     

       174329
       174443
        
              ];

     
···

       184052
       184166
        
            }:

     

       184053
       184167
        
            mkDerivation {

     

       184054
       184168
        
              pname = "mysql";

     

       184055
       184055
       -
              version = "0.2";

     

       184056
       184056
       -
              sha256 = "09b1rhv16g8npjblq9jfi29bffsplvq4hnksdhknd39anr5gpqzc";

     

       184169
       184169
       +
              version = "0.2.0.1";

     

       184170
       184170
       +
              sha256 = "16m8hv9yy2nf4jwgqg6n9z53n2pzskbc3gwbp2i3kgff8wsmf8sd";

     

       184057
       184171
        
              setupHaskellDepends = [ base Cabal ];

     

       184058
       184172
        
              libraryHaskellDepends = [ base bytestring containers ];

     

       184059
       184173
        
              librarySystemDepends = [ mysql ];

     
···

       189812
       189926
        
            }:

     

       189813
       189927
        
            mkDerivation {

     

       189814
       189928
        
              pname = "nri-env-parser";

     

       189815
       189815
       -
              version = "0.1.0.6";

     

       189816
       189816
       -
              sha256 = "1hmq6676w3f5mpdpd4jbd1aa6g379q6yyidcvdyhazqxcb0dhirh";

     

       189817
       189817
       -
              libraryHaskellDepends = [

     

       189818
       189818
       -
                base modern-uri network-uri nri-prelude text

     

       189819
       189819
       -
              ];

     

       189820
       189820
       -
              description = "Read environment variables as settings to build 12-factor apps";

     

       189821
       189821
       -
              license = lib.licenses.bsd3;

     

       189822
       189822
       -
            }) {};

     

       189823
       189823
       -
       

     

       189824
       189824
       -
         "nri-env-parser_0_1_0_7" = callPackage

     

       189825
       189825
       -
           ({ mkDerivation, base, modern-uri, network-uri, nri-prelude, text

     

       189826
       189826
       -
            }:

     

       189827
       189827
       -
            mkDerivation {

     

       189828
       189828
       -
              pname = "nri-env-parser";

     

       189829
       189929
        
              version = "0.1.0.7";

     

       189830
       189930
        
              sha256 = "1mm879mqpgl040p789wcjm5bhrqia5czn18c5dgni8bwa4y61ank";

     

       189831
       189931
        
              libraryHaskellDepends = [

     
···

       189833
       189933
        
              ];

     

       189834
       189934
        
              description = "Read environment variables as settings to build 12-factor apps";

     

       189835
       189935
        
              license = lib.licenses.bsd3;

     

       189836
       189836
       -
              hydraPlatforms = lib.platforms.none;

     

       189837
       189936
        
            }) {};

     

       189838
       189937
        
       

     

       189839
       189938
        
         "nri-observability" = callPackage

     
···

       189844
       189943
        
            }:

     

       189845
       189944
        
            mkDerivation {

     

       189846
       189945
        
              pname = "nri-observability";

     

       189847
       189847
       -
              version = "0.1.0.1";

     

       189848
       189848
       -
              sha256 = "02baq11z5qq9lq9yh8zc29s44i44qz1m593ypn3qd8rgc1arrfjj";

     

       189849
       189849
       -
              libraryHaskellDepends = [

     

       189850
       189850
       -
                aeson aeson-pretty async base bugsnag-hs bytestring directory

     

       189851
       189851
       -
                hostname http-client http-client-tls nri-env-parser nri-prelude

     

       189852
       189852
       -
                random safe-exceptions stm text time unordered-containers

     

       189853
       189853
       -
              ];

     

       189854
       189854
       -
              testHaskellDepends = [

     

       189855
       189855
       -
                aeson aeson-pretty async base bugsnag-hs bytestring directory

     

       189856
       189856
       -
                hostname http-client http-client-tls nri-env-parser nri-prelude

     

       189857
       189857
       -
                random safe-exceptions stm text time unordered-containers

     

       189858
       189858
       -
              ];

     

       189859
       189859
       -
              description = "Report log spans collected by nri-prelude";

     

       189860
       189860
       -
              license = lib.licenses.bsd3;

     

       189861
       189861
       -
            }) {};

     

       189862
       189862
       -
       

     

       189863
       189863
       -
         "nri-observability_0_1_0_2" = callPackage

     

       189864
       189864
       -
           ({ mkDerivation, aeson, aeson-pretty, async, base, bugsnag-hs

     

       189865
       189865
       -
            , bytestring, directory, hostname, http-client, http-client-tls

     

       189866
       189866
       -
            , nri-env-parser, nri-prelude, random, safe-exceptions, stm, text

     

       189867
       189867
       -
            , time, unordered-containers

     

       189868
       189868
       -
            }:

     

       189869
       189869
       -
            mkDerivation {

     

       189870
       189870
       -
              pname = "nri-observability";

     

       189871
       189946
        
              version = "0.1.0.2";

     

       189872
       189947
        
              sha256 = "19nil7vyjbvbjlapvrxky8fkxdl3f2xhqdi3a5m5i5lyawm74b6z";

     

       189873
       189948
        
              libraryHaskellDepends = [

     
···

       189882
       189957
        
              ];

     

       189883
       189958
        
              description = "Report log spans collected by nri-prelude";

     

       189884
       189959
        
              license = lib.licenses.bsd3;

     

       189885
       189885
       -
              hydraPlatforms = lib.platforms.none;

     

       189886
       189960
        
            }) {};

     

       189887
       189961
        
       

     

       189888
       189962
        
         "nri-prelude" = callPackage

     
···

       189893
       189967
        
            }:

     

       189894
       189968
        
            mkDerivation {

     

       189895
       189969
        
              pname = "nri-prelude";

     

       189896
       189896
       -
              version = "0.5.0.3";

     

       189897
       189897
       -
              sha256 = "0k4mhgyazjc74hwf2xgznhhkryqhdmsc2pv1v9d32706qkr796wn";

     

       189898
       189898
       -
              libraryHaskellDepends = [

     

       189899
       189899
       -
                aeson aeson-pretty async auto-update base bytestring containers

     

       189900
       189900
       -
                directory exceptions filepath ghc hedgehog junit-xml pretty-diff

     

       189901
       189901
       -
                pretty-show safe-coloured-text safe-exceptions terminal-size text

     

       189902
       189902
       -
                time vector

     

       189903
       189903
       -
              ];

     

       189904
       189904
       -
              testHaskellDepends = [

     

       189905
       189905
       -
                aeson aeson-pretty async auto-update base bytestring containers

     

       189906
       189906
       -
                directory exceptions filepath ghc hedgehog junit-xml pretty-diff

     

       189907
       189907
       -
                pretty-show safe-coloured-text safe-exceptions terminal-size text

     

       189908
       189908
       -
                time vector

     

       189909
       189909
       -
              ];

     

       189910
       189910
       -
              description = "A Prelude inspired by the Elm programming language";

     

       189911
       189911
       -
              license = lib.licenses.bsd3;

     

       189912
       189912
       -
            }) {};

     

       189913
       189913
       -
       

     

       189914
       189914
       -
         "nri-prelude_0_6_0_0" = callPackage

     

       189915
       189915
       -
           ({ mkDerivation, aeson, aeson-pretty, async, auto-update, base

     

       189916
       189916
       -
            , bytestring, containers, directory, exceptions, filepath, ghc

     

       189917
       189917
       -
            , hedgehog, junit-xml, pretty-diff, pretty-show, safe-coloured-text

     

       189918
       189918
       -
            , safe-exceptions, terminal-size, text, time, vector

     

       189919
       189919
       -
            }:

     

       189920
       189920
       -
            mkDerivation {

     

       189921
       189921
       -
              pname = "nri-prelude";

     

       189922
       189970
        
              version = "0.6.0.0";

     

       189923
       189971
        
              sha256 = "02v83n08zxz8521skijgrn407a0mlkjc3fjn5q04gn932wf29g5s";

     

       189924
       189972
        
              libraryHaskellDepends = [

     
···

       189935
       189983
        
              ];

     

       189936
       189984
        
              description = "A Prelude inspired by the Elm programming language";

     

       189937
       189985
        
              license = lib.licenses.bsd3;

     

       189938
       189938
       -
              hydraPlatforms = lib.platforms.none;

     

       189939
       189986
        
            }) {};

     

       189940
       189987
        
       

     

       189941
       189988
        
         "nsis" = callPackage

     
···

       191748
       191795
        
              broken = true;

     

       191749
       191796
        
            }) {};

     

       191750
       191797
        
       

     

       191798
       191798
       +
         "om-doh" = callPackage

     

       191799
       191799
       +
           ({ mkDerivation, base, base64, bytestring, http-api-data, resolv

     

       191800
       191800
       +
            , servant, servant-server, text

     

       191801
       191801
       +
            }:

     

       191802
       191802
       +
            mkDerivation {

     

       191803
       191803
       +
              pname = "om-doh";

     

       191804
       191804
       +
              version = "0.1.0.1";

     

       191805
       191805
       +
              sha256 = "1y9r70ppifww4ddk3rwvgwhfijn5hf9svlx4x46v1n027yjf9pgp";

     

       191806
       191806
       +
              libraryHaskellDepends = [

     

       191807
       191807
       +
                base base64 bytestring http-api-data resolv servant servant-server

     

       191808
       191808
       +
                text

     

       191809
       191809
       +
              ];

     

       191810
       191810
       +
              description = "om-doh";

     

       191811
       191811
       +
              license = lib.licenses.mit;

     

       191812
       191812
       +
              hydraPlatforms = lib.platforms.none;

     

       191813
       191813
       +
              broken = true;

     

       191814
       191814
       +
            }) {};

     

       191815
       191815
       +
       

     

       191751
       191816
        
         "om-elm" = callPackage

     

       191752
       191817
        
           ({ mkDerivation, base, bytestring, Cabal, containers, directory

     

       191753
       191818
        
            , http-types, safe, safe-exceptions, template-haskell, text, unix

     
···

       192560
       192625
        
            }:

     

       192561
       192626
        
            mkDerivation {

     

       192562
       192627
        
              pname = "openapi3";

     

       192563
       192563
       -
              version = "3.0.2.0";

     

       192564
       192564
       -
              sha256 = "00qpbj2lvaysbwgbax7z1vyixzd0x7yzbz26aw5zxd4asddypbfg";

     

       192565
       192565
       -
              isLibrary = true;

     

       192566
       192566
       -
              isExecutable = true;

     

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

     

       192568
       192568
       -
              libraryHaskellDepends = [

     

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

     

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

     

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

     

       192572
       192572
       -
                template-haskell text time transformers unordered-containers

     

       192573
       192573
       -
                uuid-types vector

     

       192574
       192574
       -
              ];

     

       192575
       192575
       -
              executableHaskellDepends = [ aeson base lens text ];

     

       192576
       192576
       -
              testHaskellDepends = [

     

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

     

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

     

       192579
       192579
       -
                quickcheck-instances template-haskell text time

     

       192580
       192580
       -
                unordered-containers utf8-string vector

     

       192581
       192581
       -
              ];

     

       192582
       192582
       -
              testToolDepends = [ hspec-discover ];

     

       192583
       192583
       -
              description = "OpenAPI 3.0 data model";

     

       192584
       192584
       -
              license = lib.licenses.bsd3;

     

       192585
       192585
       -
              hydraPlatforms = lib.platforms.none;

     

       192586
       192586
       -
              broken = true;

     

       192587
       192587
       -
            }) {};

     

       192588
       192588
       -
       

     

       192589
       192589
       -
         "openapi3_3_1_0" = callPackage

     

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

     

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

     

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

     

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

     

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

     

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

     

       192596
       192596
       -
            , utf8-string, uuid-types, vector

     

       192597
       192597
       -
            }:

     

       192598
       192598
       -
            mkDerivation {

     

       192599
       192599
       -
              pname = "openapi3";

     

       192600
       192628
        
              version = "3.1.0";

     

       192601
       192629
        
              sha256 = "011754qyxxw5mn06hdmxalvsiff7a4x4k2yb2r6ylzr6zhyz818z";

     

       192602
       192630
        
              isLibrary = true;

     
···

       192619
       192647
        
              testToolDepends = [ hspec-discover ];

     

       192620
       192648
        
              description = "OpenAPI 3.0 data model";

     

       192621
       192649
        
              license = lib.licenses.bsd3;

     

       192622
       192622
       -
              hydraPlatforms = lib.platforms.none;

     

       192623
       192623
       -
              broken = true;

     

       192624
       192650
        
            }) {};

     

       192625
       192651
        
       

     

       192626
       192652
        
         "openapi3-code-generator" = callPackage

     
···

       194660
       194686
        
            }:

     

       194661
       194687
        
            mkDerivation {

     

       194662
       194688
        
              pname = "orgstat";

     

       194663
       194663
       -
              version = "0.1.9";

     

       194664
       194664
       -
              sha256 = "09psfz4a2amgcyq00ygjp6zakzf5yx2y2kjykz62wncwpqkgnf53";

     

       194689
       194689
       +
              version = "0.1.10";

     

       194690
       194690
       +
              sha256 = "16p6wswh96ap4qj7n61qd3hrr0f5m84clb113vg4dncf46ivlfs6";

     

       194665
       194691
        
              isLibrary = true;

     

       194666
       194692
        
              isExecutable = true;

     

       194667
       194693
        
              libraryHaskellDepends = [

     
···

       194682
       194708
        
              ];

     

       194683
       194709
        
              description = "Statistics visualizer for org-mode";

     

       194684
       194710
        
              license = lib.licenses.gpl3Only;

     

       194685
       194685
       -
              hydraPlatforms = lib.platforms.none;

     

       194686
       194686
       -
              broken = true;

     

       194687
       194711
        
            }) {};

     

       194688
       194712
        
       

     

       194689
       194713
        
         "origami" = callPackage

     
···

       195136
       195160
        
       

     

       195137
       195161
        
         "overloaded" = callPackage

     

       195138
       195162
        
           ({ mkDerivation, assoc, base, bin, boring, bytestring, constraints

     

       195139
       195139
       -
            , containers, fin, generic-lens-lite, ghc, hmatrix, HUnit, lens

     

       195140
       195140
       -
            , optics-core, profunctors, QuickCheck, ral, record-hasfield

     

       195141
       195141
       -
            , semigroupoids, singleton-bool, sop-core, split, splitmix, syb

     

       195142
       195142
       -
            , symbols, tasty, tasty-hunit, tasty-quickcheck, template-haskell

     

       195143
       195143
       -
            , text, th-compat, time, vec

     

       195163
       195163
       +
            , containers, fin, generic-lens-lite, ghc, hmatrix, HUnit

     

       195164
       195164
       +
            , indexed-traversable, lens, optics-core, profunctors, QuickCheck

     

       195165
       195165
       +
            , ral, record-hasfield, semigroupoids, singleton-bool, sop-core

     

       195166
       195166
       +
            , split, splitmix, syb, symbols, tasty, tasty-hunit

     

       195167
       195167
       +
            , tasty-quickcheck, template-haskell, text, th-compat, time, vec

     

       195144
       195168
        
            }:

     

       195145
       195169
        
            mkDerivation {

     

       195146
       195170
        
              pname = "overloaded";

     

       195147
       195147
       -
              version = "0.3";

     

       195148
       195148
       -
              sha256 = "151xnpk7l1jg63m4bwr91h3dh1xb0d4xinc4vn1jsbhr96p662ap";

     

       195171
       195171
       +
              version = "0.3.1";

     

       195172
       195172
       +
              sha256 = "0ra33rcbjm58978gc0pjzcspyvab7g2vxnjk6z5hag7qh6ay76bg";

     

       195149
       195173
        
              libraryHaskellDepends = [

     

       195150
       195150
       -
                assoc base bin bytestring containers fin ghc optics-core

     

       195151
       195151
       -
                profunctors ral record-hasfield semigroupoids sop-core split syb

     

       195152
       195152
       -
                symbols template-haskell text th-compat time vec

     

       195174
       195174
       +
                assoc base bin bytestring containers fin ghc indexed-traversable

     

       195175
       195175
       +
                optics-core profunctors ral record-hasfield semigroupoids sop-core

     

       195176
       195176
       +
                split syb symbols template-haskell text th-compat time vec

     

       195153
       195177
        
              ];

     

       195154
       195178
        
              testHaskellDepends = [

     

       195155
       195179
        
                assoc base bin boring bytestring constraints containers fin

     
···

       196314
       196338
        
              executableHaskellDepends = [ base mtl pandoc-types text ];

     

       196315
       196339
        
              description = "Convert Pandoc Markdown-style footnotes into sidenotes";

     

       196316
       196340
        
              license = lib.licenses.mit;

     

       196317
       196317
       -
              hydraPlatforms = lib.platforms.none;

     

       196318
       196318
       -
              broken = true;

     

       196319
       196341
        
            }) {};

     

       196320
       196342
        
       

     

       196321
       196343
        
         "pandoc-stylefrommeta" = callPackage

     
···

       199472
       199494
        
       

     

       199473
       199495
        
         "pdf-toolbox-content" = callPackage

     

       199474
       199496
        
           ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring

     

       199475
       199475
       -
            , containers, io-streams, pdf-toolbox-core, text

     

       199497
       199497
       +
            , containers, hspec, io-streams, pdf-toolbox-core, scientific, text

     

       199498
       199498
       +
            , vector

     

       199476
       199499
        
            }:

     

       199477
       199500
        
            mkDerivation {

     

       199478
       199501
        
              pname = "pdf-toolbox-content";

     

       199479
       199479
       -
              version = "0.0.5.1";

     

       199480
       199480
       -
              sha256 = "1244r2ij46gs10zxc3mlf2693nnb1jpyminqkpzh71hp5qilw40w";

     

       199502
       199502
       +
              version = "0.1.1";

     

       199503
       199503
       +
              sha256 = "0bdcakhmazxim5npqkb13lh0b65p1xqv2a05c61zv0g64n1d6k5f";

     

       199481
       199504
        
              libraryHaskellDepends = [

     

       199482
       199505
        
                attoparsec base base16-bytestring bytestring containers io-streams

     

       199483
       199483
       -
                pdf-toolbox-core text

     

       199506
       199506
       +
                pdf-toolbox-core scientific text vector

     

       199507
       199507
       +
              ];

     

       199508
       199508
       +
              testHaskellDepends = [

     

       199509
       199509
       +
                attoparsec base bytestring containers hspec io-streams

     

       199510
       199510
       +
                pdf-toolbox-core

     

       199484
       199511
        
              ];

     

       199485
       199512
        
              description = "A collection of tools for processing PDF files";

     

       199486
       199513
        
              license = lib.licenses.bsd3;

     
···

       199489
       199516
        
            }) {};

     

       199490
       199517
        
       

     

       199491
       199518
        
         "pdf-toolbox-core" = callPackage

     

       199492
       199492
       -
           ({ mkDerivation, attoparsec, base, bytestring, containers, errors

     

       199493
       199493
       -
            , io-streams, scientific, transformers, zlib-bindings

     

       199519
       199519
       +
           ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring

     

       199520
       199520
       +
            , cipher-aes, cipher-rc4, containers, crypto-api, cryptohash

     

       199521
       199521
       +
            , hashable, hspec, io-streams, scientific, unordered-containers

     

       199522
       199522
       +
            , vector

     

       199494
       199523
        
            }:

     

       199495
       199524
        
            mkDerivation {

     

       199496
       199525
        
              pname = "pdf-toolbox-core";

     

       199497
       199497
       -
              version = "0.0.4.1";

     

       199498
       199498
       -
              sha256 = "10d9fchmiwdbkbdxqmn5spim4pywc1qm9q9c0dhmsssryng99qyc";

     

       199526
       199526
       +
              version = "0.1.1";

     

       199527
       199527
       +
              sha256 = "1d5bk7qbcgz99xa61xi17z0hgr3w2by3d5mr2vgd0hpcdi5ygskz";

     

       199528
       199528
       +
              revision = "1";

     

       199529
       199529
       +
              editedCabalFile = "1h5nh360zaql29lw3mcykip7bvnnjjcxmpaaz3s842a227m9wflz";

     

       199499
       199530
        
              libraryHaskellDepends = [

     

       199500
       199500
       -
                attoparsec base bytestring containers errors io-streams scientific

     

       199501
       199501
       -
                transformers zlib-bindings

     

       199531
       199531
       +
                attoparsec base base16-bytestring bytestring cipher-aes cipher-rc4

     

       199532
       199532
       +
                containers crypto-api cryptohash hashable io-streams scientific

     

       199533
       199533
       +
                unordered-containers vector

     

       199534
       199534
       +
              ];

     

       199535
       199535
       +
              testHaskellDepends = [

     

       199536
       199536
       +
                attoparsec base bytestring hspec io-streams unordered-containers

     

       199537
       199537
       +
                vector

     

       199502
       199538
        
              ];

     

       199503
       199539
        
              description = "A collection of tools for processing PDF files";

     

       199504
       199540
        
              license = lib.licenses.bsd3;

     
···

       199507
       199543
        
            }) {};

     

       199508
       199544
        
       

     

       199509
       199545
        
         "pdf-toolbox-document" = callPackage

     

       199510
       199510
       -
           ({ mkDerivation, base, bytestring, cipher-aes, cipher-rc4

     

       199511
       199511
       -
            , containers, crypto-api, cryptohash, io-streams

     

       199512
       199512
       -
            , pdf-toolbox-content, pdf-toolbox-core, text, transformers

     

       199546
       199546
       +
           ({ mkDerivation, base, bytestring, containers, directory, hspec

     

       199547
       199547
       +
            , io-streams, pdf-toolbox-content, pdf-toolbox-core, text

     

       199548
       199548
       +
            , unordered-containers, vector

     

       199513
       199549
        
            }:

     

       199514
       199550
        
            mkDerivation {

     

       199515
       199551
        
              pname = "pdf-toolbox-document";

     

       199516
       199516
       -
              version = "0.0.7.1";

     

       199517
       199517
       -
              sha256 = "1qghjsaya0wnl3vil8gv6a3crd94mmvl3y73k2cwzhc5madkfz9z";

     

       199552
       199552
       +
              version = "0.1.2";

     

       199553
       199553
       +
              sha256 = "172vxsv541hsdkk08rsr21rwdrcxwmf4pwjmgsq2rjwj4ba4723y";

     

       199518
       199554
        
              libraryHaskellDepends = [

     

       199519
       199519
       -
                base bytestring cipher-aes cipher-rc4 containers crypto-api

     

       199520
       199520
       -
                cryptohash io-streams pdf-toolbox-content pdf-toolbox-core text

     

       199521
       199521
       -
                transformers

     

       199555
       199555
       +
                base bytestring containers io-streams pdf-toolbox-content

     

       199556
       199556
       +
                pdf-toolbox-core text unordered-containers vector

     

       199557
       199557
       +
              ];

     

       199558
       199558
       +
              testHaskellDepends = [

     

       199559
       199559
       +
                base directory hspec io-streams pdf-toolbox-core

     

       199560
       199560
       +
                unordered-containers

     

       199522
       199561
        
              ];

     

       199523
       199562
        
              description = "A collection of tools for processing PDF files";

     

       199524
       199563
        
              license = lib.licenses.bsd3;

     
···

       200350
       200389
        
              ];

     

       200351
       200390
        
              description = "Periodic task system haskell client";

     

       200352
       200391
        
              license = lib.licenses.bsd3;

     

       200392
       200392
       +
              hydraPlatforms = lib.platforms.none;

     

       200393
       200393
       +
              broken = true;

     

       200353
       200394
        
            }) {};

     

       200354
       200395
        
       

     

       200355
       200396
        
         "periodic-client-exe" = callPackage

     
···

       200374
       200415
        
              ];

     

       200375
       200416
        
              description = "Periodic task system haskell client executables";

     

       200376
       200417
        
              license = lib.licenses.bsd3;

     

       200418
       200418
       +
              hydraPlatforms = lib.platforms.none;

     

       200419
       200419
       +
              broken = true;

     

       200377
       200420
        
            }) {};

     

       200378
       200421
        
       

     

       200379
       200422
        
         "periodic-common" = callPackage

     
···

       200390
       200433
        
              ];

     

       200391
       200434
        
              description = "Periodic task system common";

     

       200392
       200435
        
              license = lib.licenses.bsd3;

     

       200436
       200436
       +
              hydraPlatforms = lib.platforms.none;

     

       200437
       200437
       +
              broken = true;

     

       200393
       200438
        
            }) {};

     

       200394
       200439
        
       

     

       200395
       200440
        
         "periodic-polynomials" = callPackage

     
···

       200942
       200987
        
              license = lib.licenses.mit;

     

       200943
       200988
        
            }) {};

     

       200944
       200989
        
       

     

       200945
       200945
       -
         "persistent-mysql_2_12_0_0" = callPackage

     

       200990
       200990
       +
         "persistent-mysql_2_12_1_0" = callPackage

     

       200946
       200991
        
           ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit

     

       200947
       200992
        
            , containers, fast-logger, hspec, HUnit, monad-logger, mysql

     

       200948
       200993
        
            , mysql-simple, persistent, persistent-qq, persistent-test

     
···

       200951
       200996
        
            }:

     

       200952
       200997
        
            mkDerivation {

     

       200953
       200998
        
              pname = "persistent-mysql";

     

       200954
       200954
       -
              version = "2.12.0.0";

     

       200955
       200955
       -
              sha256 = "0bvwlkch8pr94dv1fib85vdsdrjpdla1rm4lslrmpg0dysgni9p3";

     

       200999
       200999
       +
              version = "2.12.1.0";

     

       201000
       201000
       +
              sha256 = "08494wc935gfr3007w2x9lvqcp8y2jvapgwjxz1l0mnl120vh8hw";

     

       200956
       201001
        
              libraryHaskellDepends = [

     

       200957
       201002
        
                aeson base blaze-builder bytestring conduit containers monad-logger

     

       200958
       201003
        
                mysql mysql-simple persistent resource-pool resourcet text

     
···

       202256
       202301
        
            }) {};

     

       202257
       202302
        
       

     

       202258
       202303
        
         "phonetic-languages-phonetics-basics" = callPackage

     

       202259
       202259
       -
           ({ mkDerivation, base, mmsyn2-array, mmsyn5 }:

     

       202304
       202304
       +
           ({ mkDerivation, base, foldable-ix, lists-flines, mmsyn2-array

     

       202305
       202305
       +
            , mmsyn5

     

       202306
       202306
       +
            }:

     

       202260
       202307
        
            mkDerivation {

     

       202261
       202308
        
              pname = "phonetic-languages-phonetics-basics";

     

       202262
       202262
       -
              version = "0.3.2.0";

     

       202263
       202263
       -
              sha256 = "0r4f69ky1y45h6fys1821z45ccg30h61yc68x16cf839awfri92l";

     

       202264
       202264
       -
              libraryHaskellDepends = [ base mmsyn2-array mmsyn5 ];

     

       202309
       202309
       +
              version = "0.5.1.0";

     

       202310
       202310
       +
              sha256 = "1pqc16llr1ar7z6lfbniinxx7q09qpamajmbl3d9njhk4pwdl6b8";

     

       202311
       202311
       +
              isLibrary = true;

     

       202312
       202312
       +
              isExecutable = true;

     

       202313
       202313
       +
              libraryHaskellDepends = [

     

       202314
       202314
       +
                base foldable-ix lists-flines mmsyn2-array mmsyn5

     

       202315
       202315
       +
              ];

     

       202316
       202316
       +
              executableHaskellDepends = [

     

       202317
       202317
       +
                base foldable-ix lists-flines mmsyn2-array mmsyn5

     

       202318
       202318
       +
              ];

     

       202265
       202319
        
              description = "A library for working with generalized phonetic languages usage";

     

       202266
       202320
        
              license = lib.licenses.mit;

     

       202267
       202321
        
            }) {};

     
···

       203084
       203138
        
            }:

     

       203085
       203139
        
            mkDerivation {

     

       203086
       203140
        
              pname = "pinch-gen";

     

       203087
       203087
       -
              version = "0.4.0.0";

     

       203088
       203088
       -
              sha256 = "03fpcy2mdq83mpx4hv6x57csdwd07pkqcfqc0wd10zys77i75s46";

     

       203141
       203141
       +
              version = "0.4.1.0";

     

       203142
       203142
       +
              sha256 = "11sk0lmzsxw0k8i8airpv7p461z25n6y2fygx0l7gv0zadaici2v";

     

       203089
       203143
        
              isLibrary = false;

     

       203090
       203144
        
              isExecutable = true;

     

       203091
       203145
        
              executableHaskellDepends = [

     
···

       203205
       203259
        
              license = lib.licenses.asl20;

     

       203206
       203260
        
            }) {};

     

       203207
       203261
        
       

     

       203262
       203262
       +
         "pinned-warnings" = callPackage

     

       203263
       203263
       +
           ({ mkDerivation, base, bytestring, containers, directory, ghc }:

     

       203264
       203264
       +
            mkDerivation {

     

       203265
       203265
       +
              pname = "pinned-warnings";

     

       203266
       203266
       +
              version = "0.1.0.1";

     

       203267
       203267
       +
              sha256 = "0yrd4lqr1sklswalpx7j1bmqjsc19y080wcgq4qd0fmc3qhcixjc";

     

       203268
       203268
       +
              libraryHaskellDepends = [

     

       203269
       203269
       +
                base bytestring containers directory ghc

     

       203270
       203270
       +
              ];

     

       203271
       203271
       +
              description = "Preserve warnings in a GHCi session";

     

       203272
       203272
       +
              license = lib.licenses.bsd3;

     

       203273
       203273
       +
            }) {};

     

       203274
       203274
       +
       

     

       203208
       203275
        
         "pinpon" = callPackage

     

       203209
       203276
        
           ({ mkDerivation, aeson, aeson-pretty, amazonka, amazonka-core

     

       203210
       203277
        
            , amazonka-sns, base, bytestring, containers, doctest, exceptions

     
···

       204718
       204785
        
            }) {};

     

       204719
       204786
        
       

     

       204720
       204787
        
         "pkgtreediff" = callPackage

     

       204721
       204721
       -
           ({ mkDerivation, async, base, directory, filepath, Glob

     

       204722
       204722
       -
            , http-client, http-client-tls, http-directory, simple-cmd

     

       204723
       204723
       -
            , simple-cmd-args, text

     

       204724
       204724
       -
            }:

     

       204725
       204725
       -
            mkDerivation {

     

       204726
       204726
       -
              pname = "pkgtreediff";

     

       204727
       204727
       -
              version = "0.4";

     

       204728
       204728
       -
              sha256 = "00cah2sbfx824zvg4ywm3qw8rkibflj9lmw1z0ywsalgdmmlp460";

     

       204729
       204729
       -
              isLibrary = false;

     

       204730
       204730
       -
              isExecutable = true;

     

       204731
       204731
       -
              executableHaskellDepends = [

     

       204732
       204732
       -
                async base directory filepath Glob http-client http-client-tls

     

       204733
       204733
       -
                http-directory simple-cmd simple-cmd-args text

     

       204734
       204734
       -
              ];

     

       204735
       204735
       -
              description = "Package tree diff tool";

     

       204736
       204736
       -
              license = lib.licenses.gpl3Only;

     

       204737
       204737
       -
              hydraPlatforms = lib.platforms.none;

     

       204738
       204738
       -
              broken = true;

     

       204739
       204739
       -
            }) {};

     

       204740
       204740
       -
       

     

       204741
       204741
       -
         "pkgtreediff_0_4_1" = callPackage

     

       204742
       204788
        
           ({ mkDerivation, async, base, directory, extra, filepath, Glob

     

       204743
       204789
        
            , http-client, http-client-tls, http-directory, koji, simple-cmd

     

       204744
       204790
        
            , simple-cmd-args, text

     
···

       206269
       206315
        
            }:

     

       206270
       206316
        
            mkDerivation {

     

       206271
       206317
        
              pname = "polysemy-RandomFu";

     

       206272
       206272
       -
              version = "0.4.1.0";

     

       206273
       206273
       -
              sha256 = "1gr7nyzz1wwl7c22q21c8y8r94b8sp0r5kma20w3avg6p0l53bm3";

     

       206318
       206318
       +
              version = "0.4.2.0";

     

       206319
       206319
       +
              sha256 = "0rsmdp7p0asmaf13wf5ky0ngrmnqdfbi67y4a0vcwqvknqmlys2y";

     

       206274
       206320
        
              libraryHaskellDepends = [

     

       206275
       206321
        
                base polysemy polysemy-plugin polysemy-zoo random-fu random-source

     

       206276
       206322
        
              ];

     
···

       206346
       206392
        
              ];

     

       206347
       206393
        
              description = "Extra Input and Output functions for polysemy..";

     

       206348
       206394
        
              license = lib.licenses.mit;

     

       206395
       206395
       +
              hydraPlatforms = lib.platforms.none;

     

       206396
       206396
       +
              broken = true;

     

       206349
       206397
        
            }) {};

     

       206350
       206398
        
       

     

       206351
       206399
        
         "polysemy-fs" = callPackage

     
···

       206376
       206424
        
              ];

     

       206377
       206425
        
              description = "Run a KVStore as a filesystem in polysemy";

     

       206378
       206426
        
              license = lib.licenses.mit;

     

       206427
       206427
       +
              hydraPlatforms = lib.platforms.none;

     

       206428
       206428
       +
              broken = true;

     

       206379
       206429
        
            }) {};

     

       206380
       206430
        
       

     

       206381
       206431
        
         "polysemy-http" = callPackage

     
···

       206423
       206473
        
              ];

     

       206424
       206474
        
              description = "Run a KVStore as a single json file in polysemy";

     

       206425
       206475
        
              license = lib.licenses.mit;

     

       206476
       206476
       +
              hydraPlatforms = lib.platforms.none;

     

       206477
       206477
       +
              broken = true;

     

       206426
       206478
        
            }) {};

     

       206427
       206479
        
       

     

       206428
       206480
        
         "polysemy-log" = callPackage

     
···

       206693
       206745
        
              libraryHaskellDepends = [ base polysemy polysemy-extra vinyl ];

     

       206694
       206746
        
              description = "Functions for mapping vinyl records in polysemy";

     

       206695
       206747
        
              license = lib.licenses.mit;

     

       206748
       206748
       +
              hydraPlatforms = lib.platforms.none;

     

       206749
       206749
       +
              broken = true;

     

       206696
       206750
        
            }) {};

     

       206697
       206751
        
       

     

       206698
       206752
        
         "polysemy-webserver" = callPackage

     
···

       206738
       206792
        
              testToolDepends = [ hspec-discover ];

     

       206739
       206793
        
              description = "Experimental, user-contributed effects and interpreters for polysemy";

     

       206740
       206794
        
              license = lib.licenses.bsd3;

     

       206795
       206795
       +
              hydraPlatforms = lib.platforms.none;

     

       206796
       206796
       +
              broken = true;

     

       206741
       206797
        
            }) {};

     

       206742
       206798
        
       

     

       206743
       206799
        
         "polyseq" = callPackage

     
···

       208213
       208269
        
              pname = "postgresql-simple-migration";

     

       208214
       208270
        
              version = "0.1.15.0";

     

       208215
       208271
        
              sha256 = "0j6nhyknxlmpl0yrdj1pifw1fbb24080jgg64grnhqjwh1d44dvd";

     

       208272
       208272
       +
              revision = "1";

     

       208273
       208273
       +
              editedCabalFile = "1a0a5295j207x0pzbhy5inv8qimrh76dmmp26zgaw073n1i8yg8j";

     

       208216
       208274
        
              isLibrary = true;

     

       208217
       208275
        
              isExecutable = true;

     

       208218
       208276
        
              libraryHaskellDepends = [

     
···

       212616
       212674
        
            }:

     

       212617
       212675
        
            mkDerivation {

     

       212618
       212676
        
              pname = "proto3-wire";

     

       212619
       212619
       -
              version = "1.2.0";

     

       212620
       212620
       -
              sha256 = "1xrnrh4njnw6af8xxg9xhcxrscg0g644jx4l9an4iqz6xmjp2nk2";

     

       212621
       212621
       -
              revision = "1";

     

       212622
       212622
       -
              editedCabalFile = "14cjzgh364b836sg7szwrkvmm19hg8w57hdbsrsgwa7k9rhqi349";

     

       212623
       212623
       -
              libraryHaskellDepends = [

     

       212624
       212624
       -
                base bytestring cereal containers deepseq ghc-prim hashable

     

       212625
       212625
       -
                parameterized primitive QuickCheck safe text transformers

     

       212626
       212626
       -
                unordered-containers vector

     

       212627
       212627
       -
              ];

     

       212628
       212628
       -
              testHaskellDepends = [

     

       212629
       212629
       -
                base bytestring cereal doctest QuickCheck tasty tasty-hunit

     

       212630
       212630
       -
                tasty-quickcheck text transformers vector

     

       212631
       212631
       -
              ];

     

       212632
       212632
       -
              description = "A low-level implementation of the Protocol Buffers (version 3) wire format";

     

       212633
       212633
       -
              license = lib.licenses.asl20;

     

       212634
       212634
       -
              hydraPlatforms = lib.platforms.none;

     

       212635
       212635
       -
              broken = true;

     

       212636
       212636
       -
            }) {};

     

       212637
       212637
       -
       

     

       212638
       212638
       -
         "proto3-wire_1_2_1" = callPackage

     

       212639
       212639
       -
           ({ mkDerivation, base, bytestring, cereal, containers, deepseq

     

       212640
       212640
       -
            , doctest, ghc-prim, hashable, parameterized, primitive, QuickCheck

     

       212641
       212641
       -
            , safe, tasty, tasty-hunit, tasty-quickcheck, text, transformers

     

       212642
       212642
       -
            , unordered-containers, vector

     

       212643
       212643
       -
            }:

     

       212644
       212644
       -
            mkDerivation {

     

       212645
       212645
       -
              pname = "proto3-wire";

     

       212646
       212677
        
              version = "1.2.1";

     

       212647
       212678
        
              sha256 = "0i706y9j5iq5zyi86vkiybznp3b4h2x0flvq3jmr8mgpgahvh94r";

     

       212648
       212679
        
              libraryHaskellDepends = [

     
···

       218262
       218293
        
            }:

     

       218263
       218294
        
            mkDerivation {

     

       218264
       218295
        
              pname = "rattletrap";

     

       218265
       218265
       -
              version = "11.0.1";

     

       218266
       218266
       -
              sha256 = "1s9n89i6mh3lw9mni5lgs8qnq5c1981hrz5bv0n9cffnnp45av6a";

     

       218296
       218296
       +
              version = "11.1.0";

     

       218297
       218297
       +
              sha256 = "1q915fq9bjwridd67rsmavxcbkgp3xxq9ps09z6mi62608c26987";

     

       218267
       218298
        
              isLibrary = true;

     

       218268
       218299
        
              isExecutable = true;

     

       218269
       218300
        
              libraryHaskellDepends = [

     
···

       220253
       220284
        
              license = lib.licenses.bsd3;

     

       220254
       220285
        
            }) {};

     

       220255
       220286
        
       

     

       220287
       220287
       +
         "ref-fd_0_5" = callPackage

     

       220288
       220288
       +
           ({ mkDerivation, base, stm, transformers }:

     

       220289
       220289
       +
            mkDerivation {

     

       220290
       220290
       +
              pname = "ref-fd";

     

       220291
       220291
       +
              version = "0.5";

     

       220292
       220292
       +
              sha256 = "1r34xyyx0fyl1fc64n1hhk0m2s1l808kjb18dmj8w0y91w4ms6qj";

     

       220293
       220293
       +
              libraryHaskellDepends = [ base stm transformers ];

     

       220294
       220294
       +
              description = "A type class for monads with references using functional dependencies";

     

       220295
       220295
       +
              license = lib.licenses.bsd3;

     

       220296
       220296
       +
              hydraPlatforms = lib.platforms.none;

     

       220297
       220297
       +
            }) {};

     

       220298
       220298
       +
       

     

       220256
       220299
        
         "ref-mtl" = callPackage

     

       220257
       220300
        
           ({ mkDerivation, base, mtl, stm, transformers }:

     

       220258
       220301
        
            mkDerivation {

     
···

       220277
       220320
        
              license = lib.licenses.bsd3;

     

       220278
       220321
        
            }) {};

     

       220279
       220322
        
       

     

       220323
       220323
       +
         "ref-tf_0_5" = callPackage

     

       220324
       220324
       +
           ({ mkDerivation, base, stm, transformers }:

     

       220325
       220325
       +
            mkDerivation {

     

       220326
       220326
       +
              pname = "ref-tf";

     

       220327
       220327
       +
              version = "0.5";

     

       220328
       220328
       +
              sha256 = "06lf3267b68syiqcwvgw8a7yi0ki3khnh4i9s8z7zjrjnj6h9r4v";

     

       220329
       220329
       +
              libraryHaskellDepends = [ base stm transformers ];

     

       220330
       220330
       +
              description = "A type class for monads with references using type families";

     

       220331
       220331
       +
              license = lib.licenses.bsd3;

     

       220332
       220332
       +
              hydraPlatforms = lib.platforms.none;

     

       220333
       220333
       +
            }) {};

     

       220334
       220334
       +
       

     

       220280
       220335
        
         "refact" = callPackage

     

       220281
       220336
        
           ({ mkDerivation, base }:

     

       220282
       220337
        
            mkDerivation {

     
···

       223022
       223077
        
              license = lib.licenses.publicDomain;

     

       223023
       223078
        
            }) {};

     

       223024
       223079
        
       

     

       223080
       223080
       +
         "reorder-expression" = callPackage

     

       223081
       223081
       +
           ({ mkDerivation, base, hspec, hspec-discover, optics, parsec }:

     

       223082
       223082
       +
            mkDerivation {

     

       223083
       223083
       +
              pname = "reorder-expression";

     

       223084
       223084
       +
              version = "0.1.0.0";

     

       223085
       223085
       +
              sha256 = "01d83j3mq2gz6maqbkzpjrz6ppyhsqrj4rj72xw49fkl2w34pa9f";

     

       223086
       223086
       +
              libraryHaskellDepends = [ base ];

     

       223087
       223087
       +
              testHaskellDepends = [ base hspec optics parsec ];

     

       223088
       223088
       +
              testToolDepends = [ hspec-discover ];

     

       223089
       223089
       +
              description = "Reorder expressions in a syntax tree according to operator fixities";

     

       223090
       223090
       +
              license = lib.licenses.mit;

     

       223091
       223091
       +
              hydraPlatforms = lib.platforms.none;

     

       223092
       223092
       +
              broken = true;

     

       223093
       223093
       +
            }) {};

     

       223094
       223094
       +
       

     

       223025
       223095
        
         "reorderable" = callPackage

     

       223026
       223096
        
           ({ mkDerivation, base, constraints, haskell-src-exts

     

       223027
       223097
        
            , haskell-src-meta, template-haskell

     
···

       223583
       223653
        
            }) {};

     

       223584
       223654
        
       

     

       223585
       223655
        
         "reprinter" = callPackage

     

       223586
       223586
       -
           ({ mkDerivation, base, mtl, syb, syz, text, transformers, uniplate

     

       223656
       223656
       +
           ({ mkDerivation, base, bytestring, hspec, hspec-discover, mtl, syb

     

       223657
       223657
       +
            , syz, text, transformers

     

       223587
       223658
        
            }:

     

       223588
       223659
        
            mkDerivation {

     

       223589
       223660
        
              pname = "reprinter";

     

       223590
       223590
       -
              version = "0.2.0.0";

     

       223591
       223591
       -
              sha256 = "1b3hdz7qq9qk7pbx0ny4ziagjm9hi9wfi9rl0aq0b8p70zzyjiq1";

     

       223661
       223661
       +
              version = "0.3.0.0";

     

       223662
       223662
       +
              sha256 = "04rzgk0q5q75z52x3qyq8ddhyb6krnz1ixhmmvzpcfaq39p00cgh";

     

       223592
       223663
        
              libraryHaskellDepends = [

     

       223593
       223593
       -
                base mtl syb syz text transformers uniplate

     

       223664
       223664
       +
                base bytestring mtl syb syz text transformers

     

       223594
       223665
        
              ];

     

       223666
       223666
       +
              testHaskellDepends = [ base hspec mtl text ];

     

       223667
       223667
       +
              testToolDepends = [ hspec-discover ];

     

       223595
       223668
        
              description = "Scrap Your Reprinter";

     

       223596
       223669
        
              license = lib.licenses.asl20;

     

       223597
       223670
        
              hydraPlatforms = lib.platforms.none;

     
···

       223734
       223807
        
            }:

     

       223735
       223808
        
            mkDerivation {

     

       223736
       223809
        
              pname = "request";

     

       223737
       223737
       -
              version = "0.1.3.0";

     

       223738
       223738
       -
              sha256 = "07ypsdmf227m6j8gkl29621z7grbsgr0pmk3dglx9zlrmq0zbn8j";

     

       223810
       223810
       +
              version = "0.2.0.0";

     

       223811
       223811
       +
              sha256 = "023bldkfjqbwmd6mh4vb2k7z5vi8lfkhf5an057h04dzhpgb3r9l";

     

       223739
       223812
        
              libraryHaskellDepends = [

     

       223740
       223813
        
                base bytestring case-insensitive http-client http-client-tls

     

       223741
       223814
        
                http-types

     
···

       229134
       229207
        
            }:

     

       229135
       229208
        
            mkDerivation {

     

       229136
       229209
        
              pname = "sandwich";

     

       229137
       229137
       -
              version = "0.1.0.2";

     

       229138
       229138
       -
              sha256 = "1xcw3mdl85brj6pvynz58aclaf3ya0aq0y038cps9dsz58bqhbka";

     

       229210
       229210
       +
              version = "0.1.0.3";

     

       229211
       229211
       +
              sha256 = "1gd8k4dx25bgqrw16dwvq9lnk7gpvpci01kvnn3s08ylkiq2qax9";

     

       229212
       229212
       +
              isLibrary = true;

     

       229213
       229213
       +
              isExecutable = true;

     

       229214
       229214
       +
              libraryHaskellDepends = [

     

       229215
       229215
       +
                aeson ansi-terminal async base brick bytestring colour containers

     

       229216
       229216
       +
                directory exceptions filepath free haskell-src-exts lens

     

       229217
       229217
       +
                lifted-async microlens microlens-th monad-control monad-logger mtl

     

       229218
       229218
       +
                optparse-applicative pretty-show process safe safe-exceptions stm

     

       229219
       229219
       +
                string-interpolate template-haskell text time transformers

     

       229220
       229220
       +
                transformers-base unix unliftio-core vector vty

     

       229221
       229221
       +
              ];

     

       229222
       229222
       +
              executableHaskellDepends = [

     

       229223
       229223
       +
                aeson ansi-terminal async base brick bytestring colour containers

     

       229224
       229224
       +
                directory exceptions filepath free haskell-src-exts lens

     

       229225
       229225
       +
                lifted-async microlens microlens-th monad-control monad-logger mtl

     

       229226
       229226
       +
                optparse-applicative pretty-show process safe safe-exceptions stm

     

       229227
       229227
       +
                string-interpolate template-haskell text time transformers

     

       229228
       229228
       +
                transformers-base unix unliftio-core vector vty

     

       229229
       229229
       +
              ];

     

       229230
       229230
       +
              testHaskellDepends = [

     

       229231
       229231
       +
                aeson ansi-terminal async base brick bytestring colour containers

     

       229232
       229232
       +
                directory exceptions filepath free haskell-src-exts lens

     

       229233
       229233
       +
                lifted-async microlens microlens-th monad-control monad-logger mtl

     

       229234
       229234
       +
                optparse-applicative pretty-show process safe safe-exceptions stm

     

       229235
       229235
       +
                string-interpolate template-haskell text time transformers

     

       229236
       229236
       +
                transformers-base unix unliftio-core vector vty

     

       229237
       229237
       +
              ];

     

       229238
       229238
       +
              description = "Yet another test framework for Haskell";

     

       229239
       229239
       +
              license = lib.licenses.bsd3;

     

       229240
       229240
       +
            }) {};

     

       229241
       229241
       +
       

     

       229242
       229242
       +
         "sandwich_0_1_0_5" = callPackage

     

       229243
       229243
       +
           ({ mkDerivation, aeson, ansi-terminal, async, base, brick

     

       229244
       229244
       +
            , bytestring, colour, containers, directory, exceptions, filepath

     

       229245
       229245
       +
            , free, haskell-src-exts, lens, lifted-async, microlens

     

       229246
       229246
       +
            , microlens-th, monad-control, monad-logger, mtl

     

       229247
       229247
       +
            , optparse-applicative, pretty-show, process, safe, safe-exceptions

     

       229248
       229248
       +
            , stm, string-interpolate, template-haskell, text, time

     

       229249
       229249
       +
            , transformers, transformers-base, unix, unliftio-core, vector, vty

     

       229250
       229250
       +
            }:

     

       229251
       229251
       +
            mkDerivation {

     

       229252
       229252
       +
              pname = "sandwich";

     

       229253
       229253
       +
              version = "0.1.0.5";

     

       229254
       229254
       +
              sha256 = "1np5c81jbv2k6sszrg7wwf2ymbnpn2pak8fji1phk79sdr04qmfh";

     

       229139
       229255
        
              isLibrary = true;

     

       229140
       229256
        
              isExecutable = true;

     

       229141
       229257
        
              libraryHaskellDepends = [

     
···

       229164
       229280
        
              ];

     

       229165
       229281
        
              description = "Yet another test framework for Haskell";

     

       229166
       229282
        
              license = lib.licenses.bsd3;

     

       229283
       229283
       +
              hydraPlatforms = lib.platforms.none;

     

       229284
       229284
       +
            }) {};

     

       229285
       229285
       +
       

     

       229286
       229286
       +
         "sandwich-quickcheck" = callPackage

     

       229287
       229287
       +
           ({ mkDerivation, base, free, monad-control, QuickCheck

     

       229288
       229288
       +
            , safe-exceptions, sandwich, string-interpolate, time

     

       229289
       229289
       +
            }:

     

       229290
       229290
       +
            mkDerivation {

     

       229291
       229291
       +
              pname = "sandwich-quickcheck";

     

       229292
       229292
       +
              version = "0.1.0.4";

     

       229293
       229293
       +
              sha256 = "0sljlpnhv5wpda1w9nh5da2psmg9snias8k9dr62y9khymn3aya7";

     

       229294
       229294
       +
              isLibrary = true;

     

       229295
       229295
       +
              isExecutable = true;

     

       229296
       229296
       +
              libraryHaskellDepends = [

     

       229297
       229297
       +
                base free monad-control QuickCheck safe-exceptions sandwich

     

       229298
       229298
       +
                string-interpolate time

     

       229299
       229299
       +
              ];

     

       229300
       229300
       +
              executableHaskellDepends = [

     

       229301
       229301
       +
                base free monad-control QuickCheck safe-exceptions sandwich

     

       229302
       229302
       +
                string-interpolate time

     

       229303
       229303
       +
              ];

     

       229304
       229304
       +
              testHaskellDepends = [

     

       229305
       229305
       +
                base free monad-control QuickCheck safe-exceptions sandwich

     

       229306
       229306
       +
                string-interpolate time

     

       229307
       229307
       +
              ];

     

       229308
       229308
       +
              description = "Sandwich integration with QuickCheck";

     

       229309
       229309
       +
              license = lib.licenses.bsd3;

     

       229167
       229310
        
            }) {};

     

       229168
       229311
        
       

     

       229169
       229312
        
         "sandwich-slack" = callPackage

     
···

       229173
       229316
        
            }:

     

       229174
       229317
        
            mkDerivation {

     

       229175
       229318
        
              pname = "sandwich-slack";

     

       229176
       229176
       -
              version = "0.1.0.1";

     

       229177
       229177
       -
              sha256 = "1c7csrdfq342733rgrfwx5rc6v14jhfb9wb44gn699pgzzj031kz";

     

       229319
       229319
       +
              version = "0.1.0.3";

     

       229320
       229320
       +
              sha256 = "1g8ymxy4q08jxlfbd7ar6n30wm1mcm942vr5627bpx63m83yld1y";

     

       229321
       229321
       +
              isLibrary = true;

     

       229322
       229322
       +
              isExecutable = true;

     

       229323
       229323
       +
              libraryHaskellDepends = [

     

       229324
       229324
       +
                aeson base bytestring containers lens lens-aeson monad-logger mtl

     

       229325
       229325
       +
                safe safe-exceptions sandwich stm string-interpolate text time

     

       229326
       229326
       +
                vector wreq

     

       229327
       229327
       +
              ];

     

       229328
       229328
       +
              executableHaskellDepends = [

     

       229329
       229329
       +
                aeson base bytestring containers lens lens-aeson monad-logger mtl

     

       229330
       229330
       +
                safe safe-exceptions sandwich stm string-interpolate text time

     

       229331
       229331
       +
                vector wreq

     

       229332
       229332
       +
              ];

     

       229333
       229333
       +
              testHaskellDepends = [

     

       229334
       229334
       +
                aeson base bytestring containers lens lens-aeson monad-logger mtl

     

       229335
       229335
       +
                safe safe-exceptions sandwich stm string-interpolate text time

     

       229336
       229336
       +
                vector wreq

     

       229337
       229337
       +
              ];

     

       229338
       229338
       +
              description = "Sandwich integration with Slack";

     

       229339
       229339
       +
              license = lib.licenses.bsd3;

     

       229340
       229340
       +
            }) {};

     

       229341
       229341
       +
       

     

       229342
       229342
       +
         "sandwich-slack_0_1_0_4" = callPackage

     

       229343
       229343
       +
           ({ mkDerivation, aeson, base, bytestring, containers, lens

     

       229344
       229344
       +
            , lens-aeson, monad-logger, mtl, safe, safe-exceptions, sandwich

     

       229345
       229345
       +
            , stm, string-interpolate, text, time, vector, wreq

     

       229346
       229346
       +
            }:

     

       229347
       229347
       +
            mkDerivation {

     

       229348
       229348
       +
              pname = "sandwich-slack";

     

       229349
       229349
       +
              version = "0.1.0.4";

     

       229350
       229350
       +
              sha256 = "1l296q3lxafj3gd7pr6n6qrvcb4zdkncsj2z6ra6q0qfw465jaqk";

     

       229178
       229351
        
              isLibrary = true;

     

       229179
       229352
        
              isExecutable = true;

     

       229180
       229353
        
              libraryHaskellDepends = [

     
···

       229194
       229367
        
              ];

     

       229195
       229368
        
              description = "Sandwich integration with Slack";

     

       229196
       229369
        
              license = lib.licenses.bsd3;

     

       229370
       229370
       +
              hydraPlatforms = lib.platforms.none;

     

       229197
       229371
        
            }) {};

     

       229198
       229372
        
       

     

       229199
       229373
        
         "sandwich-webdriver" = callPackage

     
···

       229207
       229381
        
            }:

     

       229208
       229382
        
            mkDerivation {

     

       229209
       229383
        
              pname = "sandwich-webdriver";

     

       229210
       229210
       -
              version = "0.1.0.1";

     

       229211
       229211
       -
              sha256 = "10s0zb3al4ii9gm3b6by8czvr8i3s424mlfk81v2hpdv5i7a0yqb";

     

       229384
       229384
       +
              version = "0.1.0.4";

     

       229385
       229385
       +
              sha256 = "0vmqm2f78vd8kk0adg7ldd6rlb5rw5hks9q705gws9dj6s4nyz9r";

     

       229212
       229386
        
              isLibrary = true;

     

       229213
       229387
        
              isExecutable = true;

     

       229214
       229388
        
              libraryHaskellDepends = [

     
···

       229253
       229427
        
            }) {};

     

       229254
       229428
        
       

     

       229255
       229429
        
         "sarsi" = callPackage

     

       229256
       229256
       -
           ({ mkDerivation, async, attoparsec, base, binary, bytestring, Cabal

     

       229257
       229257
       -
            , containers, cryptonite, data-msgpack, directory, filepath

     

       229430
       229430
       +
           ({ mkDerivation, ansi-terminal, async, attoparsec, base, binary

     

       229431
       229431
       +
            , bytestring, Cabal, containers, cryptonite, directory, filepath

     

       229258
       229432
        
            , fsnotify, machines, machines-binary, machines-io

     

       229259
       229259
       -
            , machines-process, network, process, stm, text

     

       229433
       229433
       +
            , machines-process, msgpack, network, process, stm, text

     

       229260
       229434
        
            , unordered-containers, vector

     

       229261
       229435
        
            }:

     

       229262
       229436
        
            mkDerivation {

     

       229263
       229437
        
              pname = "sarsi";

     

       229264
       229264
       -
              version = "0.0.4.0";

     

       229265
       229265
       -
              sha256 = "0lv7mlhkf894q4750x53qr7fa7479hpczhgm1xw2xm5n49z35iy9";

     

       229438
       229438
       +
              version = "0.0.5.2";

     

       229439
       229439
       +
              sha256 = "1xqnpqq2hhqkp4y9lp11l0lmp61v19wfqx0g5dfaq8z7k0dq41fm";

     

       229266
       229440
        
              isLibrary = true;

     

       229267
       229441
        
              isExecutable = true;

     

       229268
       229442
        
              libraryHaskellDepends = [

     

       229269
       229269
       -
                async attoparsec base binary bytestring containers cryptonite

     

       229270
       229270
       -
                data-msgpack directory filepath fsnotify machines machines-binary

     

       229271
       229271
       -
                machines-io machines-process network process stm text vector

     

       229443
       229443
       +
                ansi-terminal async attoparsec base binary bytestring containers

     

       229444
       229444
       +
                cryptonite directory filepath fsnotify machines machines-binary

     

       229445
       229445
       +
                machines-io machines-process msgpack network process stm text

     

       229446
       229446
       +
                vector

     

       229272
       229447
        
              ];

     

       229273
       229448
        
              executableHaskellDepends = [

     

       229274
       229274
       -
                base binary bytestring Cabal containers data-msgpack directory

     

       229275
       229275
       -
                filepath machines machines-binary machines-io machines-process

     

       229276
       229276
       -
                network process text unordered-containers vector

     

       229449
       229449
       +
                async base binary bytestring Cabal containers directory filepath

     

       229450
       229450
       +
                machines machines-binary machines-io machines-process msgpack

     

       229451
       229451
       +
                network process stm text unordered-containers vector

     

       229277
       229452
        
              ];

     

       229278
       229453
        
              description = "A universal quickfix toolkit and his protocol";

     

       229279
       229454
        
              license = lib.licenses.asl20;

     
···

       229927
       230102
        
              testHaskellDepends = [ attoparsec base bytestring hspec scanner ];

     

       229928
       230103
        
              description = "Inject attoparsec parser with backtracking into non-backtracking scanner";

     

       229929
       230104
        
              license = lib.licenses.bsd3;

     

       230105
       230105
       +
              hydraPlatforms = lib.platforms.none;

     

       230106
       230106
       +
              broken = true;

     

       229930
       230107
        
            }) {};

     

       229931
       230108
        
       

     

       229932
       230109
        
         "scat" = callPackage

     
···

       233797
       233974
        
              broken = true;

     

       233798
       233975
        
            }) {};

     

       233799
       233976
        
       

     

       233977
       233977
       +
         "servant-benchmark" = callPackage

     

       233978
       233978
       +
           ({ mkDerivation, aeson, base, base64-bytestring, bytestring

     

       233979
       233979
       +
            , case-insensitive, hspec, http-media, http-types, QuickCheck

     

       233980
       233980
       +
            , servant, text, yaml

     

       233981
       233981
       +
            }:

     

       233982
       233982
       +
            mkDerivation {

     

       233983
       233983
       +
              pname = "servant-benchmark";

     

       233984
       233984
       +
              version = "0.1.1.1";

     

       233985
       233985
       +
              sha256 = "1rsj819kg17p31ky5ad28hydrkh39nsfwkq3f9zdkqm2j924idhx";

     

       233986
       233986
       +
              libraryHaskellDepends = [

     

       233987
       233987
       +
                aeson base base64-bytestring bytestring case-insensitive http-media

     

       233988
       233988
       +
                http-types QuickCheck servant text yaml

     

       233989
       233989
       +
              ];

     

       233990
       233990
       +
              testHaskellDepends = [

     

       233991
       233991
       +
                aeson base base64-bytestring bytestring case-insensitive hspec

     

       233992
       233992
       +
                http-media http-types QuickCheck servant text yaml

     

       233993
       233993
       +
              ];

     

       233994
       233994
       +
              description = "Generate benchmark files from a Servant API";

     

       233995
       233995
       +
              license = lib.licenses.bsd3;

     

       233996
       233996
       +
              hydraPlatforms = lib.platforms.none;

     

       233997
       233997
       +
              broken = true;

     

       233998
       233998
       +
            }) {};

     

       233999
       233999
       +
       

     

       233800
       234000
        
         "servant-blaze" = callPackage

     

       233801
       234001
        
           ({ mkDerivation, base, blaze-html, http-media, servant

     

       233802
       234002
        
            , servant-server, wai, warp

     
···

       234910
       235110
        
            }:

     

       234911
       235111
        
            mkDerivation {

     

       234912
       235112
        
              pname = "servant-openapi3";

     

       234913
       234913
       -
              version = "2.0.1.1";

     

       234914
       234914
       -
              sha256 = "1cyzyljmdfr3gigdszcpj1i7l698fnxpc9hr83mzspm6qcmbqmgf";

     

       234915
       234915
       -
              revision = "2";

     

       234916
       234916
       -
              editedCabalFile = "0y214pgkfkysvdll15inf44psyqj7dmzcwp2vjynwdlywy2j0y16";

     

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

     

       234918
       234918
       -
              libraryHaskellDepends = [

     

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

     

       234920
       234920
       -
                insert-ordered-containers lens openapi3 QuickCheck servant

     

       234921
       234921
       -
                singleton-bool text unordered-containers

     

       234922
       234922
       -
              ];

     

       234923
       234923
       -
              testHaskellDepends = [

     

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

     

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

     

       234926
       234926
       -
                utf8-string vector

     

       234927
       234927
       -
              ];

     

       234928
       234928
       -
              testToolDepends = [ hspec-discover ];

     

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

     

       234930
       234930
       -
              license = lib.licenses.bsd3;

     

       234931
       234931
       -
              hydraPlatforms = lib.platforms.none;

     

       234932
       234932
       -
              broken = true;

     

       234933
       234933
       -
            }) {};

     

       234934
       234934
       -
       

     

       234935
       234935
       -
         "servant-openapi3_2_0_1_2" = callPackage

     

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

     

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

     

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

     

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

     

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

     

       234941
       234941
       -
            , vector

     

       234942
       234942
       -
            }:

     

       234943
       234943
       -
            mkDerivation {

     

       234944
       234944
       -
              pname = "servant-openapi3";

     

       234945
       235113
        
              version = "2.0.1.2";

     

       234946
       235114
        
              sha256 = "1lqvycbv49x0i3adbsdlcl49n65wxfjzhiz9pj11hg4k0j952q5p";

     

       234947
       235115
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       234958
       235126
        
              testToolDepends = [ hspec-discover ];

     

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

     

       234960
       235128
        
              license = lib.licenses.bsd3;

     

       234961
       234961
       -
              hydraPlatforms = lib.platforms.none;

     

       234962
       234962
       -
              broken = true;

     

       234963
       235129
        
            }) {};

     

       234964
       235130
        
       

     

       234965
       235131
        
         "servant-options" = callPackage

     
···

       235045
       235211
        
            }:

     

       235046
       235212
        
            mkDerivation {

     

       235047
       235213
        
              pname = "servant-polysemy";

     

       235048
       235048
       -
              version = "0.1.2";

     

       235049
       235049
       -
              sha256 = "05qk2kl90lqszwhi1yqnj63zkx3qvd6jbaxsxjw68k7ppsjvnyks";

     

       235214
       235214
       +
              version = "0.1.3";

     

       235215
       235215
       +
              sha256 = "132yf6fp0hl6k3859sywkfzsca8xsaqd3a4ca4vdqqjrllk0m88i";

     

       235050
       235216
        
              isLibrary = true;

     

       235051
       235217
        
              isExecutable = true;

     

       235052
       235218
        
              libraryHaskellDepends = [

     
···

       235766
       235932
        
            }) {};

     

       235767
       235933
        
       

     

       235768
       235934
        
         "servant-swagger-ui" = callPackage

     

       235769
       235769
       -
           ({ mkDerivation, base, bytestring, file-embed-lzma, servant

     

       235770
       235770
       -
            , servant-server, servant-swagger-ui-core, swagger2, text

     

       235771
       235771
       -
            }:

     

       235772
       235772
       -
            mkDerivation {

     

       235773
       235773
       -
              pname = "servant-swagger-ui";

     

       235774
       235774
       -
              version = "0.3.4.3.37.2";

     

       235775
       235775
       -
              sha256 = "1kx8i2x3ffbwbjh2i2ljha2cl6vfj1fcad9wkmc9ll9mbj6cpl8v";

     

       235776
       235776
       -
              libraryHaskellDepends = [

     

       235777
       235777
       -
                base bytestring file-embed-lzma servant servant-server

     

       235778
       235778
       -
                servant-swagger-ui-core swagger2 text

     

       235779
       235779
       -
              ];

     

       235780
       235780
       -
              description = "Servant swagger ui";

     

       235781
       235781
       -
              license = lib.licenses.bsd3;

     

       235782
       235782
       -
            }) {};

     

       235783
       235783
       -
       

     

       235784
       235784
       -
         "servant-swagger-ui_0_3_5_3_47_1" = callPackage

     

       235785
       235935
        
           ({ mkDerivation, aeson, base, bytestring, file-embed-lzma, servant

     

       235786
       235936
        
            , servant-server, servant-swagger-ui-core, text

     

       235787
       235937
        
            }:

     
···

       235795
       235945
        
              ];

     

       235796
       235946
        
              description = "Servant swagger ui";

     

       235797
       235947
        
              license = lib.licenses.bsd3;

     

       235798
       235798
       -
              hydraPlatforms = lib.platforms.none;

     

       235799
       235948
        
            }) {};

     

       235800
       235949
        
       

     

       235801
       235950
        
         "servant-swagger-ui-core" = callPackage

     

       235802
       235802
       -
           ({ mkDerivation, base, blaze-markup, bytestring, http-media

     

       235803
       235803
       -
            , servant, servant-blaze, servant-server, swagger2, text

     

       235804
       235804
       -
            , transformers, transformers-compat, wai-app-static

     

       235805
       235805
       -
            }:

     

       235806
       235806
       -
            mkDerivation {

     

       235807
       235807
       -
              pname = "servant-swagger-ui-core";

     

       235808
       235808
       -
              version = "0.3.4";

     

       235809
       235809
       -
              sha256 = "05vi74kgsf3yhkbw9cjl1zxs5swhh9jib6bwqf1h11cg0nr5i8ab";

     

       235810
       235810
       -
              libraryHaskellDepends = [

     

       235811
       235811
       -
                base blaze-markup bytestring http-media servant servant-blaze

     

       235812
       235812
       -
                servant-server swagger2 text transformers transformers-compat

     

       235813
       235813
       -
                wai-app-static

     

       235814
       235814
       -
              ];

     

       235815
       235815
       -
              description = "Servant swagger ui core components";

     

       235816
       235816
       -
              license = lib.licenses.bsd3;

     

       235817
       235817
       -
            }) {};

     

       235818
       235818
       -
       

     

       235819
       235819
       -
         "servant-swagger-ui-core_0_3_5" = callPackage

     

       235820
       235951
        
           ({ mkDerivation, aeson, base, blaze-markup, bytestring, http-media

     

       235821
       235952
        
            , servant, servant-blaze, servant-server, text, transformers

     

       235822
       235953
        
            , transformers-compat, wai-app-static

     
···

       235831
       235962
        
              ];

     

       235832
       235963
        
              description = "Servant swagger ui core components";

     

       235833
       235964
        
              license = lib.licenses.bsd3;

     

       235834
       235834
       -
              hydraPlatforms = lib.platforms.none;

     

       235835
       235965
        
            }) {};

     

       235836
       235966
        
       

     

       235837
       235967
        
         "servant-swagger-ui-jensoleg" = callPackage

     
···

       244918
       245048
        
            }:

     

       244919
       245049
        
            mkDerivation {

     

       244920
       245050
        
              pname = "sourcemap";

     

       244921
       244921
       -
              version = "0.1.6";

     

       244922
       244922
       -
              sha256 = "0ynfm44ym8y592wnzdwa0d05dbkffyyg5sm26y5ylzpynk64r85r";

     

       244923
       244923
       -
              revision = "1";

     

       244924
       244924
       -
              editedCabalFile = "1f7q44ar6qfip8fsllg43jyn7r15ifn2r0vz32cbmx0sb0d38dax";

     

       245051
       245051
       +
              version = "0.1.6.1";

     

       245052
       245052
       +
              sha256 = "0kz8xpcd5syg5s4qa2qq8ylaxjhabj127w42may46vv6i0q1bf8a";

     

       244925
       245053
        
              libraryHaskellDepends = [

     

       244926
       245054
        
                aeson attoparsec base bytestring process text unordered-containers

     

       244927
       245055
        
                utf8-string

     
···

       245621
       245749
        
           ({ mkDerivation, base, cmdargs, containers, express, leancheck }:

     

       245622
       245750
        
            mkDerivation {

     

       245623
       245751
        
              pname = "speculate";

     

       245624
       245624
       -
              version = "0.4.4";

     

       245625
       245625
       -
              sha256 = "0vmxi8rapbld7b3llw2v6fz1v6vqyv90rpbnzjdfa29kdza4m5sf";

     

       245752
       245752
       +
              description = "Integration layer for \"json-pointer\" and \"aeson\"";

     

       245753
       245753
       +
              sha256 = "0vpc2vxfpziyz0hzapni4j31g1i12m2gnsrq72zf42qbhjwif57g";

     

       245626
       245754
        
              libraryHaskellDepends = [

     

       245627
       245755
        
                base cmdargs containers express leancheck

     

       245628
       245756
        
              ];

     
···

       246813
       246941
        
              license = lib.licenses.bsd3;

     

       246814
       246942
        
            }) {};

     

       246815
       246943
        
       

     

       246944
       246944
       +
         "srcloc_0_6" = callPackage

     

       246945
       246945
       +
           ({ mkDerivation, base }:

     

       246946
       246946
       +
            mkDerivation {

     

       246947
       246947
       +
              pname = "srcloc";

     

       246948
       246948
       +
              version = "0.6";

     

       246949
       246949
       +
              sha256 = "1vcp9vgfi5rscy09l4qaq0pp426b6qcdpzs6kpbzg0k5x81kcsbb";

     

       246950
       246950
       +
              libraryHaskellDepends = [ base ];

     

       246951
       246951
       +
              description = "Data types for managing source code locations";

     

       246952
       246952
       +
              license = lib.licenses.bsd3;

     

       246953
       246953
       +
              hydraPlatforms = lib.platforms.none;

     

       246954
       246954
       +
            }) {};

     

       246955
       246955
       +
       

     

       246816
       246956
        
         "srec" = callPackage

     

       246817
       246957
        
           ({ mkDerivation, base, bytestring }:

     

       246818
       246958
        
            mkDerivation {

     
···

       247287
       247427
        
            }:

     

       247288
       247428
        
            mkDerivation {

     

       247289
       247429
        
              pname = "stack-all";

     

       247290
       247290
       -
              version = "0.2";

     

       247291
       247291
       -
              sha256 = "0q64g4frvcmj308x27mibi89m6rwjf5v47ql4yy6cnf9arjzqf9f";

     

       247430
       247430
       +
              version = "0.2.1";

     

       247431
       247431
       +
              sha256 = "07azc2phnljxwxskxlipmx52vjyavxn54q87k1bakapla469fdr4";

     

       247292
       247432
        
              isLibrary = false;

     

       247293
       247433
        
              isExecutable = true;

     

       247294
       247434
        
              executableHaskellDepends = [

     
···

       249846
       249986
        
            }:

     

       249847
       249987
        
            mkDerivation {

     

       249848
       249988
        
              pname = "store";

     

       249849
       249849
       -
              version = "0.7.10";

     

       249850
       249850
       -
              sha256 = "0026bjff7nsw23i1l5427qnvw69ncbii5s2q1nshkrs1nrspb0i2";

     

       249851
       249851
       -
              libraryHaskellDepends = [

     

       249852
       249852
       -
                array async base base-orphans base64-bytestring bifunctors

     

       249853
       249853
       -
                bytestring containers contravariant cryptohash deepseq directory

     

       249854
       249854
       -
                filepath free ghc-prim hashable hspec hspec-smallcheck integer-gmp

     

       249855
       249855
       -
                lifted-base monad-control mono-traversable nats network primitive

     

       249856
       249856
       -
                resourcet safe smallcheck store-core syb template-haskell text

     

       249857
       249857
       -
                th-lift th-lift-instances th-orphans th-reify-many th-utilities

     

       249858
       249858
       -
                time transformers unordered-containers vector void

     

       249859
       249859
       -
              ];

     

       249860
       249860
       -
              testHaskellDepends = [

     

       249861
       249861
       -
                array async base base-orphans base64-bytestring bifunctors

     

       249862
       249862
       -
                bytestring clock containers contravariant cryptohash deepseq

     

       249863
       249863
       -
                directory filepath free ghc-prim hashable hspec hspec-smallcheck

     

       249864
       249864
       -
                integer-gmp lifted-base monad-control mono-traversable nats network

     

       249865
       249865
       -
                primitive resourcet safe smallcheck store-core syb template-haskell

     

       249866
       249866
       -
                text th-lift th-lift-instances th-orphans th-reify-many

     

       249867
       249867
       -
                th-utilities time transformers unordered-containers vector void

     

       249868
       249868
       -
              ];

     

       249869
       249869
       -
              benchmarkHaskellDepends = [

     

       249870
       249870
       -
                array async base base-orphans base64-bytestring bifunctors

     

       249871
       249871
       -
                bytestring cereal cereal-vector containers contravariant criterion

     

       249872
       249872
       -
                cryptohash deepseq directory filepath free ghc-prim hashable hspec

     

       249873
       249873
       -
                hspec-smallcheck integer-gmp lifted-base monad-control

     

       249874
       249874
       -
                mono-traversable nats network primitive resourcet safe smallcheck

     

       249875
       249875
       -
                store-core syb template-haskell text th-lift th-lift-instances

     

       249876
       249876
       -
                th-orphans th-reify-many th-utilities time transformers

     

       249877
       249877
       -
                unordered-containers vector vector-binary-instances void weigh

     

       249878
       249878
       -
              ];

     

       249879
       249879
       -
              description = "Fast binary serialization";

     

       249880
       249880
       -
              license = lib.licenses.mit;

     

       249881
       249881
       -
            }) {};

     

       249882
       249882
       -
       

     

       249883
       249883
       -
         "store_0_7_11" = callPackage

     

       249884
       249884
       -
           ({ mkDerivation, array, async, base, base-orphans

     

       249885
       249885
       -
            , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector

     

       249886
       249886
       -
            , clock, containers, contravariant, criterion, cryptohash, deepseq

     

       249887
       249887
       -
            , directory, filepath, free, ghc-prim, hashable, hspec

     

       249888
       249888
       -
            , hspec-smallcheck, integer-gmp, lifted-base, monad-control

     

       249889
       249889
       -
            , mono-traversable, nats, network, primitive, resourcet, safe

     

       249890
       249890
       -
            , smallcheck, store-core, syb, template-haskell, text, th-lift

     

       249891
       249891
       -
            , th-lift-instances, th-orphans, th-reify-many, th-utilities, time

     

       249892
       249892
       -
            , transformers, unordered-containers, vector

     

       249893
       249893
       -
            , vector-binary-instances, void, weigh

     

       249894
       249894
       -
            }:

     

       249895
       249895
       -
            mkDerivation {

     

       249896
       249896
       -
              pname = "store";

     

       249897
       249989
        
              version = "0.7.11";

     

       249898
       249990
        
              sha256 = "03i9gd18xqbfmj5kmiv4k4sw44gn6mn4faj71r2723abm3qwklwr";

     

       249899
       249991
        
              libraryHaskellDepends = [

     
···

       249926
       250018
        
              ];

     

       249927
       250019
        
              description = "Fast binary serialization";

     

       249928
       250020
        
              license = lib.licenses.mit;

     

       249929
       249929
       -
              hydraPlatforms = lib.platforms.none;

     

       249930
       250021
        
            }) {};

     

       249931
       250022
        
       

     

       249932
       250023
        
         "store-core" = callPackage

     
···

       252028
       252119
        
              ];

     

       252029
       252120
        
              description = "Strict GC'd imperative object-oriented programming with cheap pointers";

     

       252030
       252121
        
              license = lib.licenses.bsd3;

     

       252122
       252122
       +
            }) {};

     

       252123
       252123
       +
       

     

       252124
       252124
       +
         "structs_0_1_6" = callPackage

     

       252125
       252125
       +
           ({ mkDerivation, base, deepseq, ghc-prim, primitive, QuickCheck

     

       252126
       252126
       +
            , tasty, tasty-hunit, tasty-quickcheck, template-haskell

     

       252127
       252127
       +
            , th-abstraction

     

       252128
       252128
       +
            }:

     

       252129
       252129
       +
            mkDerivation {

     

       252130
       252130
       +
              pname = "structs";

     

       252131
       252131
       +
              version = "0.1.6";

     

       252132
       252132
       +
              sha256 = "0wzbhsvix46aans0hdm11pvsigk1lxpdaha2sxslx0ip1xsdg0gk";

     

       252133
       252133
       +
              libraryHaskellDepends = [

     

       252134
       252134
       +
                base deepseq ghc-prim primitive template-haskell th-abstraction

     

       252135
       252135
       +
              ];

     

       252136
       252136
       +
              testHaskellDepends = [

     

       252137
       252137
       +
                base primitive QuickCheck tasty tasty-hunit tasty-quickcheck

     

       252138
       252138
       +
              ];

     

       252139
       252139
       +
              description = "Strict GC'd imperative object-oriented programming with cheap pointers";

     

       252140
       252140
       +
              license = lib.licenses.bsd3;

     

       252141
       252141
       +
              hydraPlatforms = lib.platforms.none;

     

       252031
       252142
        
            }) {};

     

       252032
       252143
        
       

     

       252033
       252144
        
         "structural-induction" = callPackage

     
···

       261441
       261552
        
              pname = "th-abstraction";

     

       261442
       261553
        
              version = "0.4.2.0";

     

       261443
       261554
        
              sha256 = "0h0wl442a82llpjsxv45i7grgyanlzjj7k28mhnvbi2zlb6v41pa";

     

       261555
       261555
       +
              revision = "1";

     

       261556
       261556
       +
              editedCabalFile = "1yc17r29vkwi4qzbrxy1d3gra87hk3ghy1jzfmrl2q8zjc0v59vb";

     

       261444
       261557
        
              libraryHaskellDepends = [

     

       261445
       261558
        
                base containers ghc-prim template-haskell

     

       261446
       261559
        
              ];

     
···

       261820
       261933
        
              pname = "th-lift";

     

       261821
       261934
        
              version = "0.8.2";

     

       261822
       261935
        
              sha256 = "1r2wrnrn6qwy6ysyfnlqn6xbfckw0b22h8n00pk67bhhg81jfn9s";

     

       261936
       261936
       +
              revision = "1";

     

       261937
       261937
       +
              editedCabalFile = "1l8fsxbxfsgcy6qxlgn6qxwhiqwwmmaj2vb1gbrjyb905gb3lpwm";

     

       261823
       261938
        
              libraryHaskellDepends = [

     

       261824
       261939
        
                base ghc-prim template-haskell th-abstraction

     

       261825
       261940
        
              ];

     
···

       262980
       263095
        
            }:

     

       262981
       263096
        
            mkDerivation {

     

       262982
       263097
        
              pname = "tidal";

     

       262983
       262983
       -
              version = "1.7.3";

     

       262984
       262984
       -
              sha256 = "0z0brlicisn7xpwag20vdrq6ympczxcyd886pm6am5phmifkmfif";

     

       262985
       262985
       -
              enableSeparateDataOutput = true;

     

       262986
       262986
       -
              libraryHaskellDepends = [

     

       262987
       262987
       -
                base bifunctors bytestring clock colour containers deepseq hosc

     

       262988
       262988
       -
                network parsec primitive random text transformers

     

       262989
       262989
       -
              ];

     

       262990
       262990
       -
              testHaskellDepends = [

     

       262991
       262991
       -
                base containers deepseq hosc microspec parsec

     

       262992
       262992
       -
              ];

     

       262993
       262993
       -
              benchmarkHaskellDepends = [ base criterion weigh ];

     

       262994
       262994
       -
              description = "Pattern language for improvised music";

     

       262995
       262995
       -
              license = lib.licenses.gpl3Only;

     

       262996
       262996
       -
            }) {};

     

       262997
       262997
       -
       

     

       262998
       262998
       -
         "tidal_1_7_4" = callPackage

     

       262999
       262999
       -
           ({ mkDerivation, base, bifunctors, bytestring, clock, colour

     

       263000
       263000
       -
            , containers, criterion, deepseq, hosc, microspec, network, parsec

     

       263001
       263001
       -
            , primitive, random, text, transformers, weigh

     

       263002
       263002
       -
            }:

     

       263003
       263003
       -
            mkDerivation {

     

       263004
       263004
       -
              pname = "tidal";

     

       263005
       263098
        
              version = "1.7.4";

     

       263006
       263099
        
              sha256 = "080zncw6gp0dzwm9vd82c789v1x00nfzz8r1ldb4hl67v04jf8hi";

     

       263007
       263100
        
              enableSeparateDataOutput = true;

     
···

       263015
       263108
        
              benchmarkHaskellDepends = [ base criterion weigh ];

     

       263016
       263109
        
              description = "Pattern language for improvised music";

     

       263017
       263110
        
              license = lib.licenses.gpl3Only;

     

       263018
       263018
       -
              hydraPlatforms = lib.platforms.none;

     

       263019
       263111
        
            }) {};

     

       263020
       263112
        
       

     

       263021
       263113
        
         "tidal-midi" = callPackage

     
···

       263211
       263303
        
              broken = true;

     

       263212
       263304
        
            }) {};

     

       263213
       263305
        
       

     

       263214
       263214
       -
         "time_1_11_1_1" = callPackage

     

       263306
       263306
       +
         "time_1_11_1_2" = callPackage

     

       263215
       263307
        
           ({ mkDerivation, base, criterion, deepseq, QuickCheck, random

     

       263216
       263216
       -
            , tasty, tasty-hunit, tasty-quickcheck, unix

     

       263308
       263308
       +
            , tasty, tasty-hunit, tasty-quickcheck

     

       263217
       263309
        
            }:

     

       263218
       263310
        
            mkDerivation {

     

       263219
       263311
        
              pname = "time";

     

       263220
       263220
       -
              version = "1.11.1.1";

     

       263221
       263221
       -
              sha256 = "0xrs9j4fskxz98zgwhgh7w4d9a6im3ipahg6ahp0689qhs61cx9p";

     

       263312
       263312
       +
              version = "1.11.1.2";

     

       263313
       263313
       +
              sha256 = "0r33rxxrrpyzxpdihky93adlpdj0r8k6wh2i1sx0nb7zhvfnfj27";

     

       263222
       263314
        
              libraryHaskellDepends = [ base deepseq ];

     

       263223
       263315
        
              testHaskellDepends = [

     

       263224
       263316
        
                base deepseq QuickCheck random tasty tasty-hunit tasty-quickcheck

     

       263225
       263225
       -
                unix

     

       263226
       263317
        
              ];

     

       263227
       263318
        
              benchmarkHaskellDepends = [ base criterion deepseq ];

     

       263228
       263319
        
              description = "A time library";

     

       263229
       263229
       -
              license = lib.licenses.bsd3;

     

       263320
       263320
       +
              license = lib.licenses.bsd2;

     

       263230
       263321
        
              hydraPlatforms = lib.platforms.none;

     

       263231
       263322
        
            }) {};

     

       263232
       263323
        
       

     
···

       271836
       271927
        
            }) {};

     

       271837
       271928
        
       

     

       271838
       271929
        
         "unicode-collation" = callPackage

     

       271839
       271839
       -
           ({ mkDerivation, base, binary, bytestring, bytestring-lexing

     

       271840
       271840
       -
            , containers, filepath, parsec, QuickCheck, quickcheck-instances

     

       271841
       271841
       -
            , tasty, tasty-bench, tasty-hunit, template-haskell, text, text-icu

     

       271930
       271930
       +
           ({ mkDerivation, base, binary, bytestring, containers, parsec

     

       271931
       271931
       +
            , QuickCheck, quickcheck-instances, tasty, tasty-bench, tasty-hunit

     

       271932
       271932
       +
            , tasty-quickcheck, template-haskell, text, text-icu

     

       271842
       271933
        
            , th-lift-instances, unicode-transforms

     

       271843
       271934
        
            }:

     

       271844
       271935
        
            mkDerivation {

     

       271845
       271936
        
              pname = "unicode-collation";

     

       271846
       271846
       -
              version = "0.1.2";

     

       271847
       271847
       -
              sha256 = "1q77rd3d2c1r5d35f0z1mhismc3rf8bg1dwfg32wvdd9hpszc52v";

     

       271937
       271937
       +
              version = "0.1.3";

     

       271938
       271938
       +
              sha256 = "0nbxkpd29ivdi6vcikbaasffkcz9m2vd4nhv29p6gmvckzmhj7zi";

     

       271848
       271939
        
              isLibrary = true;

     

       271849
       271940
        
              isExecutable = true;

     

       271850
       271941
        
              libraryHaskellDepends = [

     

       271851
       271851
       -
                base binary bytestring bytestring-lexing containers filepath parsec

     

       271852
       271852
       -
                template-haskell text th-lift-instances unicode-transforms

     

       271942
       271942
       +
                base binary bytestring containers parsec template-haskell text

     

       271943
       271943
       +
                th-lift-instances

     

       271944
       271944
       +
              ];

     

       271945
       271945
       +
              testHaskellDepends = [

     

       271946
       271946
       +
                base bytestring tasty tasty-hunit tasty-quickcheck text

     

       271947
       271947
       +
                unicode-transforms

     

       271853
       271948
        
              ];

     

       271854
       271854
       -
              testHaskellDepends = [ base bytestring tasty tasty-hunit text ];

     

       271855
       271949
        
              benchmarkHaskellDepends = [

     

       271856
       271950
        
                base QuickCheck quickcheck-instances tasty-bench text text-icu

     

       271857
       271951
        
              ];

     
···

       275788
       275882
        
              broken = true;

     

       275789
       275883
        
            }) {};

     

       275790
       275884
        
       

     

       275885
       275885
       +
         "variadic" = callPackage

     

       275886
       275886
       +
           ({ mkDerivation, base, containers, criterion, hspec

     

       275887
       275887
       +
            , hspec-expectations-lifted, mmorph, mtl, process

     

       275888
       275888
       +
            }:

     

       275889
       275889
       +
            mkDerivation {

     

       275890
       275890
       +
              pname = "variadic";

     

       275891
       275891
       +
              version = "0.0.0.0";

     

       275892
       275892
       +
              sha256 = "1wlf8bxxmal6zmjhdw6ghvcdxi2lvlhs2vn7c7sn0jb88im0i18s";

     

       275893
       275893
       +
              libraryHaskellDepends = [ base mmorph mtl ];

     

       275894
       275894
       +
              testHaskellDepends = [

     

       275895
       275895
       +
                base containers hspec hspec-expectations-lifted mmorph mtl process

     

       275896
       275896
       +
              ];

     

       275897
       275897
       +
              benchmarkHaskellDepends = [ base criterion mmorph mtl ];

     

       275898
       275898
       +
              description = "Abstractions for working with variadic functions";

     

       275899
       275899
       +
              license = lib.licenses.bsd3;

     

       275900
       275900
       +
            }) {};

     

       275901
       275901
       +
       

     

       275791
       275902
        
         "variation" = callPackage

     

       275792
       275903
        
           ({ mkDerivation, base, cereal, containers, deepseq, semigroupoids

     

       275793
       275904
        
            }:

     
···

       276439
       276550
        
              ];

     

       276440
       276551
        
              description = "A binding to the fftw library for one-dimensional vectors";

     

       276441
       276552
        
              license = lib.licenses.bsd3;

     

       276553
       276553
       +
              hydraPlatforms = lib.platforms.none;

     

       276554
       276554
       +
              broken = true;

     

       276442
       276555
        
            }) {inherit (pkgs) fftw;};

     

       276443
       276556
        
       

     

       276444
       276557
        
         "vector-functorlazy" = callPackage

     
···

       277937
       278050
        
              broken = true;

     

       277938
       278051
        
            }) {};

     

       277939
       278052
        
       

     

       278053
       278053
       +
         "vp-tree" = callPackage

     

       278054
       278054
       +
           ({ mkDerivation, base, boxes, bytestring, conduit, containers

     

       278055
       278055
       +
            , deepseq, depq, hspec, mtl, mwc-probability, primitive, psqueues

     

       278056
       278056
       +
            , QuickCheck, sampling, serialise, transformers, vector

     

       278057
       278057
       +
            , vector-algorithms, weigh

     

       278058
       278058
       +
            }:

     

       278059
       278059
       +
            mkDerivation {

     

       278060
       278060
       +
              pname = "vp-tree";

     

       278061
       278061
       +
              version = "0.1.0.1";

     

       278062
       278062
       +
              sha256 = "1hzzz5ld397ig0lskr09sdz2cdd4nkk6pckhb9r04vzmqczpiarp";

     

       278063
       278063
       +
              libraryHaskellDepends = [

     

       278064
       278064
       +
                base boxes containers deepseq depq mtl mwc-probability primitive

     

       278065
       278065
       +
                psqueues sampling serialise transformers vector vector-algorithms

     

       278066
       278066
       +
              ];

     

       278067
       278067
       +
              testHaskellDepends = [

     

       278068
       278068
       +
                base hspec mwc-probability primitive QuickCheck vector

     

       278069
       278069
       +
              ];

     

       278070
       278070
       +
              benchmarkHaskellDepends = [

     

       278071
       278071
       +
                base bytestring conduit containers deepseq vector weigh

     

       278072
       278072
       +
              ];

     

       278073
       278073
       +
              description = "Vantage Point Trees";

     

       278074
       278074
       +
              license = lib.licenses.bsd3;

     

       278075
       278075
       +
            }) {};

     

       278076
       278076
       +
       

     

       277940
       278077
        
         "vpq" = callPackage

     

       277941
       278078
        
           ({ mkDerivation, base, primitive, smallcheck, tasty

     

       277942
       278079
        
            , tasty-smallcheck, util, vector

     
···

       280037
       280174
        
              ];

     

       280038
       280175
        
              description = "Simple Redis backed wai-session backend";

     

       280039
       280176
        
              license = lib.licenses.bsd3;

     

       280177
       280177
       +
              hydraPlatforms = lib.platforms.none;

     

       280178
       280178
       +
              broken = true;

     

       280040
       280179
        
            }) {};

     

       280041
       280180
        
       

     

       280042
       280181
        
         "wai-session-tokyocabinet" = callPackage

     
···

       280373
       280512
        
            }:

     

       280374
       280513
        
            mkDerivation {

     

       280375
       280514
        
              pname = "warp";

     

       280376
       280376
       -
              version = "3.3.14";

     

       280377
       280377
       -
              sha256 = "0whmh6dbl7321a2kg6ypngw5kgvvxqdk161li0l4hr3wqqddlc93";

     

       280378
       280378
       -
              libraryHaskellDepends = [

     

       280379
       280379
       -
                array async auto-update base bsb-http-chunked bytestring

     

       280380
       280380
       -
                case-insensitive containers ghc-prim hashable http-date http-types

     

       280381
       280381
       -
                http2 iproute network simple-sendfile stm streaming-commons text

     

       280382
       280382
       -
                time-manager unix unix-compat vault wai word8 x509

     

       280383
       280383
       -
              ];

     

       280384
       280384
       -
              testHaskellDepends = [

     

       280385
       280385
       -
                array async auto-update base bsb-http-chunked bytestring

     

       280386
       280386
       -
                case-insensitive containers directory ghc-prim hashable hspec

     

       280387
       280387
       -
                http-client http-date http-types http2 HUnit iproute lifted-base

     

       280388
       280388
       -
                network process QuickCheck simple-sendfile stm streaming-commons

     

       280389
       280389
       -
                text time time-manager unix unix-compat vault wai word8 x509

     

       280390
       280390
       -
              ];

     

       280391
       280391
       -
              benchmarkHaskellDepends = [

     

       280392
       280392
       -
                auto-update base bytestring containers gauge hashable http-date

     

       280393
       280393
       -
                http-types network time-manager unix unix-compat x509

     

       280394
       280394
       -
              ];

     

       280395
       280395
       -
              description = "A fast, light-weight web server for WAI applications";

     

       280396
       280396
       -
              license = lib.licenses.mit;

     

       280397
       280397
       -
            }) {};

     

       280398
       280398
       -
       

     

       280399
       280399
       -
         "warp_3_3_15" = callPackage

     

       280400
       280400
       -
           ({ mkDerivation, array, async, auto-update, base, bsb-http-chunked

     

       280401
       280401
       -
            , bytestring, case-insensitive, containers, directory, gauge

     

       280402
       280402
       -
            , ghc-prim, hashable, hspec, http-client, http-date, http-types

     

       280403
       280403
       -
            , http2, HUnit, iproute, lifted-base, network, process, QuickCheck

     

       280404
       280404
       -
            , simple-sendfile, stm, streaming-commons, text, time, time-manager

     

       280405
       280405
       -
            , unix, unix-compat, vault, wai, word8, x509

     

       280406
       280406
       -
            }:

     

       280407
       280407
       -
            mkDerivation {

     

       280408
       280408
       -
              pname = "warp";

     

       280409
       280515
        
              version = "3.3.15";

     

       280410
       280516
        
              sha256 = "0nj4xxzjcy33hyfdagpc2ij6ga71r1fmc248rjgwsyfflial63bz";

     

       280411
       280517
        
              libraryHaskellDepends = [

     
···

       280427
       280533
        
              ];

     

       280428
       280534
        
              description = "A fast, light-weight web server for WAI applications";

     

       280429
       280535
        
              license = lib.licenses.mit;

     

       280430
       280430
       -
              hydraPlatforms = lib.platforms.none;

     

       280431
       280536
        
            }) {};

     

       280432
       280537
        
       

     

       280433
       280538
        
         "warp-dynamic" = callPackage

     
···

       280463
       280568
        
              ];

     

       280464
       280569
        
              description = "A minimal gRPC server on top of Warp";

     

       280465
       280570
        
              license = lib.licenses.bsd3;

     

       280571
       280571
       +
              hydraPlatforms = lib.platforms.none;

     

       280572
       280572
       +
              broken = true;

     

       280466
       280573
        
            }) {};

     

       280467
       280574
        
       

     

       280468
       280575
        
         "warp-static" = callPackage

     
···

       282878
       282985
        
            }) {};

     

       282879
       282986
        
       

     

       282880
       282987
        
         "witch" = callPackage

     

       282881
       282881
       -
           ({ mkDerivation, base, bytestring, containers, hspec, QuickCheck

     

       282882
       282882
       -
            , text

     

       282988
       282988
       +
           ({ mkDerivation, base, bytestring, containers, hspec

     

       282989
       282989
       +
            , template-haskell, text

     

       282883
       282990
        
            }:

     

       282884
       282991
        
            mkDerivation {

     

       282885
       282992
        
              pname = "witch";

     

       282886
       282886
       -
              version = "0.0.0.5";

     

       282887
       282887
       -
              sha256 = "1j12mh8zap8c0lb358bzk4sq29h64lv0jrwq9r4nssx4yybrz9gg";

     

       282888
       282888
       -
              libraryHaskellDepends = [ base bytestring containers text ];

     

       282889
       282889
       -
              testHaskellDepends = [

     

       282890
       282890
       -
                base bytestring containers hspec QuickCheck text

     

       282993
       282993
       +
              version = "0.2.0.2";

     

       282994
       282994
       +
              sha256 = "13y5zbs9lwniamwq2cm45rsc7xp11ny2m7x3f965qd6az66ds396";

     

       282995
       282995
       +
              libraryHaskellDepends = [

     

       282996
       282996
       +
                base bytestring containers template-haskell text

     

       282891
       282997
        
              ];

     

       282998
       282998
       +
              testHaskellDepends = [ base bytestring containers hspec text ];

     

       282892
       282999
        
              description = "Convert values from one type into another";

     

       282893
       283000
        
              license = lib.licenses.isc;

     

       282894
       283001
        
            }) {};

     

       282895
       283002
        
       

     

       282896
       282896
       -
         "witch_0_2_0_0" = callPackage

     

       282897
       282897
       -
           ({ mkDerivation, base, bytestring, containers, hspec

     

       283003
       283003
       +
         "witch_0_2_1_0" = callPackage

     

       283004
       283004
       +
           ({ mkDerivation, base, bytestring, containers, hspec, QuickCheck

     

       282898
       283005
        
            , template-haskell, text

     

       282899
       283006
        
            }:

     

       282900
       283007
        
            mkDerivation {

     

       282901
       283008
        
              pname = "witch";

     

       282902
       282902
       -
              version = "0.2.0.0";

     

       282903
       282903
       -
              sha256 = "03rnpljng4vy913zm3cxnhlq3i8d5p57661wa1cwj46hkhy7rhj7";

     

       283009
       283009
       +
              version = "0.2.1.0";

     

       283010
       283010
       +
              sha256 = "0zvq9axjmqksk4fqq42qgbj4whx27p4m40cgvdqmq4vpj4csvswl";

     

       282904
       283011
        
              libraryHaskellDepends = [

     

       282905
       283012
        
                base bytestring containers template-haskell text

     

       282906
       283013
        
              ];

     

       282907
       282907
       -
              testHaskellDepends = [ base bytestring containers hspec text ];

     

       283014
       283014
       +
              testHaskellDepends = [

     

       283015
       283015
       +
                base bytestring containers hspec QuickCheck text

     

       283016
       283016
       +
              ];

     

       282908
       283017
        
              description = "Convert values from one type into another";

     

       282909
       283018
        
              license = lib.licenses.isc;

     

       282910
       283019
        
              hydraPlatforms = lib.platforms.none;

     
···

       285686
       285795
        
            }:

     

       285687
       285796
        
            mkDerivation {

     

       285688
       285797
        
              pname = "xml-conduit";

     

       285689
       285689
       -
              version = "1.9.1.0";

     

       285690
       285690
       -
              sha256 = "0ag0g9x5qnw1nfgc31h6bj2qv0h1c2y7n1l0g99l4dkn428dk9ca";

     

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

     

       285692
       285692
       -
              libraryHaskellDepends = [

     

       285693
       285693
       -
                attoparsec base blaze-html blaze-markup bytestring conduit

     

       285694
       285694
       -
                conduit-extra containers data-default-class deepseq resourcet text

     

       285695
       285695
       -
                transformers xml-types

     

       285696
       285696
       -
              ];

     

       285697
       285697
       -
              testHaskellDepends = [

     

       285698
       285698
       -
                base blaze-markup bytestring conduit containers doctest hspec HUnit

     

       285699
       285699
       -
                resourcet text transformers xml-types

     

       285700
       285700
       -
              ];

     

       285701
       285701
       -
              description = "Pure-Haskell utilities for dealing with XML with the conduit package";

     

       285702
       285702
       -
              license = lib.licenses.mit;

     

       285703
       285703
       -
            }) {};

     

       285704
       285704
       -
       

     

       285705
       285705
       -
         "xml-conduit_1_9_1_1" = callPackage

     

       285706
       285706
       -
           ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup

     

       285707
       285707
       -
            , bytestring, Cabal, cabal-doctest, conduit, conduit-extra

     

       285708
       285708
       -
            , containers, data-default-class, deepseq, doctest, hspec, HUnit

     

       285709
       285709
       -
            , resourcet, text, transformers, xml-types

     

       285710
       285710
       -
            }:

     

       285711
       285711
       -
            mkDerivation {

     

       285712
       285712
       -
              pname = "xml-conduit";

     

       285713
       285798
        
              version = "1.9.1.1";

     

       285714
       285799
        
              sha256 = "1zzh7xnmbm68dab1vqsjkr6ghxqgnla5nik4amrwlmhbdih1gcdx";

     

       285715
       285800
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       285724
       285809
        
              ];

     

       285725
       285810
        
              description = "Pure-Haskell utilities for dealing with XML with the conduit package";

     

       285726
       285811
        
              license = lib.licenses.mit;

     

       285727
       285727
       -
              hydraPlatforms = lib.platforms.none;

     

       285728
       285812
        
            }) {};

     

       285729
       285813
        
       

     

       285730
       285814
        
         "xml-conduit-decode" = callPackage

     
···

       288592
       288676
        
            }:

     

       288593
       288677
        
            mkDerivation {

     

       288594
       288678
        
              pname = "yesod";

     

       288595
       288595
       -
              version = "1.6.1.0";

     

       288596
       288596
       -
              sha256 = "1jk55fm58ywp69khacw8n3qk2aybsrlh4bkinjgrah3w01kflmyw";

     

       288597
       288597
       -
              libraryHaskellDepends = [

     

       288598
       288598
       -
                aeson base bytestring conduit data-default-class directory

     

       288599
       288599
       -
                fast-logger file-embed monad-logger shakespeare streaming-commons

     

       288600
       288600
       -
                template-haskell text unix unordered-containers wai wai-extra

     

       288601
       288601
       -
                wai-logger warp yaml yesod-core yesod-form yesod-persistent

     

       288602
       288602
       -
              ];

     

       288603
       288603
       -
              description = "Creation of type-safe, RESTful web applications";

     

       288604
       288604
       -
              license = lib.licenses.mit;

     

       288605
       288605
       -
            }) {};

     

       288606
       288606
       -
       

     

       288607
       288607
       -
         "yesod_1_6_1_1" = callPackage

     

       288608
       288608
       -
           ({ mkDerivation, aeson, base, bytestring, conduit

     

       288609
       288609
       -
            , data-default-class, directory, fast-logger, file-embed

     

       288610
       288610
       -
            , monad-logger, shakespeare, streaming-commons, template-haskell

     

       288611
       288611
       -
            , text, unix, unordered-containers, wai, wai-extra, wai-logger

     

       288612
       288612
       -
            , warp, yaml, yesod-core, yesod-form, yesod-persistent

     

       288613
       288613
       -
            }:

     

       288614
       288614
       -
            mkDerivation {

     

       288615
       288615
       -
              pname = "yesod";

     

       288616
       288679
        
              version = "1.6.1.1";

     

       288617
       288680
        
              sha256 = "1iiaixd1xrqjcvknl9g3yvr26nbpfa2amh2ayfxmnpjlxvdhfnyn";

     

       288618
       288681
        
              libraryHaskellDepends = [

     
···

       288623
       288686
        
              ];

     

       288624
       288687
        
              description = "Creation of type-safe, RESTful web applications";

     

       288625
       288688
        
              license = lib.licenses.mit;

     

       288626
       288626
       -
              hydraPlatforms = lib.platforms.none;

     

       288627
       288689
        
            }) {};

     

       288628
       288690
        
       

     

       288629
       288691
        
         "yesod-alerts" = callPackage

     
···

       288717
       288779
        
            }:

     

       288718
       288780
        
            mkDerivation {

     

       288719
       288781
        
              pname = "yesod-auth";

     

       288720
       288720
       -
              version = "1.6.10.2";

     

       288721
       288721
       -
              sha256 = "16c4rddfmpw1smk7zayflwp1xy3avrqcr0cv6qx4aq949zpn6lz8";

     

       288722
       288722
       -
              libraryHaskellDepends = [

     

       288723
       288723
       -
                aeson authenticate base base16-bytestring base64-bytestring binary

     

       288724
       288724
       -
                blaze-builder blaze-html blaze-markup bytestring conduit

     

       288725
       288725
       -
                conduit-extra containers cryptonite data-default email-validate

     

       288726
       288726
       -
                file-embed http-client http-client-tls http-conduit http-types

     

       288727
       288727
       -
                memory network-uri nonce persistent random safe shakespeare

     

       288728
       288728
       -
                template-haskell text time transformers unliftio unliftio-core

     

       288729
       288729
       -
                unordered-containers wai yesod-core yesod-form yesod-persistent

     

       288730
       288730
       -
              ];

     

       288731
       288731
       -
              description = "Authentication for Yesod";

     

       288732
       288732
       -
              license = lib.licenses.mit;

     

       288733
       288733
       -
            }) {};

     

       288734
       288734
       -
       

     

       288735
       288735
       -
         "yesod-auth_1_6_10_3" = callPackage

     

       288736
       288736
       -
           ({ mkDerivation, aeson, authenticate, base, base16-bytestring

     

       288737
       288737
       -
            , base64-bytestring, binary, blaze-builder, blaze-html

     

       288738
       288738
       -
            , blaze-markup, bytestring, conduit, conduit-extra, containers

     

       288739
       288739
       -
            , cryptonite, data-default, email-validate, file-embed, http-client

     

       288740
       288740
       -
            , http-client-tls, http-conduit, http-types, memory, network-uri

     

       288741
       288741
       -
            , nonce, persistent, random, safe, shakespeare, template-haskell

     

       288742
       288742
       -
            , text, time, transformers, unliftio, unliftio-core

     

       288743
       288743
       -
            , unordered-containers, wai, yesod-core, yesod-form

     

       288744
       288744
       -
            , yesod-persistent

     

       288745
       288745
       -
            }:

     

       288746
       288746
       -
            mkDerivation {

     

       288747
       288747
       -
              pname = "yesod-auth";

     

       288748
       288782
        
              version = "1.6.10.3";

     

       288749
       288783
        
              sha256 = "00a7gbp2czg6ixxx62k2nmrj5g1la6cjh697y8vg9xhxq7vpyshg";

     

       288750
       288784
        
              libraryHaskellDepends = [

     
···

       288758
       288792
        
              ];

     

       288759
       288793
        
              description = "Authentication for Yesod";

     

       288760
       288794
        
              license = lib.licenses.mit;

     

       288761
       288761
       -
              hydraPlatforms = lib.platforms.none;

     

       288762
       288795
        
            }) {};

     

       288763
       288796
        
       

     

       288764
       288797
        
         "yesod-auth-account" = callPackage

     
···

       288913
       288946
        
            }:

     

       288914
       288947
        
            mkDerivation {

     

       288915
       288948
        
              pname = "yesod-auth-hashdb";

     

       288916
       288916
       -
              version = "1.7.1.5";

     

       288917
       288917
       -
              sha256 = "14isl9mwxarba14aqhidi82yci36jdws6af2jirv7z8mfnrwysbi";

     

       288918
       288918
       -
              libraryHaskellDepends = [

     

       288919
       288919
       -
                aeson base bytestring persistent text yesod-auth yesod-core

     

       288920
       288920
       -
                yesod-form yesod-persistent

     

       288921
       288921
       -
              ];

     

       288922
       288922
       -
              testHaskellDepends = [

     

       288923
       288923
       -
                aeson base basic-prelude bytestring containers hspec http-conduit

     

       288924
       288924
       -
                http-types monad-logger network-uri persistent-sqlite resourcet

     

       288925
       288925
       -
                text unordered-containers wai-extra yesod yesod-auth yesod-core

     

       288926
       288926
       -
                yesod-test

     

       288927
       288927
       -
              ];

     

       288928
       288928
       -
              description = "Authentication plugin for Yesod";

     

       288929
       288929
       -
              license = lib.licenses.mit;

     

       288930
       288930
       -
            }) {};

     

       288931
       288931
       -
       

     

       288932
       288932
       -
         "yesod-auth-hashdb_1_7_1_6" = callPackage

     

       288933
       288933
       -
           ({ mkDerivation, aeson, base, basic-prelude, bytestring, containers

     

       288934
       288934
       -
            , hspec, http-conduit, http-types, monad-logger, network-uri

     

       288935
       288935
       -
            , persistent, persistent-sqlite, resourcet, text

     

       288936
       288936
       -
            , unordered-containers, wai-extra, yesod, yesod-auth, yesod-core

     

       288937
       288937
       -
            , yesod-form, yesod-persistent, yesod-test

     

       288938
       288938
       -
            }:

     

       288939
       288939
       -
            mkDerivation {

     

       288940
       288940
       -
              pname = "yesod-auth-hashdb";

     

       288941
       288949
        
              version = "1.7.1.6";

     

       288942
       288950
        
              sha256 = "062f2fv4ixr5bd5xcs208xfg2i18z25g3imf86qrziv0yxxg5qpc";

     

       288943
       288951
        
              libraryHaskellDepends = [

     
···

       288952
       288960
        
              ];

     

       288953
       288961
        
              description = "Authentication plugin for Yesod";

     

       288954
       288962
        
              license = lib.licenses.mit;

     

       288955
       288955
       -
              hydraPlatforms = lib.platforms.none;

     

       288956
       288963
        
            }) {};

     

       288957
       288964
        
       

     

       288958
       288965
        
         "yesod-auth-hmac-keccak" = callPackage

     
···

       289916
       289923
        
            }) {};

     

       289917
       289924
        
       

     

       289918
       289925
        
         "yesod-markdown" = callPackage

     

       289919
       289919
       -
           ({ mkDerivation, base, blaze-html, blaze-markup, bytestring

     

       289920
       289920
       -
            , directory, hspec, pandoc, persistent, shakespeare, text

     

       289921
       289921
       -
            , xss-sanitize, yesod-core, yesod-form

     

       289922
       289922
       -
            }:

     

       289923
       289923
       -
            mkDerivation {

     

       289924
       289924
       -
              pname = "yesod-markdown";

     

       289925
       289925
       -
              version = "0.12.6.8";

     

       289926
       289926
       -
              sha256 = "1jlnci0wkfg04qvad7qx19321s8jf2rskjghirwcqy1abg3bf96p";

     

       289927
       289927
       -
              libraryHaskellDepends = [

     

       289928
       289928
       -
                base blaze-html blaze-markup bytestring directory pandoc persistent

     

       289929
       289929
       -
                shakespeare text xss-sanitize yesod-core yesod-form

     

       289930
       289930
       -
              ];

     

       289931
       289931
       -
              testHaskellDepends = [ base blaze-html hspec text ];

     

       289932
       289932
       -
              description = "Tools for using markdown in a yesod application";

     

       289933
       289933
       -
              license = lib.licenses.gpl2Only;

     

       289934
       289934
       -
              hydraPlatforms = lib.platforms.none;

     

       289935
       289935
       -
              broken = true;

     

       289936
       289936
       -
            }) {};

     

       289937
       289937
       -
       

     

       289938
       289938
       -
         "yesod-markdown_0_12_6_9" = callPackage

     

       289939
       289926
        
           ({ mkDerivation, base, blaze-html, blaze-markup, bytestring

     

       289940
       289927
        
            , directory, hspec, pandoc, persistent, shakespeare, text

     

       289941
       289928
        
            , xss-sanitize, yesod-core, yesod-form

     
···

       293089
       293076
        
           ({ mkDerivation, base, hspec, Z-Data, Z-IO, zookeeper_mt }:

     

       293090
       293077
        
            mkDerivation {

     

       293091
       293078
        
              pname = "zoovisitor";

     

       293092
       293092
       -
              version = "0.1.1.0";

     

       293093
       293093
       -
              sha256 = "16y2j12zl8arwv2m0crllrrf09l4ar1s2v9wrfzjmxnk80vhncf1";

     

       293079
       293079
       +
              version = "0.1.1.1";

     

       293080
       293080
       +
              sha256 = "1mg3wz3drddxdrbr1b0yw5wayzqi99zfdlgiwvgcc5pxb98i6wk3";

     

       293094
       293081
        
              libraryHaskellDepends = [ base Z-Data Z-IO ];

     

       293095
       293082
        
              librarySystemDepends = [ zookeeper_mt ];

     

       293096
       293083
        
              testHaskellDepends = [ base hspec ];

+13 -6

pkgs/development/libraries/arrow-cpp/default.nix

···

       1
       1
       -
       { stdenv, lib, fetchurl, fetchFromGitHub, fetchpatch, fixDarwinDylibNames

     

       1
       1
       +
       { stdenv, lib, fetchurl, fetchFromGitHub, fixDarwinDylibNames

     

       2
       2
        
       , autoconf, boost, brotli, cmake, flatbuffers, gflags, glog, gtest, lz4

     

       3
       3
       -
       , perl, python3, rapidjson, re2, snappy, thrift, utf8proc, which, zlib, zstd

     

       3
       3
       +
       , perl, python3, rapidjson, re2, snappy, thrift, utf8proc, which, xsimd

     

       4
       4
       +
       , zlib, zstd

     

       4
       5
        
       , enableShared ? !stdenv.hostPlatform.isStatic

     

       5
       6
        
       }:

     

       6
       7
        
       

     
···

       15
       16
        
         parquet-testing = fetchFromGitHub {

     

       16
       17
        
           owner = "apache";

     

       17
       18
        
           repo = "parquet-testing";

     

       18
       18
       -
           rev = "e31fe1a02c9e9f271e4bfb8002d403c52f1ef8eb";

     

       19
       19
       -
           sha256 = "02f51dvx8w5mw0bx3hn70hkn55mn1m65kzdps1ifvga9hghpy0sh";

     

       19
       19
       +
           rev = "ddd898958803cb89b7156c6350584d1cda0fe8de";

     

       20
       20
       +
           sha256 = "0n16xqlpxn2ryp43w8pppxrbwmllx6sk4hv3ycgikfj57nd3ibc0";

     

       20
       21
        
         };

     

       21
       22
        
       

     

       22
       23
        
       in stdenv.mkDerivation rec {

     

       23
       24
        
         pname = "arrow-cpp";

     

       24
       24
       -
         version = "3.0.0";

     

       25
       25
       +
         version = "4.0.0";

     

       25
       26
        
       

     

       26
       27
        
         src = fetchurl {

     

       27
       28
        
           url =

     

       28
       29
        
             "mirror://apache/arrow/arrow-${version}/apache-arrow-${version}.tar.gz";

     

       29
       29
       -
           sha256 = "0yp2b02wrc3s50zd56fmpz4nhhbihp0zw329v4zizaipwlxwrhkk";

     

       30
       30
       +
           sha256 = "1bj9jr0pgq9f2nyzqiyj3cl0hcx3c83z2ym6rpdkp59ff2zx0caa";

     

       30
       31
        
         };

     

       31
       32
        
         sourceRoot = "apache-arrow-${version}/cpp";

     

       32
       33
        
       

     
···

       90
       91
        
           "-DARROW_VERBOSE_THIRDPARTY_BUILD=ON"

     

       91
       92
        
           "-DARROW_DEPENDENCY_SOURCE=SYSTEM"

     

       92
       93
        
           "-DARROW_DEPENDENCY_USE_SHARED=${if enableShared then "ON" else "OFF"}"

     

       94
       94
       +
           "-DARROW_COMPUTE=ON"

     

       95
       95
       +
           "-DARROW_CSV=ON"

     

       96
       96
       +
           "-DARROW_DATASET=ON"

     

       97
       97
       +
           "-DARROW_JSON=ON"

     

       93
       98
        
           "-DARROW_PLASMA=ON"

     

       94
       99
        
           # Disable Python for static mode because openblas is currently broken there.

     

       95
       100
        
           "-DARROW_PYTHON=${if enableShared then "ON" else "OFF"}"

     
···

       110
       115
        
           "-DCMAKE_SKIP_BUILD_RPATH=OFF" # needed for tests

     

       111
       116
        
           "-DCMAKE_INSTALL_RPATH=@loader_path/../lib" # needed for tools executables

     

       112
       117
        
         ] ++ lib.optional (!stdenv.isx86_64) "-DARROW_USE_SIMD=OFF";

     

       118
       118
       +
       

     

       119
       119
       +
         ARROW_XSIMD_URL = xsimd.src;

     

       113
       120
        
       

     

       114
       121
        
         doInstallCheck = true;

     

       115
       122
        
         ARROW_TEST_DATA =

+27 -18

pkgs/development/libraries/wxSVG/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl

     

       2
       2
       -
       , pkg-config, wxGTK

     

       3
       3
       -
       , ffmpeg_3, libexif

     

       4
       4
       -
       , cairo, pango }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , cairo

     

       5
       5
       +
       , ffmpeg

     

       6
       6
       +
       , libexif

     

       7
       7
       +
       , pango

     

       8
       8
       +
       , pkg-config

     

       9
       9
       +
       , wxGTK

     

       10
       10
       +
       }:

     

       5
       11
        
       

     

       6
       12
        
       stdenv.mkDerivation rec {

     

       7
       7
       -
       

     

       8
       13
        
         pname = "wxSVG";

     

       9
       9
       -
         srcName = "wxsvg-${version}";

     

       10
       14
        
         version = "1.5.22";

     

       11
       15
        
       

     

       12
       16
        
         src = fetchurl {

     

       13
       13
       -
           url = "mirror://sourceforge/project/wxsvg/wxsvg/${version}/${srcName}.tar.bz2";

     

       14
       14
       -
           sha256 = "0agmmwg0zlsw1idygvqjpj1nk41akzlbdha0hsdk1k8ckz6niq8d";

     

       17
       17
       +
           url = "mirror://sourceforge/project/wxsvg/wxsvg/${version}/wxsvg-${version}.tar.bz2";

     

       18
       18
       +
           hash = "sha256-DeFozZ8MzTCbhkDBtuifKpBpg7wS7+dbDFzTDx6v9Sk=";

     

       15
       19
        
         };

     

       16
       20
        
       

     

       17
       17
       -
         nativeBuildInputs = [ pkg-config ];

     

       18
       18
       -
       

     

       19
       19
       -
         propagatedBuildInputs = [ wxGTK ffmpeg_3 libexif ];

     

       20
       20
       -
       

     

       21
       21
       -
         buildInputs = [ cairo pango ];

     

       21
       21
       +
         nativeBuildInputs = [

     

       22
       22
       +
           pkg-config

     

       23
       23
       +
         ];

     

       24
       24
       +
         buildInputs = [

     

       25
       25
       +
           cairo

     

       26
       26
       +
           ffmpeg

     

       27
       27
       +
           libexif

     

       28
       28
       +
           pango

     

       29
       29
       +
           wxGTK

     

       30
       30
       +
         ];

     

       22
       31
        
       

     

       23
       32
        
         meta = with lib; {

     

       33
       33
       +
           homepage = "http://wxsvg.sourceforge.net/";

     

       24
       34
        
           description = "A SVG manipulation library built with wxWidgets";

     

       25
       35
        
           longDescription = ''

     

       26
       26
       -
           wxSVG is C++ library to create, manipulate and render

     

       27
       27
       -
           Scalable Vector Graphics (SVG) files with the wxWidgets toolkit.

     

       36
       36
       +
             wxSVG is C++ library to create, manipulate and render Scalable Vector

     

       37
       37
       +
             Graphics (SVG) files with the wxWidgets toolkit.

     

       28
       38
        
           '';

     

       29
       29
       -
           homepage = "http://wxsvg.sourceforge.net/";

     

       30
       30
       -
           license = with licenses; gpl2;

     

       39
       39
       +
           license = with licenses; gpl2Plus;

     

       31
       40
        
           maintainers = with maintainers; [ AndersonTorres ];

     

       32
       32
       -
           platforms = with platforms; linux;

     

       41
       41
       +
           platforms = wxGTK.meta.platforms;

     

       33
       42
        
         };

     

       34
       43
        
       }

+65 -14

pkgs/development/libraries/xine-lib/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, pkg-config, xorg, alsaLib, libGLU, libGL, aalib

     

       2
       2
       -
       , libvorbis, libtheora, speex, zlib, perl, ffmpeg_3

     

       3
       3
       -
       , flac, libcaca, libpulseaudio, libmng, libcdio, libv4l, vcdimager

     

       4
       4
       -
       , libmpcdec, ncurses

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , fetchpatch

     

       5
       5
       +
       , aalib

     

       6
       6
       +
       , alsaLib

     

       7
       7
       +
       , ffmpeg

     

       8
       8
       +
       , flac

     

       9
       9
       +
       , libGL

     

       10
       10
       +
       , libGLU

     

       11
       11
       +
       , libcaca

     

       12
       12
       +
       , libcdio

     

       13
       13
       +
       , libmng

     

       14
       14
       +
       , libmpcdec

     

       15
       15
       +
       , libpulseaudio

     

       16
       16
       +
       , libtheora

     

       17
       17
       +
       , libv4l

     

       18
       18
       +
       , libvorbis

     

       19
       19
       +
       , perl

     

       20
       20
       +
       , pkg-config

     

       21
       21
       +
       , speex

     

       22
       22
       +
       , vcdimager

     

       23
       23
       +
       , xorg

     

       24
       24
       +
       , zlib

     

       5
       25
        
       }:

     

       6
       26
        
       

     

       7
       27
        
       stdenv.mkDerivation rec {

     
···

       10
       30
        
       

     

       11
       31
        
         src = fetchurl {

     

       12
       32
        
           url = "mirror://sourceforge/xine/xine-lib-${version}.tar.xz";

     

       13
       13
       -
           sha256 = "01bhq27g5zbgy6y36hl7lajz1nngf68vs4fplxgh98fx20fv4lgg";

     

       33
       33
       +
           sha256 = "sha256-71GyHRDdoQRfp9cRvZFxz9rwpaKHQjO88W/98o7AcAU=";

     

       14
       34
        
         };

     

       15
       35
        
       

     

       16
       16
       -
         nativeBuildInputs = [ pkg-config perl ];

     

       36
       36
       +
         nativeBuildInputs = [

     

       37
       37
       +
           pkg-config

     

       38
       38
       +
           perl

     

       39
       39
       +
         ];

     

       40
       40
       +
         buildInputs = [

     

       41
       41
       +
           aalib

     

       42
       42
       +
           alsaLib

     

       43
       43
       +
           ffmpeg

     

       44
       44
       +
           flac

     

       45
       45
       +
           libGL

     

       46
       46
       +
           libGLU

     

       47
       47
       +
           libcaca

     

       48
       48
       +
           libcdio

     

       49
       49
       +
           libmng

     

       50
       50
       +
           libmpcdec

     

       51
       51
       +
           libpulseaudio

     

       52
       52
       +
           libtheora

     

       53
       53
       +
           libv4l

     

       54
       54
       +
           libvorbis

     

       55
       55
       +
           perl

     

       56
       56
       +
           speex

     

       57
       57
       +
           vcdimager

     

       58
       58
       +
           zlib

     

       59
       59
       +
         ] ++ (with xorg; [

     

       60
       60
       +
           libX11

     

       61
       61
       +
           libXext

     

       62
       62
       +
           libXinerama

     

       63
       63
       +
           libXv

     

       64
       64
       +
           libxcb

     

       65
       65
       +
         ]);

     

       17
       66
        
       

     

       18
       18
       -
         buildInputs = [

     

       19
       19
       -
           xorg.libX11 xorg.libXv xorg.libXinerama xorg.libxcb xorg.libXext

     

       20
       20
       -
           alsaLib libGLU libGL aalib libvorbis libtheora speex perl ffmpeg_3 flac

     

       21
       21
       -
           libcaca libpulseaudio libmng libcdio libv4l vcdimager libmpcdec ncurses

     

       67
       67
       +
         patches = [

     

       68
       68
       +
           # splitting path plugin

     

       69
       69
       +
           (fetchpatch {

     

       70
       70
       +
             name = "0001-fix-XINE_PLUGIN_PATH-splitting.patch";

     

       71
       71
       +
             url = "https://sourceforge.net/p/xine/mailman/attachment/32394053-5e27-6558-f0c9-49e0da0bc3cc%40gmx.de/1/";

     

       72
       72
       +
             sha256 = "sha256-LJedxrD8JWITDo9pnS9BCmy7wiPTyJyoQ1puX49tOls=";

     

       73
       73
       +
           })

     

       22
       74
        
         ];

     

       23
       75
        
       

     

       24
       76
        
         NIX_LDFLAGS = "-lxcb-shm";

     

       25
       77
        
       

     

       26
       26
       -
         propagatedBuildInputs = [zlib];

     

       27
       27
       -
       

     

       28
       78
        
         enableParallelBuilding = true;

     

       29
       79
        
       

     

       30
       80
        
         meta = with lib; {

     

       31
       31
       -
           homepage = "http://xine.sourceforge.net/home";

     

       81
       81
       +
           homepage = "http://www.xinehq.de/";

     

       32
       82
        
           description = "A high-performance, portable and reusable multimedia playback engine";

     

       33
       33
       -
           platforms = platforms.linux;

     

       34
       83
        
           license = with licenses; [ gpl2Plus lgpl2Plus ];

     

       84
       84
       +
           maintainers = with maintainers; [ AndersonTorres ];

     

       85
       85
       +
           platforms = platforms.linux;

     

       35
       86
        
         };

     

       36
       87
        
       }

+56

pkgs/development/libraries/xsimd/default.nix

···

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, cmake, gtest }:

     

       2
       2
       +
       let

     

       3
       3
       +
         version = "7.5.0";

     

       4
       4
       +
       

     

       5
       5
       +
         darwin_src = fetchFromGitHub {

     

       6
       6
       +
           owner = "xtensor-stack";

     

       7
       7
       +
           repo = "xsimd";

     

       8
       8
       +
           rev = version;

     

       9
       9
       +
           sha256 = "eGAdRSYhf7rbFdm8g1Tz1ZtSVu44yjH/loewblhv9Vs=";

     

       10
       10
       +
           # Avoid requiring apple_sdk. We're doing this here instead of in the patchPhase

     

       11
       11
       +
           # because this source is directly used in arrow-cpp.

     

       12
       12
       +
           # pyconfig.h defines _GNU_SOURCE to 1, so we need to stamp that out too.

     

       13
       13
       +
           # Upstream PR with a better fix: https://github.com/xtensor-stack/xsimd/pull/463

     

       14
       14
       +
           postFetch = ''

     

       15
       15
       +
             mkdir $out

     

       16
       16
       +
             tar -xf $downloadedFile --directory=$out --strip-components=1

     

       17
       17
       +
             substituteInPlace $out/include/xsimd/types/xsimd_scalar.hpp \

     

       18
       18
       +
               --replace 'defined(__APPLE__)' 0 \

     

       19
       19
       +
               --replace 'defined(_GNU_SOURCE)' 0

     

       20
       20
       +
           '';

     

       21
       21
       +
         };

     

       22
       22
       +
       

     

       23
       23
       +
         src = fetchFromGitHub {

     

       24
       24
       +
           owner = "xtensor-stack";

     

       25
       25
       +
           repo = "xsimd";

     

       26
       26
       +
           rev = version;

     

       27
       27
       +
           sha256 = "0c9pq5vz43j99z83w3b9qylfi66mn749k1afpv5cwfxggbxvy63f";

     

       28
       28
       +
         };

     

       29
       29
       +
       in stdenv.mkDerivation {

     

       30
       30
       +
         pname = "xsimd";

     

       31
       31
       +
         inherit version;

     

       32
       32
       +
         src = if stdenv.hostPlatform.isDarwin then darwin_src else src;

     

       33
       33
       +
       

     

       34
       34
       +
         nativeBuildInputs = [ cmake ];

     

       35
       35
       +
       

     

       36
       36
       +
         cmakeFlags = [ "-DBUILD_TESTS=ON" ];

     

       37
       37
       +
       

     

       38
       38
       +
         doCheck = true;

     

       39
       39
       +
         checkInputs = [ gtest ];

     

       40
       40
       +
         checkTarget = "xtest";

     

       41
       41
       +
         GTEST_FILTER = let

     

       42
       42
       +
             # Upstream Issue: https://github.com/xtensor-stack/xsimd/issues/456

     

       43
       43
       +
             filteredTests = lib.optionals stdenv.hostPlatform.isDarwin [

     

       44
       44
       +
               "error_gamma_test/sse_double.gamma"

     

       45
       45
       +
               "error_gamma_test/avx_double.gamma"

     

       46
       46
       +
             ];

     

       47
       47
       +
           in "-${builtins.concatStringsSep ":" filteredTests}";

     

       48
       48
       +
       

     

       49
       49
       +
         meta = with lib; {

     

       50
       50
       +
           description = "C++ wrappers for SIMD intrinsics";

     

       51
       51
       +
           homepage = "https://github.com/xtensor-stack/xsimd";

     

       52
       52
       +
           license = licenses.bsd3;

     

       53
       53
       +
           maintainers = with maintainers; [ tobim ];

     

       54
       54
       +
           platforms = platforms.all;

     

       55
       55
       +
         };

     

       56
       56
       +
       }

+11 -6

pkgs/development/python-modules/pyarrow/default.nix

···

       34
       34
        
           export PYARROW_PARALLEL=$NIX_BUILD_CORES

     

       35
       35
        
         '';

     

       36
       36
        
       

     

       37
       37
       -
         # Deselect a single test because pyarrow prints a 2-line error message where

     

       38
       38
       -
         # only a single line is expected. The additional line of output comes from

     

       39
       39
       -
         # the glog library which is an optional dependency of arrow-cpp that is

     

       40
       40
       -
         # enabled in nixpkgs.

     

       41
       41
       -
         # Upstream Issue: https://issues.apache.org/jira/browse/ARROW-11393

     

       42
       42
       -
         pytestFlagsArray = [ "--deselect=pyarrow/tests/test_memory.py::test_env_var" ];

     

       37
       37
       +
         pytestFlagsArray = [

     

       38
       38
       +
           # Deselect a single test because pyarrow prints a 2-line error message where

     

       39
       39
       +
           # only a single line is expected. The additional line of output comes from

     

       40
       40
       +
           # the glog library which is an optional dependency of arrow-cpp that is

     

       41
       41
       +
           # enabled in nixpkgs.

     

       42
       42
       +
           # Upstream Issue: https://issues.apache.org/jira/browse/ARROW-11393

     

       43
       43
       +
           "--deselect=pyarrow/tests/test_memory.py::test_env_var"

     

       44
       44
       +
           # Deselect the parquet dataset write test because it erroneously fails to find the

     

       45
       45
       +
           # pyarrow._dataset module.

     

       46
       46
       +
           "--deselect=pyarrow/tests/parquet/test_dataset.py::test_write_to_dataset_filesystem"

     

       47
       47
       +
         ];

     

       43
       48
        
       

     

       44
       49
        
         dontUseSetuptoolsCheck = true;

     

       45
       50
        
         preCheck = ''

+15 -10

pkgs/development/python-modules/pykeepass/default.nix

···

       1
       1
       -
       { lib, fetchPypi, buildPythonPackage

     

       1
       1
       +
       { lib, fetchFromGitHub, buildPythonPackage

     

       2
       2
        
       , lxml, pycryptodomex, construct

     

       3
       3
        
       , argon2_cffi, dateutil, future

     

       4
       4
       +
       , python

     

       4
       5
        
       }:

     

       5
       6
        
       

     

       6
       7
        
       buildPythonPackage rec {

     

       7
       8
        
         pname   = "pykeepass";

     

       8
       9
        
         version = "4.0.0";

     

       9
       10
        
       

     

       10
       10
       -
         src = fetchPypi {

     

       11
       11
       -
           inherit pname version;

     

       12
       12
       -
           sha256 = "1b41b3277ea4e044556e1c5a21866ea4dfd36e69a4c0f14272488f098063178f";

     

       11
       11
       +
         src = fetchFromGitHub {

     

       12
       12
       +
           owner = "libkeepass";

     

       13
       13
       +
           repo = "pykeepass";

     

       14
       14
       +
           rev = version;

     

       15
       15
       +
           sha256 = "1zw5hjk90zfxpgq2fz4h5qzw3kmvdnlfbd32gw57l034hmz2i08v";

     

       13
       16
        
         };

     

       14
       17
        
       

     

       15
       18
        
         postPatch = ''

     
···

       21
       24
        
           argon2_cffi dateutil future

     

       22
       25
        
         ];

     

       23
       26
        
       

     

       24
       24
       -
         # no tests in PyPI tarball

     

       25
       25
       -
         doCheck = false;

     

       27
       27
       +
         checkPhase = ''

     

       28
       28
       +
           ${python.interpreter} -m unittest tests.tests

     

       29
       29
       +
         '';

     

       26
       30
        
       

     

       27
       27
       -
         meta = {

     

       28
       28
       -
           homepage = "https://github.com/pschmitt/pykeepass";

     

       31
       31
       +
         meta = with lib; {

     

       32
       32
       +
           homepage = "https://github.com/libkeepass/pykeepass";

     

       33
       33
       +
           changelog = "https://github.com/libkeepass/pykeepass/blob/${version}/CHANGELOG.rst";

     

       29
       34
        
           description = "Python library to interact with keepass databases (supports KDBX3 and KDBX4)";

     

       30
       30
       -
           license = lib.licenses.gpl3;

     

       35
       35
       +
           license = licenses.gpl3Only;

     

       36
       36
       +
           maintainers = with maintainers; [ dotlambda ];

     

       31
       37
        
         };

     

       32
       32
       -
       

     

       33
       38
        
       }

+75 -29

pkgs/development/tools/analysis/kcov/default.nix

···

       1
       1
       -
       {lib, stdenv, fetchFromGitHub, cmake, pkg-config, zlib, curl, elfutils, python3, libiberty, libopcodes}:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , cmake

     

       5
       5
       +
       , pkg-config

     

       6
       6
       +
       , zlib

     

       7
       7
       +
       , curl

     

       8
       8
       +
       , elfutils

     

       9
       9
       +
       , python3

     

       10
       10
       +
       , libiberty

     

       11
       11
       +
       , libopcodes

     

       12
       12
       +
       , runCommand

     

       13
       13
       +
       , gcc

     

       14
       14
       +
       , rustc

     

       15
       15
       +
       }:

     

       2
       16
        
       

     

       3
       3
       -
       stdenv.mkDerivation rec {

     

       4
       4
       -
         pname = "kcov";

     

       5
       5
       -
         version = "36";

     

       17
       17
       +
       let

     

       18
       18
       +
         self =

     

       19
       19
       +
           stdenv.mkDerivation rec {

     

       20
       20
       +
             pname = "kcov";

     

       21
       21
       +
             version = "38";

     

       6
       22
        
       

     

       7
       7
       -
         src = fetchFromGitHub {

     

       8
       8
       -
           owner = "SimonKagstrom";

     

       9
       9
       -
           repo = "kcov";

     

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

     

       11
       11
       -
           sha256 = "1q1mw5mxz041lr6qc2v4280rmx13pg1bx5r3bxz9bzs941r405r3";

     

       12
       12
       -
         };

     

       23
       23
       +
             src = fetchFromGitHub {

     

       24
       24
       +
               owner = "SimonKagstrom";

     

       25
       25
       +
               repo = "kcov";

     

       26
       26
       +
               rev = "v${version}";

     

       27
       27
       +
               sha256 = "sha256-6LoIo2/yMUz8qIpwJVcA3qZjjF+8KEM1MyHuyHsQD38=";

     

       28
       28
       +
             };

     

       13
       29
        
       

     

       14
       14
       -
         preConfigure = "patchShebangs src/bin-to-c-source.py";

     

       15
       15
       -
         nativeBuildInputs = [ cmake pkg-config python3 ];

     

       30
       30
       +
             preConfigure = "patchShebangs src/bin-to-c-source.py";

     

       31
       31
       +
             nativeBuildInputs = [ cmake pkg-config python3 ];

     

       16
       32
        
       

     

       17
       17
       -
         buildInputs = [ curl zlib elfutils libiberty libopcodes ];

     

       33
       33
       +
             buildInputs = [ curl zlib elfutils libiberty libopcodes ];

     

       18
       34
        
       

     

       19
       19
       -
         strictDeps = true;

     

       35
       35
       +
             strictDeps = true;

     

       20
       36
        
       

     

       21
       21
       -
         meta = with lib; {

     

       22
       22
       -
           description = "Code coverage tester for compiled programs, Python scripts and shell scripts";

     

       37
       37
       +
             passthru.tests = {

     

       38
       38
       +
               works-on-c = runCommand "works-on-c" {} ''

     

       39
       39
       +
                 set -ex

     

       40
       40
       +
                 cat - > a.c <<EOF

     

       41
       41
       +
                 int main() {}

     

       42
       42
       +
                 EOF

     

       43
       43
       +
                 ${gcc}/bin/gcc a.c -o a.out

     

       44
       44
       +
                 ${self}/bin/kcov /tmp/kcov ./a.out

     

       45
       45
       +
                 test -e /tmp/kcov/index.html

     

       46
       46
       +
                 touch $out

     

       47
       47
       +
                 set +x

     

       48
       48
       +
               '';

     

       23
       49
        
       

     

       24
       24
       -
           longDescription = ''

     

       25
       25
       -
             Kcov is a code coverage tester for compiled programs, Python

     

       26
       26
       -
             scripts and shell scripts. It allows collecting code coverage

     

       27
       27
       -
             information from executables without special command-line

     

       28
       28
       -
             arguments, and continuosly produces output from long-running

     

       29
       29
       -
             applications.

     

       30
       30
       -
           '';

     

       50
       50
       +
               works-on-rust = runCommand "works-on-rust" {} ''

     

       51
       51
       +
                 set -ex

     

       52
       52
       +
                 cat - > a.rs <<EOF

     

       53
       53
       +
                 fn main() {}

     

       54
       54
       +
                 EOF

     

       55
       55
       +
                 # Put gcc in the path so that `cc` is found

     

       56
       56
       +
                 PATH=${gcc}/bin:$PATH ${rustc}/bin/rustc a.rs -o a.out

     

       57
       57
       +
                 ${self}/bin/kcov /tmp/kcov ./a.out

     

       58
       58
       +
                 test -e /tmp/kcov/index.html

     

       59
       59
       +
                 touch $out

     

       60
       60
       +
                 set +x

     

       61
       61
       +
               '';

     

       62
       62
       +
             };

     

       31
       63
        
       

     

       32
       32
       -
           homepage = "http://simonkagstrom.github.io/kcov/index.html";

     

       33
       33
       -
           license = licenses.gpl2;

     

       64
       64
       +
             meta = with lib; {

     

       65
       65
       +
               description = "Code coverage tester for compiled programs, Python scripts and shell scripts";

     

       34
       66
        
       

     

       35
       35
       -
           maintainers = with maintainers; [ gal_bolle ekleog ];

     

       36
       36
       -
           platforms = platforms.linux;

     

       37
       37
       -
         };

     

       38
       38
       -
       }

     

       67
       67
       +
               longDescription = ''

     

       68
       68
       +
                 Kcov is a code coverage tester for compiled programs, Python

     

       69
       69
       +
                 scripts and shell scripts. It allows collecting code coverage

     

       70
       70
       +
                 information from executables without special command-line

     

       71
       71
       +
                 arguments, and continuosly produces output from long-running

     

       72
       72
       +
                 applications.

     

       73
       73
       +
               '';

     

       74
       74
       +
       

     

       75
       75
       +
               homepage = "http://simonkagstrom.github.io/kcov/index.html";

     

       76
       76
       +
               license = licenses.gpl2;

     

       77
       77
       +
               changelog = "https://github.com/SimonKagstrom/kcov/blob/master/ChangeLog";

     

       78
       78
       +
       

     

       79
       79
       +
               maintainers = with maintainers; [ gal_bolle ekleog ];

     

       80
       80
       +
               platforms = platforms.linux;

     

       81
       81
       +
             };

     

       82
       82
       +
           };

     

       83
       83
       +
       in

     

       84
       84
       +
       self

+2 -2

pkgs/games/steam/runtime.nix

···

       8
       8
        
       

     

       9
       9
        
         pname = "steam-runtime";

     

       10
       10
        
         # from https://repo.steampowered.com/steamrt-images-scout/snapshots/

     

       11
       11
       -
         version = "0.20201203.1";

     

       11
       11
       +
         version = "0.20210317.0";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchurl {

     

       14
       14
        
           url = "https://repo.steampowered.com/steamrt-images-scout/snapshots/${version}/steam-runtime.tar.xz";

     

       15
       15
       -
           sha256 = "sha256-hOHfMi0x3K82XM3m/JmGYbVk5RvuHG+m275eAC0MoQc=";

     

       15
       15
       +
           sha256 = "061z2r33n2017prmhdxm82cly3qp3bma2q70pqs57adl65yvg7vw";

     

       16
       16
        
           name = "scout-runtime-${version}.tar.gz";

     

       17
       17
        
         };

     

       18
       18

+46 -19

pkgs/misc/emulators/mgba/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, makeDesktopItem, wrapQtAppsHook, pkg-config

     

       2
       2
       -
       , cmake, epoxy, libzip, libelf, libedit, ffmpeg_3, SDL2, imagemagick

     

       3
       3
       -
       , qtbase, qtmultimedia, qttools, minizip }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , SDL2

     

       5
       5
       +
       , cmake

     

       6
       6
       +
       , epoxy

     

       7
       7
       +
       , ffmpeg

     

       8
       8
       +
       , imagemagick

     

       9
       9
       +
       , libedit

     

       10
       10
       +
       , libelf

     

       11
       11
       +
       , libzip

     

       12
       12
       +
       , makeDesktopItem

     

       13
       13
       +
       , minizip

     

       14
       14
       +
       , pkg-config

     

       15
       15
       +
       , qtbase

     

       16
       16
       +
       , qtmultimedia

     

       17
       17
       +
       , qttools

     

       18
       18
       +
       , wrapQtAppsHook

     

       19
       19
       +
       }:

     

       4
       20
        
       

     

       5
       21
        
       let

     

       6
       22
        
         desktopItem = makeDesktopItem {

     
···

       21
       37
        
           owner = "mgba-emu";

     

       22
       38
        
           repo = "mgba";

     

       23
       39
        
           rev = version;

     

       24
       24
       -
           sha256 = "sha256-JVauGyHJVfiXVG4Z+Ydh1lRypy5rk9SKeTbeHFNFYJs=";

     

       40
       40
       +
           hash = "sha256-JVauGyHJVfiXVG4Z+Ydh1lRypy5rk9SKeTbeHFNFYJs=";

     

       25
       41
        
         };

     

       26
       42
        
       

     

       27
       27
       -
         nativeBuildInputs = [ wrapQtAppsHook pkg-config cmake ];

     

       28
       28
       -
       

     

       43
       43
       +
         nativeBuildInputs = [

     

       44
       44
       +
           cmake

     

       45
       45
       +
           pkg-config

     

       46
       46
       +
           wrapQtAppsHook

     

       47
       47
       +
         ];

     

       29
       48
        
         buildInputs = [

     

       30
       30
       -
           epoxy libzip libelf libedit ffmpeg_3 SDL2 imagemagick

     

       31
       31
       -
           qtbase qtmultimedia qttools minizip

     

       49
       49
       +
           SDL2

     

       50
       50
       +
           epoxy

     

       51
       51
       +
           ffmpeg

     

       52
       52
       +
           imagemagick

     

       53
       53
       +
           libedit

     

       54
       54
       +
           libelf

     

       55
       55
       +
           libzip

     

       56
       56
       +
           minizip

     

       57
       57
       +
           qtbase

     

       58
       58
       +
           qtmultimedia

     

       59
       59
       +
           qttools

     

       32
       60
        
         ];

     

       33
       61
        
       

     

       34
       62
        
         postInstall = ''

     
···

       38
       66
        
         meta = with lib; {

     

       39
       67
        
           homepage = "https://mgba.io";

     

       40
       68
        
           description = "A modern GBA emulator with a focus on accuracy";

     

       41
       41
       -
       

     

       42
       69
        
           longDescription = ''

     

       43
       70
        
             mGBA is a new Game Boy Advance emulator written in C.

     

       44
       71
        
       

     

       45
       45
       -
             The project started in April 2013 with the goal of being fast

     

       46
       46
       -
             enough to run on lower end hardware than other emulators

     

       47
       47
       -
             support, without sacrificing accuracy or portability. Even in

     

       48
       48
       -
             the initial version, games generally play without problems. It

     

       49
       49
       -
             is loosely based on the previous GBA.js emulator, although very

     

       50
       50
       -
             little of GBA.js can still be seen in mGBA.

     

       72
       72
       +
             The project started in April 2013 with the goal of being fast enough to

     

       73
       73
       +
             run on lower end hardware than other emulators support, without

     

       74
       74
       +
             sacrificing accuracy or portability. Even in the initial version, games

     

       75
       75
       +
             generally play without problems. It is loosely based on the previous

     

       76
       76
       +
             GBA.js emulator, although very little of GBA.js can still be seen in mGBA.

     

       51
       77
        
       

     

       52
       52
       -
             Other goals include accurate enough emulation to provide a

     

       53
       53
       -
             development environment for homebrew software, a good workflow

     

       54
       54
       -
             for tool-assist runners, and a modern feature set for emulators

     

       55
       55
       -
             that older emulators may not support.

     

       78
       78
       +
             Other goals include accurate enough emulation to provide a development

     

       79
       79
       +
             environment for homebrew software, a good workflow for tool-assist

     

       80
       80
       +
             runners, and a modern feature set for emulators that older emulators may

     

       81
       81
       +
             not support.

     

       56
       82
        
           '';

     

       57
       83
        
       

     

       58
       84
        
           license = licenses.mpl20;

     
···

       60
       86
        
           platforms = platforms.linux;

     

       61
       87
        
         };

     

       62
       88
        
       }

     

       89
       89
       +
       # TODO [ AndersonTorres ]: use desktopItem functions

+10 -8

pkgs/misc/emulators/ppsspp/default.nix

···

       1
       1
       -
       { SDL2

     

       2
       2
       -
       , cmake

     

       1
       1
       +
       { mkDerivation

     

       3
       2
        
       , fetchFromGitHub

     

       4
       4
       -
       , ffmpeg_3

     

       3
       3
       +
       , SDL2

     

       4
       4
       +
       , cmake

     

       5
       5
       +
       , ffmpeg

     

       5
       6
        
       , glew

     

       6
       7
        
       , lib

     

       7
       8
        
       , libzip

     

       8
       8
       -
       , mkDerivation

     

       9
       9
        
       , pkg-config

     

       10
       10
        
       , python3

     

       11
       11
        
       , qtbase

     
···

       23
       23
        
           repo = pname;

     

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

     

       25
       25
        
           fetchSubmodules = true;

     

       26
       26
       -
           sha256 = "19948jzqpclf8zfzp3k7s580xfjgqcyfwlcp7x7xj8h8lyypzymx";

     

       26
       26
       +
           sha256 = "sha256-vfp/vacIItlPP5dR7jzDT7oOUNFnjvvdR46yi79EJKU=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         postPatch = ''

     
···

       35
       35
        
       

     

       36
       36
        
         buildInputs = [

     

       37
       37
        
           SDL2

     

       38
       38
       -
           ffmpeg_3

     

       38
       38
       +
           ffmpeg

     

       39
       39
        
           glew

     

       40
       40
        
           libzip

     

       41
       41
        
           qtbase

     
···

       45
       45
        
         ];

     

       46
       46
        
       

     

       47
       47
        
         cmakeFlags = [

     

       48
       48
       +
           "-DHEADLESS=OFF"

     

       48
       49
        
           "-DOpenGL_GL_PREFERENCE=GLVND"

     

       49
       50
        
           "-DUSE_SYSTEM_FFMPEG=ON"

     

       50
       51
        
           "-DUSE_SYSTEM_LIBZIP=ON"

     

       51
       52
        
           "-DUSE_SYSTEM_SNAPPY=ON"

     

       52
       53
        
           "-DUSING_QT_UI=ON"

     

       53
       53
       -
           "-DHEADLESS=OFF"

     

       54
       54
        
         ];

     

       55
       55
        
       

     

       56
       56
        
         installPhase = ''

     

       57
       57
       +
           runHook preInstall

     

       57
       58
        
           mkdir -p $out/share/ppsspp

     

       58
       59
        
           install -Dm555 PPSSPPQt $out/bin/ppsspp

     

       59
       60
        
           mv assets $out/share/ppsspp

     

       61
       61
       +
           runHook postInstall

     

       60
       62
        
         '';

     

       61
       63
        
       

     

       62
       64
        
         meta = with lib; {

     

       63
       63
       -
           description = "A HLE Playstation Portable emulator, written in C++";

     

       64
       65
        
           homepage = "https://www.ppsspp.org/";

     

       66
       66
       +
           description = "A HLE Playstation Portable emulator, written in C++";

     

       65
       67
        
           license = licenses.gpl2Plus;

     

       66
       68
        
           maintainers = with maintainers; [ AndersonTorres ];

     

       67
       69
        
           platforms = platforms.linux;

+2 -2

pkgs/os-specific/linux/rtl88xxau-aircrack/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "rtl88xxau-aircrack-${kernel.version}-${version}";

     

       5
       5
       -
         rev = "fc0194c1d90453bf4943089ca237159ef19a7374";

     

       5
       5
       +
         rev = "c0ce81745eb3471a639f0efd4d556975153c666e";

     

       6
       6
        
         version = "${builtins.substring 0 6 rev}";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           owner = "aircrack-ng";

     

       10
       10
        
           repo = "rtl8812au";

     

       11
       11
        
           inherit rev;

     

       12
       12
       -
           sha256 = "0hf7mrvxaskc6qcjar5w81y9xc7s2rlsxp34achyqly2hjg7fgmy";

     

       12
       12
       +
           sha256 = "131cwwg3czq0i1xray20j71n836g93ac064nvf8wi13c2wr36ppc";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         buildInputs = kernel.moduleBuildDependencies;

+3 -3

pkgs/servers/maddy/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "maddy";

     

       5
       5
       -
         version = "0.4.3";

     

       5
       5
       +
         version = "0.4.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "foxcpp";

     

       9
       9
        
           repo = "maddy";

     

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

     

       11
       11
       -
           sha256 = "1mi607hl4c9y9xxv5lywh9fvpybprlrgqa7617km9rssbgk4x1v7";

     

       11
       11
       +
           sha256 = "sha256-IhVEb6tjfbWqhQdw1UYxy4I8my2L+eSOCd/BEz0qis0=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "16laf864789yiakvqs6dy3sgnnp2hcdbyzif492wcijqlir2swv7";

     

       14
       14
       +
         vendorSha256 = "sha256-FrKWlZ3pQB+oo+rfHA8AgGRAr7YRUcb064bZGTDSKkk=";

     

       15
       15
        
       

     

       16
       16
        
         buildFlagsArray = [ "-ldflags=-s -w -X github.com/foxcpp/maddy.Version=${version}" ];

     

       17
       17

+3 -2

pkgs/servers/sql/postgresql/ext/pgvector.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "pgvector";

     

       5
       5
       -
         version = "0.1.0";

     

       5
       5
       +
         version = "0.1.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "ankane";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "03i8rq9wp9j2zdba82q31lzbrqpnhrqc8867pxxy3z505fxsvfzb";

     

       11
       11
       +
           sha256 = "1vq672ghhv0azpzgfb7azb36kbjyz9ypcly7r16lrryvjgp5lcjs";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         buildInputs = [ postgresql ];

     
···

       22
       22
        
         meta = with lib; {

     

       23
       23
        
           description = "Open-source vector similarity search for PostgreSQL";

     

       24
       24
        
           homepage = "https://github.com/ankane/pgvector";

     

       25
       25
       +
           changelog = "https://github.com/ankane/pgvector/raw/v${version}/CHANGELOG.md";

     

       25
       26
        
           license = licenses.postgresql;

     

       26
       27
        
           platforms = postgresql.meta.platforms;

     

       27
       28
        
           maintainers = [ maintainers.marsam ];

+2 -2

pkgs/tools/networking/lldpd/default.nix

···

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         pname = "lldpd";

     

       7
       7
       -
         version = "1.0.8";

     

       7
       7
       +
         version = "1.0.10";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchurl {

     

       10
       10
        
           url = "https://media.luffy.cx/files/lldpd/${pname}-${version}.tar.gz";

     

       11
       11
       -
           sha256 = "sha256-mNIA524w9iYsSkSTFIwYQIJ4mDKRRqV6NPjw+SjKPe8=";

     

       11
       11
       +
           sha256 = "sha256-RFstdgN+8+vQPUDh/B8p7wgQL6o6Cf6Ea5Unl8i8dyI=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         configureFlags = [

+2 -2

pkgs/tools/nix/nix-output-monitor/default.nix

···

       5
       5
        
       }:

     

       6
       6
        
       mkDerivation rec {

     

       7
       7
        
         pname = "nix-output-monitor";

     

       8
       8
       -
         version = "1.0.3.0";

     

       8
       8
       +
         version = "1.0.3.1";

     

       9
       9
        
         src = fetchFromGitHub {

     

       10
       10
        
           owner = "maralorn";

     

       11
       11
        
           repo = "nix-output-monitor";

     

       12
       12
       -
           sha256 = "1gidg03cwz8ss370bgz4a2g9ldj1lap5ws7dmfg6vigpx8mxigpb";

     

       12
       12
       +
           sha256 = "1kkf6cqq8aba8vmfcww30ah9j44bwakanyfdb6595vmaq5hrsq92";

     

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

     

       14
       14
        
         };

     

       15
       15
        
         isLibrary = true;

+3 -3

pkgs/tools/package-management/cargo-deb/default.nix

···

       8
       8
        
       

     

       9
       9
        
       rustPlatform.buildRustPackage rec {

     

       10
       10
        
         pname = "cargo-deb";

     

       11
       11
       -
         version = "1.29.1";

     

       11
       11
       +
         version = "1.29.2";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "mmstick";

     

       15
       15
        
           repo = pname;

     

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

     

       17
       17
       -
           sha256 = "sha256-oWivGy2azF9zpeZ0UAi7Bxm4iXFWAjcBG0pN7qtkSU8=";

     

       17
       17
       +
           sha256 = "sha256-2eOWhxKZ+YPj5oKTe5g7PyeakiSNnPz27dK150GAcVQ=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         buildInputs = lib.optionals stdenv.isDarwin [ Security ];

     

       21
       21
        
       

     

       22
       22
       -
         cargoSha256 = "0j9frvcmy9hydw73v0ffr0bjvq2ykylnpmiw700z344djpaaa08y";

     

       22
       22
       +
         cargoSha256 = "sha256-QmchuY+4R7w0zMOdReH1m8idl9RI1hHE9VtbwT2K9YM=";

     

       23
       23
        
       

     

       24
       24
        
         preCheck = ''

     

       25
       25
        
           substituteInPlace tests/command.rs \

+7 -2

pkgs/tools/security/pass/extensions/import.nix

···

       17
       17
        
           sha256 = "sha256-nH2xAqWfMT+Brv3z9Aw6nbvYqArEZjpM28rKsRPihqA=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         # by default, tries to install scripts/pimport, which is a bash wrapper around "python -m pass_import ..."

     

       21
       21
       -
         # This is a better way to do the same, and takes advantage of the existing Nix python environments

     

       22
       20
        
         patches = [

     

       21
       21
       +
           (fetchpatch {

     

       22
       22
       +
             name = "support-for-keepass-4.0.0.patch";

     

       23
       23
       +
             url = "https://github.com/roddhjav/pass-import/commit/86cfb1bb13a271fefe1e70f24be18e15a83a04d8.patch";

     

       24
       24
       +
             sha256 = "0mrlblqlmwl9gqs2id4rl4sivrcclsv6zyc6vjqi78kkqmnwzhxh";

     

       25
       25
       +
           })

     

       26
       26
       +
           # by default, tries to install scripts/pimport, which is a bash wrapper around "python -m pass_import ..."

     

       27
       27
       +
           # This is a better way to do the same, and takes advantage of the existing Nix python environments

     

       23
       28
        
           # from https://github.com/roddhjav/pass-import/pull/138

     

       24
       29
        
           (fetchpatch {

     

       25
       30
        
             name = "pass-import-pr-138-pimport-entrypoint.patch";

+3 -3

pkgs/tools/system/logcheck/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "logcheck";

     

       5
       5
       -
         version = "1.3.22";

     

       5
       5
       +
         version = "1.3.23";

     

       6
       6
        
         _name    = "logcheck_${version}";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           url = "mirror://debian/pool/main/l/logcheck/${_name}.tar.xz";

     

       10
       10
       -
           sha256 = "sha256-e7XeRNlFsexlVskK2OnLTmNV/ES2xWU+/+AElexV6E4=";

     

       10
       10
       +
           sha256 = "sha256-ohiLpUn/9EEsggdLJxiE/2bSXz/bKkGRboF85naFWyk=";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         prePatch = ''

     
···

       42
       42
        
             Logcheck was part of the Abacus Project of security tools, but this version has been rewritten.

     

       43
       43
        
           '';

     

       44
       44
        
           homepage = "https://salsa.debian.org/debian/logcheck";

     

       45
       45
       -
           license = licenses.gpl2;

     

       45
       45
       +
           license = licenses.gpl2Plus;

     

       46
       46
        
           maintainers = [ maintainers.bluescreen303 ];

     

       47
       47
        
         };

     

       48
       48
        
       }

pkgs/top-level/aliases.nix

···

       853
       853
        
         xbmcPlain = kodiPlain; # added 2018-04-25

     

       854
       854
        
         xbmcPlugins = kodiPackages; # added 2018-04-25

     

       855
       855
        
         kodiPlugins = kodiPackages; # added 2021-03-09;

     

       856
       856
       +
         xineLib = xine-lib; # added 2021-04-27

     

       857
       857
       +
         xineUI = xine-ui; # added 2021-04-27

     

       856
       858
        
         xmonad_log_applet_gnome3 = xmonad_log_applet; # added 2018-05-01

     

       857
       859
        
         xmpppy = throw "xmpppy has been removed from nixpkgs as it is unmaintained and python2-only";

     

       858
       860
        
         pyIRCt = throw "pyIRCt has been removed from nixpkgs as it is unmaintained and python2-only";

+4 -2

pkgs/top-level/all-packages.nix

···

       18097
       18097
        
       

     

       18098
       18098
        
         xed = callPackage ../development/libraries/xed { };

     

       18099
       18099
        
       

     

       18100
       18100
       -
         xineLib = callPackage ../development/libraries/xine-lib { };

     

       18100
       18100
       +
         xine-lib = callPackage ../development/libraries/xine-lib { };

     

       18101
       18101
        
       

     

       18102
       18102
        
         xautolock = callPackage ../misc/screensavers/xautolock { };

     

       18103
       18103
        
       

     
···

       18126
       18126
        
         xml-tooling-c = callPackage ../development/libraries/xml-tooling-c { };

     

       18127
       18127
        
       

     

       18128
       18128
        
         xlslib = callPackage ../development/libraries/xlslib { };

     

       18129
       18129
       +
       

     

       18130
       18130
       +
         xsimd = callPackage ../development/libraries/xsimd { };

     

       18129
       18131
        
       

     

       18130
       18132
        
         xvidcore = callPackage ../development/libraries/xvidcore { };

     

       18131
       18133
        
       

     
···

       27159
       27161
        
       

     

       27160
       27162
        
         xfractint = callPackage ../applications/graphics/xfractint {};

     

       27161
       27163
        
       

     

       27162
       27162
       -
         xineUI = callPackage ../applications/video/xine-ui { };

     

       27164
       27164
       +
         xine-ui = callPackage ../applications/video/xine-ui { };

     

       27163
       27165
        
       

     

       27164
       27166
        
         xlsxgrep = callPackage ../applications/search/xlsxgrep { };

     

       27165
       27167