commit 883232c00ddc5e2a804084a8cdf94ffaf4c1cb0c · pyrox.dev/nixpkgs

+1 -1

doc/languages-frameworks/python.section.md

···

       205
       205
        
           license = licenses.bsd3;

     

       206
       206
        
           maintainers = with maintainers; [ fridh ];

     

       207
       207
        
         };

     

       208
       208
       -
       };

     

       208
       208
       +
       }

     

       209
       209
        
       ```

     

       210
       210
        
       

     

       211
       211
        
       What happens here? The function `buildPythonPackage` is called and as argument

lib/licenses.nix

···

       145
       145
        
           free = false;

     

       146
       146
        
         };

     

       147
       147
        
       

     

       148
       148
       +
         cc-by-nc-30 = spdx {

     

       149
       149
       +
           spdxId = "CC-BY-NC-3.0";

     

       150
       150
       +
           fullName = "Creative Commons Attribution Non Commercial 3.0 Unported";

     

       151
       151
       +
           free = false;

     

       152
       152
       +
         };

     

       153
       153
       +
       

     

       148
       154
        
         cc-by-nc-40 = spdx {

     

       149
       155
        
           spdxId = "CC-BY-NC-4.0";

     

       150
       156
        
           fullName = "Creative Commons Attribution Non Commercial 4.0 International";

maintainers/maintainer-list.nix

···

       3218
       3218
        
           github = "mogria";

     

       3219
       3219
        
           name = "Mogria";

     

       3220
       3220
        
         };

     

       3221
       3221
       +
         monsieurp = {

     

       3222
       3222
       +
           email = "monsieurp@gentoo.org";

     

       3223
       3223
       +
           github = "monsieurp";

     

       3224
       3224
       +
           name = "Patrice Clement";

     

       3225
       3225
       +
         };

     

       3221
       3226
        
         montag451 = {

     

       3222
       3227
        
           email = "montag451@laposte.net";

     

       3223
       3228
        
           github = "montag451";

nixos/modules/module-list.nix

···

       686
       686
        
         ./services/networking/vsftpd.nix

     

       687
       687
        
         ./services/networking/wakeonlan.nix

     

       688
       688
        
         ./services/networking/websockify.nix

     

       689
       689
       +
         ./services/networking/wg-quick.nix

     

       689
       690
        
         ./services/networking/wicd.nix

     

       690
       691
        
         ./services/networking/wireguard.nix

     

       691
       692
        
         ./services/networking/wpa_supplicant.nix

+29 -22

nixos/modules/services/misc/packagekit.nix

···

       7
       7
        
         cfg = config.services.packagekit;

     

       8
       8
        
       

     

       9
       9
        
         packagekitConf = ''

     

       10
       10
       -
       [Daemon]

     

       11
       11
       -
       KeepCache=false

     

       12
       12
       -
           '';

     

       10
       10
       +
           [Daemon]

     

       11
       11
       +
           DefaultBackend=${cfg.backend}

     

       12
       12
       +
           KeepCache=false

     

       13
       13
       +
         '';

     

       13
       14
        
       

     

       14
       15
        
         vendorConf = ''

     

       15
       15
       -
       [PackagesNotFound]

     

       16
       16
       -
       DefaultUrl=https://github.com/NixOS/nixpkgs

     

       17
       17
       -
       CodecUrl=https://github.com/NixOS/nixpkgs

     

       18
       18
       -
       HardwareUrl=https://github.com/NixOS/nixpkgs

     

       19
       19
       -
       FontUrl=https://github.com/NixOS/nixpkgs

     

       20
       20
       -
       MimeUrl=https://github.com/NixOS/nixpkgs

     

       21
       21
       -
             '';

     

       16
       16
       +
           [PackagesNotFound]

     

       17
       17
       +
           DefaultUrl=https://github.com/NixOS/nixpkgs

     

       18
       18
       +
           CodecUrl=https://github.com/NixOS/nixpkgs

     

       19
       19
       +
           HardwareUrl=https://github.com/NixOS/nixpkgs

     

       20
       20
       +
           FontUrl=https://github.com/NixOS/nixpkgs

     

       21
       21
       +
           MimeUrl=https://github.com/NixOS/nixpkgs

     

       22
       22
       +
         '';

     

       22
       23
        
       

     

       23
       24
        
       in

     

       24
       25
        
       

     
···

       33
       34
        
                 installing software. Software utilizing PackageKit can install

     

       34
       35
        
                 software regardless of the package manager.

     

       35
       36
        
               '';

     

       37
       37
       +
       

     

       38
       38
       +
             # TODO: integrate with PolicyKit if the nix backend matures to the point

     

       39
       39
       +
             # where it will require elevated permissions

     

       40
       40
       +
             backend = mkOption {

     

       41
       41
       +
               type = types.enum [ "test_nop" ];

     

       42
       42
       +
               default = "test_nop";

     

       43
       43
       +
               description = ''

     

       44
       44
       +
                 PackageKit supports multiple different backends and <literal>auto</literal> which

     

       45
       45
       +
                 should do the right thing.

     

       46
       46
       +
                 </para>

     

       47
       47
       +
                 <para>

     

       48
       48
       +
                 On NixOS however, we do not have a backend compatible with nix 2.0

     

       49
       49
       +
                 (refer to <link xlink:href="https://github.com/NixOS/nix/issues/233">this issue</link> so we have to force

     

       50
       50
       +
                 it to <literal>test_nop</literal> for now.

     

       51
       51
       +
               '';

     

       52
       52
       +
             };

     

       36
       53
        
           };

     

       37
       37
       -
       

     

       38
       54
        
         };

     

       39
       55
        
       

     

       40
       56
        
         config = mkIf cfg.enable {

     

       41
       57
        
       

     

       42
       42
       -
           services.dbus.packages = [ pkgs.packagekit ];

     

       58
       58
       +
           services.dbus.packages = with pkgs; [ packagekit ];

     

       43
       59
        
       

     

       44
       44
       -
           systemd.services.packagekit = {

     

       45
       45
       -
             description = "PackageKit Daemon";

     

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

     

       47
       47
       -
             serviceConfig.ExecStart = "${pkgs.packagekit}/libexec/packagekitd";

     

       48
       48
       -
             serviceConfig.User = "root";

     

       49
       49
       -
             serviceConfig.BusName = "org.freedesktop.PackageKit";

     

       50
       50
       -
             serviceConfig.Type = "dbus";

     

       51
       51
       -
           };

     

       60
       60
       +
           systemd.packages = with pkgs; [ packagekit ];

     

       52
       61
        
       

     

       53
       62
        
           environment.etc."PackageKit/PackageKit.conf".text = packagekitConf;

     

       54
       63
        
           environment.etc."PackageKit/Vendor.conf".text = vendorConf;

     

       55
       55
       -
       

     

       56
       64
        
         };

     

       57
       57
       -
       

     

       58
       65
        
       }

+40 -62

nixos/modules/services/misc/plex.nix

···

       10
       10
        
           services.plex = {

     

       11
       11
        
             enable = mkEnableOption "Plex Media Server";

     

       12
       12
        
       

     

       13
       13
       -
             # FIXME: In order for this config option to work, symlinks in the Plex

     

       14
       14
       -
             # package in the Nix store have to be changed to point to this directory.

     

       15
       13
        
             dataDir = mkOption {

     

       16
       14
        
               type = types.str;

     

       17
       15
        
               default = "/var/lib/plex";

     

       18
       18
       -
               description = "The directory where Plex stores its data files.";

     

       16
       16
       +
               description = ''

     

       17
       17
       +
                 The directory where Plex stores its data files.

     

       18
       18
       +
               '';

     

       19
       19
        
             };

     

       20
       20
        
       

     

       21
       21
        
             openFirewall = mkOption {

     

       22
       22
        
               type = types.bool;

     

       23
       23
        
               default = false;

     

       24
       24
        
               description = ''

     

       25
       25
       -
                 Open ports in the firewall for the media server

     

       25
       25
       +
                 Open ports in the firewall for the media server.

     

       26
       26
        
               '';

     

       27
       27
        
             };

     

       28
       28
        
       

     

       29
       29
        
             user = mkOption {

     

       30
       30
        
               type = types.str;

     

       31
       31
        
               default = "plex";

     

       32
       32
       -
               description = "User account under which Plex runs.";

     

       32
       32
       +
               description = ''

     

       33
       33
       +
                 User account under which Plex runs.

     

       34
       34
       +
               '';

     

       33
       35
        
             };

     

       34
       36
        
       

     

       35
       37
        
             group = mkOption {

     

       36
       38
        
               type = types.str;

     

       37
       39
        
               default = "plex";

     

       38
       38
       -
               description = "Group under which Plex runs.";

     

       40
       40
       +
               description = ''

     

       41
       41
       +
                 Group under which Plex runs.

     

       42
       42
       +
               '';

     

       39
       43
        
             };

     

       40
       40
       -
       

     

       41
       44
        
       

     

       42
       45
        
             managePlugins = mkOption {

     

       43
       46
        
               type = types.bool;

     
···

       80
       83
        
             description = "Plex Media Server";

     

       81
       84
        
             after = [ "network.target" ];

     

       82
       85
        
             wantedBy = [ "multi-user.target" ];

     

       83
       83
       -
             preStart = ''

     

       84
       84
       -
               test -d "${cfg.dataDir}/Plex Media Server" || {

     

       85
       85
       -
                 echo "Creating initial Plex data directory in \"${cfg.dataDir}\"."

     

       86
       86
       -
                 mkdir -p "${cfg.dataDir}/Plex Media Server"

     

       87
       87
       -
                 chown -R ${cfg.user}:${cfg.group} "${cfg.dataDir}"

     

       88
       88
       -
               }

     

       89
       86
        
       

     

       90
       90
       -
               # Copy the database skeleton files to /var/lib/plex/.skeleton

     

       91
       91
       -
               # See the the Nix expression for Plex's package for more information on

     

       92
       92
       -
               # why this is done.

     

       93
       93
       -
               install --owner ${cfg.user} --group ${cfg.group} -d "${cfg.dataDir}/.skeleton"

     

       94
       94
       -
               for db in "com.plexapp.plugins.library.db"; do

     

       95
       95
       -
                   if [ ! -e  "${cfg.dataDir}/.skeleton/$db" ]; then

     

       96
       96
       -
                     cp "${cfg.package}/usr/lib/plexmediaserver/Resources/base_$db" "${cfg.dataDir}/.skeleton/$db"

     

       97
       97
       -
                   fi

     

       98
       98
       -
                   chmod u+w "${cfg.dataDir}/.skeleton/$db"

     

       99
       99
       -
                   chown ${cfg.user}:${cfg.group} "${cfg.dataDir}/.skeleton/$db"

     

       100
       100
       -
               done

     

       101
       101
       -
       

     

       102
       102
       -
               # If managePlugins is enabled, setup symlinks for plugins.

     

       103
       103
       -
               ${optionalString cfg.managePlugins ''

     

       104
       104
       -
                 echo "Preparing plugin directory."

     

       105
       105
       -
                 PLUGINDIR="${cfg.dataDir}/Plex Media Server/Plug-ins"

     

       106
       106
       -
                 test -d "$PLUGINDIR" || {

     

       107
       107
       -
                   mkdir -p "$PLUGINDIR";

     

       108
       108
       -
                   chown ${cfg.user}:${cfg.group} "$PLUGINDIR";

     

       109
       109
       -
                 }

     

       110
       110
       -
       

     

       111
       111
       -
                 echo "Removing old symlinks."

     

       112
       112
       -
                 # First, remove all of the symlinks in the directory.

     

       113
       113
       -
                 for f in `ls "$PLUGINDIR/"`; do

     

       114
       114
       -
                   if [[ -L "$PLUGINDIR/$f" ]]; then

     

       115
       115
       -
                     echo "Removing plugin symlink $PLUGINDIR/$f."

     

       116
       116
       -
                     rm "$PLUGINDIR/$f"

     

       117
       117
       -
                   fi

     

       118
       118
       -
                 done

     

       119
       119
       -
       

     

       120
       120
       -
                 echo "Symlinking plugins."

     

       121
       121
       -
                 for path in ${toString cfg.extraPlugins}; do

     

       122
       122
       -
                   dest="$PLUGINDIR/$(basename $path)"

     

       123
       123
       -
                   if [[ ! -d "$path" ]]; then

     

       124
       124
       -
                     echo "Error symlinking plugin from $path: no such directory."

     

       125
       125
       -
                   elif [[ -d "$dest" || -L "$dest" ]]; then

     

       126
       126
       -
                     echo "Error symlinking plugin from $path to $dest: file or directory already exists."

     

       127
       127
       -
                   else

     

       128
       128
       -
                     echo "Symlinking plugin at $path..."

     

       129
       129
       -
                     ln -s "$path" "$dest"

     

       130
       130
       -
                   fi

     

       131
       131
       -
                 done

     

       132
       132
       -
               ''}

     

       133
       133
       -
            '';

     

       134
       87
        
             serviceConfig = {

     

       135
       88
        
               Type = "simple";

     

       136
       89
        
               User = cfg.user;

     

       137
       90
        
               Group = cfg.group;

     

       138
       138
       -
               PermissionsStartOnly = "true";

     

       139
       139
       -
               ExecStart = "\"${cfg.package}/usr/lib/plexmediaserver/Plex Media Server\"";

     

       91
       91
       +
       

     

       92
       92
       +
               # Run the pre-start script with full permissions (the "!" prefix) so it

     

       93
       93
       +
               # can create the data directory if necessary.

     

       94
       94
       +
               ExecStartPre = let

     

       95
       95
       +
                 preStartScript = pkgs.writeScript "plex-run-prestart" ''

     

       96
       96
       +
                   #!${pkgs.bash}/bin/bash

     

       97
       97
       +
       

     

       98
       98
       +
                   # Create data directory if it doesn't exist

     

       99
       99
       +
                   if ! test -d "$PLEX_DATADIR"; then

     

       100
       100
       +
                     echo "Creating initial Plex data directory in: $PLEX_DATADIR"

     

       101
       101
       +
                     install -d -m 0755 -o "${cfg.user}" -g "${cfg.group}" "$PLEX_DATADIR"

     

       102
       102
       +
                   fi

     

       103
       103
       +
                '';

     

       104
       104
       +
               in

     

       105
       105
       +
                 "!${preStartScript}";

     

       106
       106
       +
       

     

       107
       107
       +
               ExecStart = "${cfg.package}/bin/plexmediaserver";

     

       140
       108
        
               KillSignal = "SIGQUIT";

     

       141
       109
        
               Restart = "on-failure";

     

       142
       110
        
             };

     

       111
       111
       +
       

     

       143
       112
        
             environment = {

     

       144
       144
       -
               PLEX_MEDIA_SERVER_APPLICATION_SUPPORT_DIR=cfg.dataDir;

     

       145
       145
       -
               PLEX_MEDIA_SERVER_HOME="${cfg.package}/usr/lib/plexmediaserver";

     

       113
       113
       +
               # Configuration for our FHS userenv script

     

       114
       114
       +
               PLEX_DATADIR=cfg.dataDir;

     

       115
       115
       +
               PLEX_PLUGINS=concatMapStringsSep ":" builtins.toString cfg.extraPlugins;

     

       116
       116
       +
       

     

       117
       117
       +
               # The following variables should be set by the FHS userenv script:

     

       118
       118
       +
               #   PLEX_MEDIA_SERVER_APPLICATION_SUPPORT_DIR

     

       119
       119
       +
               #   PLEX_MEDIA_SERVER_HOME

     

       120
       120
       +
       

     

       121
       121
       +
               # Allow access to GPU acceleration; the Plex LD_LIBRARY_PATH is added

     

       122
       122
       +
               # by the FHS userenv script.

     

       123
       123
       +
               LD_LIBRARY_PATH="/run/opengl-driver/lib";

     

       124
       124
       +
       

     

       146
       125
        
               PLEX_MEDIA_SERVER_MAX_PLUGIN_PROCS="6";

     

       147
       126
        
               PLEX_MEDIA_SERVER_TMPDIR="/tmp";

     

       148
       127
        
               PLEX_MEDIA_SERVER_USE_SYSLOG="true";

     

       149
       149
       -
               LD_LIBRARY_PATH="/run/opengl-driver/lib:${cfg.package}/usr/lib/plexmediaserver/lib";

     

       150
       128
        
               LC_ALL="en_US.UTF-8";

     

       151
       129
        
               LANG="en_US.UTF-8";

     

       152
       130
        
             };

+312

nixos/modules/services/networking/wg-quick.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       let

     

       5
       5
       +
         cfg = config.networking.wg-quick;

     

       6
       6
       +
       

     

       7
       7
       +
         kernel = config.boot.kernelPackages;

     

       8
       8
       +
       

     

       9
       9
       +
         # interface options

     

       10
       10
       +
       

     

       11
       11
       +
         interfaceOpts = { ... }: {

     

       12
       12
       +
           options = {

     

       13
       13
       +
             address = mkOption {

     

       14
       14
       +
               example = [ "192.168.2.1/24" ];

     

       15
       15
       +
               default = [];

     

       16
       16
       +
               type = with types; listOf str;

     

       17
       17
       +
               description = "The IP addresses of the interface.";

     

       18
       18
       +
             };

     

       19
       19
       +
       

     

       20
       20
       +
             dns = mkOption {

     

       21
       21
       +
               example = [ "192.168.2.2" ];

     

       22
       22
       +
               default = [];

     

       23
       23
       +
               type = with types; listOf str;

     

       24
       24
       +
               description = "The IP addresses of DNS servers to configure.";

     

       25
       25
       +
             };

     

       26
       26
       +
       

     

       27
       27
       +
             privateKey = mkOption {

     

       28
       28
       +
               example = "yAnz5TF+lXXJte14tji3zlMNq+hd2rYUIgJBgB3fBmk=";

     

       29
       29
       +
               type = with types; nullOr str;

     

       30
       30
       +
               default = null;

     

       31
       31
       +
               description = ''

     

       32
       32
       +
                 Base64 private key generated by wg genkey.

     

       33
       33
       +
       

     

       34
       34
       +
                 Warning: Consider using privateKeyFile instead if you do not

     

       35
       35
       +
                 want to store the key in the world-readable Nix store.

     

       36
       36
       +
               '';

     

       37
       37
       +
             };

     

       38
       38
       +
       

     

       39
       39
       +
             privateKeyFile = mkOption {

     

       40
       40
       +
               example = "/private/wireguard_key";

     

       41
       41
       +
               type = with types; nullOr str;

     

       42
       42
       +
               default = null;

     

       43
       43
       +
               description = ''

     

       44
       44
       +
                 Private key file as generated by wg genkey.

     

       45
       45
       +
               '';

     

       46
       46
       +
             };

     

       47
       47
       +
       

     

       48
       48
       +
             listenPort = mkOption {

     

       49
       49
       +
               default = null;

     

       50
       50
       +
               type = with types; nullOr int;

     

       51
       51
       +
               example = 51820;

     

       52
       52
       +
               description = ''

     

       53
       53
       +
                 16-bit port for listening. Optional; if not specified,

     

       54
       54
       +
                 automatically generated based on interface name.

     

       55
       55
       +
               '';

     

       56
       56
       +
             };

     

       57
       57
       +
       

     

       58
       58
       +
             preUp = mkOption {

     

       59
       59
       +
               example = literalExample ''

     

       60
       60
       +
                 ${pkgs.iproute}/bin/ip netns add foo

     

       61
       61
       +
               '';

     

       62
       62
       +
               default = "";

     

       63
       63
       +
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     

       64
       64
       +
               description = ''

     

       65
       65
       +
                 Commands called at the start of the interface setup.

     

       66
       66
       +
               '';

     

       67
       67
       +
             };

     

       68
       68
       +
       

     

       69
       69
       +
             preDown = mkOption {

     

       70
       70
       +
               example = literalExample ''

     

       71
       71
       +
                 ${pkgs.iproute}/bin/ip netns del foo

     

       72
       72
       +
               '';

     

       73
       73
       +
               default = "";

     

       74
       74
       +
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     

       75
       75
       +
               description = ''

     

       76
       76
       +
                 Command called before the interface is taken down.

     

       77
       77
       +
               '';

     

       78
       78
       +
             };

     

       79
       79
       +
       

     

       80
       80
       +
             postUp = mkOption {

     

       81
       81
       +
               example = literalExample ''

     

       82
       82
       +
                 ${pkgs.iproute}/bin/ip netns add foo

     

       83
       83
       +
               '';

     

       84
       84
       +
               default = "";

     

       85
       85
       +
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     

       86
       86
       +
               description = ''

     

       87
       87
       +
                 Commands called after the interface setup.

     

       88
       88
       +
               '';

     

       89
       89
       +
             };

     

       90
       90
       +
       

     

       91
       91
       +
             postDown = mkOption {

     

       92
       92
       +
               example = literalExample ''

     

       93
       93
       +
                 ${pkgs.iproute}/bin/ip netns del foo

     

       94
       94
       +
               '';

     

       95
       95
       +
               default = "";

     

       96
       96
       +
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     

       97
       97
       +
               description = ''

     

       98
       98
       +
                 Command called after the interface is taken down.

     

       99
       99
       +
               '';

     

       100
       100
       +
             };

     

       101
       101
       +
       

     

       102
       102
       +
             table = mkOption {

     

       103
       103
       +
               example = "main";

     

       104
       104
       +
               default = null;

     

       105
       105
       +
               type = with types; nullOr str;

     

       106
       106
       +
               description = ''

     

       107
       107
       +
                 The kernel routing table to add this interface's

     

       108
       108
       +
                 associated routes to. Setting this is useful for e.g. policy routing

     

       109
       109
       +
                 ("ip rule") or virtual routing and forwarding ("ip vrf"). Both numeric

     

       110
       110
       +
                 table IDs and table names (/etc/rt_tables) can be used. Defaults to

     

       111
       111
       +
                 "main".

     

       112
       112
       +
               '';

     

       113
       113
       +
             };

     

       114
       114
       +
       

     

       115
       115
       +
             mtu = mkOption {

     

       116
       116
       +
               example = 1248;

     

       117
       117
       +
               default = null;

     

       118
       118
       +
               type = with types; nullOr int;

     

       119
       119
       +
               description = ''

     

       120
       120
       +
                 If not specified, the MTU is automatically determined

     

       121
       121
       +
                 from the endpoint addresses or the system default route, which is usually

     

       122
       122
       +
                 a sane choice. However, to manually specify an MTU to override this

     

       123
       123
       +
                 automatic discovery, this value may be specified explicitly.

     

       124
       124
       +
               '';

     

       125
       125
       +
             };

     

       126
       126
       +
       

     

       127
       127
       +
             peers = mkOption {

     

       128
       128
       +
               default = [];

     

       129
       129
       +
               description = "Peers linked to the interface.";

     

       130
       130
       +
               type = with types; listOf (submodule peerOpts);

     

       131
       131
       +
             };

     

       132
       132
       +
           };

     

       133
       133
       +
         };

     

       134
       134
       +
       

     

       135
       135
       +
         # peer options

     

       136
       136
       +
       

     

       137
       137
       +
         peerOpts = {

     

       138
       138
       +
           options = {

     

       139
       139
       +
             publicKey = mkOption {

     

       140
       140
       +
               example = "xTIBA5rboUvnH4htodjb6e697QjLERt1NAB4mZqp8Dg=";

     

       141
       141
       +
               type = types.str;

     

       142
       142
       +
               description = "The base64 public key the peer.";

     

       143
       143
       +
             };

     

       144
       144
       +
       

     

       145
       145
       +
             presharedKey = mkOption {

     

       146
       146
       +
               default = null;

     

       147
       147
       +
               example = "rVXs/Ni9tu3oDBLS4hOyAUAa1qTWVA3loR8eL20os3I=";

     

       148
       148
       +
               type = with types; nullOr str;

     

       149
       149
       +
               description = ''

     

       150
       150
       +
                 Base64 preshared key generated by wg genpsk. Optional,

     

       151
       151
       +
                 and may be omitted. This option adds an additional layer of

     

       152
       152
       +
                 symmetric-key cryptography to be mixed into the already existing

     

       153
       153
       +
                 public-key cryptography, for post-quantum resistance.

     

       154
       154
       +
       

     

       155
       155
       +
                 Warning: Consider using presharedKeyFile instead if you do not

     

       156
       156
       +
                 want to store the key in the world-readable Nix store.

     

       157
       157
       +
               '';

     

       158
       158
       +
             };

     

       159
       159
       +
       

     

       160
       160
       +
             presharedKeyFile = mkOption {

     

       161
       161
       +
               default = null;

     

       162
       162
       +
               example = "/private/wireguard_psk";

     

       163
       163
       +
               type = with types; nullOr str;

     

       164
       164
       +
               description = ''

     

       165
       165
       +
                 File pointing to preshared key as generated by wg pensk. Optional,

     

       166
       166
       +
                 and may be omitted. This option adds an additional layer of

     

       167
       167
       +
                 symmetric-key cryptography to be mixed into the already existing

     

       168
       168
       +
                 public-key cryptography, for post-quantum resistance.

     

       169
       169
       +
               '';

     

       170
       170
       +
             };

     

       171
       171
       +
       

     

       172
       172
       +
             allowedIPs = mkOption {

     

       173
       173
       +
               example = [ "10.192.122.3/32" "10.192.124.1/24" ];

     

       174
       174
       +
               type = with types; listOf str;

     

       175
       175
       +
               description = ''List of IP (v4 or v6) addresses with CIDR masks from

     

       176
       176
       +
               which this peer is allowed to send incoming traffic and to which

     

       177
       177
       +
               outgoing traffic for this peer is directed. The catch-all 0.0.0.0/0 may

     

       178
       178
       +
               be specified for matching all IPv4 addresses, and ::/0 may be specified

     

       179
       179
       +
               for matching all IPv6 addresses.'';

     

       180
       180
       +
             };

     

       181
       181
       +
       

     

       182
       182
       +
             endpoint = mkOption {

     

       183
       183
       +
               default = null;

     

       184
       184
       +
               example = "demo.wireguard.io:12913";

     

       185
       185
       +
               type = with types; nullOr str;

     

       186
       186
       +
               description = ''Endpoint IP or hostname of the peer, followed by a colon,

     

       187
       187
       +
               and then a port number of the peer.'';

     

       188
       188
       +
             };

     

       189
       189
       +
       

     

       190
       190
       +
             persistentKeepalive = mkOption {

     

       191
       191
       +
               default = null;

     

       192
       192
       +
               type = with types; nullOr int;

     

       193
       193
       +
               example = 25;

     

       194
       194
       +
               description = ''This is optional and is by default off, because most

     

       195
       195
       +
               users will not need it. It represents, in seconds, between 1 and 65535

     

       196
       196
       +
               inclusive, how often to send an authenticated empty packet to the peer,

     

       197
       197
       +
               for the purpose of keeping a stateful firewall or NAT mapping valid

     

       198
       198
       +
               persistently. For example, if the interface very rarely sends traffic,

     

       199
       199
       +
               but it might at anytime receive traffic from a peer, and it is behind

     

       200
       200
       +
               NAT, the interface might benefit from having a persistent keepalive

     

       201
       201
       +
               interval of 25 seconds; however, most users will not need this.'';

     

       202
       202
       +
             };

     

       203
       203
       +
           };

     

       204
       204
       +
         };

     

       205
       205
       +
       

     

       206
       206
       +
         writeScriptFile = name: text: ((pkgs.writeShellScriptBin name text) + "/bin/${name}");

     

       207
       207
       +
       

     

       208
       208
       +
         generateUnit = name: values:

     

       209
       209
       +
           assert assertMsg ((values.privateKey != null) != (values.privateKeyFile != null)) "Only one of privateKey or privateKeyFile may be set";

     

       210
       210
       +
           let

     

       211
       211
       +
             preUpFile = if values.preUp != "" then writeScriptFile "preUp.sh" values.preUp else null;

     

       212
       212
       +
             postUp =

     

       213
       213
       +
                   optional (values.privateKeyFile != null) "wg set ${name} private-key <(cat ${values.privateKeyFile})" ++

     

       214
       214
       +
                   (concatMap (peer: optional (peer.presharedKeyFile != null) "wg set ${name} peer ${peer.publicKey} preshared-key <(cat ${peer.presharedKeyFile})") values.peers) ++

     

       215
       215
       +
                   optional (values.postUp != null) values.postUp;

     

       216
       216
       +
             postUpFile = if postUp != [] then writeScriptFile "postUp.sh" (concatMapStringsSep "\n" (line: line) postUp) else null;

     

       217
       217
       +
             preDownFile = if values.preDown != "" then writeScriptFile "preDown.sh" values.preDown else null;

     

       218
       218
       +
             postDownFile = if values.postDown != "" then writeScriptFile "postDown.sh" values.postDown else null;

     

       219
       219
       +
             configDir = pkgs.writeTextFile {

     

       220
       220
       +
               name = "config-${name}";

     

       221
       221
       +
               executable = false;

     

       222
       222
       +
               destination = "/${name}.conf";

     

       223
       223
       +
               text =

     

       224
       224
       +
               ''

     

       225
       225
       +
               [interface]

     

       226
       226
       +
               ${concatMapStringsSep "\n" (address:

     

       227
       227
       +
                 "Address = ${address}"

     

       228
       228
       +
               ) values.address}

     

       229
       229
       +
               ${concatMapStringsSep "\n" (dns:

     

       230
       230
       +
                 "DNS = ${dns}"

     

       231
       231
       +
               ) values.dns}

     

       232
       232
       +
               '' +

     

       233
       233
       +
               optionalString (values.table != null) "Table = ${values.table}\n" +

     

       234
       234
       +
               optionalString (values.mtu != null) "MTU = ${toString values.mtu}\n" +

     

       235
       235
       +
               optionalString (values.privateKey != null) "PrivateKey = ${values.privateKey}\n" +

     

       236
       236
       +
               optionalString (values.listenPort != null) "ListenPort = ${toString values.listenPort}\n" +

     

       237
       237
       +
               optionalString (preUpFile != null) "PreUp = ${preUpFile}\n" +

     

       238
       238
       +
               optionalString (postUpFile != null) "PostUp = ${postUpFile}\n" +

     

       239
       239
       +
               optionalString (preDownFile != null) "PreDown = ${preDownFile}\n" +

     

       240
       240
       +
               optionalString (postDownFile != null) "PostDown = ${postDownFile}\n" +

     

       241
       241
       +
               concatMapStringsSep "\n" (peer:

     

       242
       242
       +
                 assert assertMsg (!((peer.presharedKeyFile != null) && (peer.presharedKey != null))) "Only one of presharedKey or presharedKeyFile may be set";

     

       243
       243
       +
                 "[Peer]\n" +

     

       244
       244
       +
                 "PublicKey = ${peer.publicKey}\n" +

     

       245
       245
       +
                 optionalString (peer.presharedKey != null) "PresharedKey = ${peer.presharedKey}\n" +

     

       246
       246
       +
                 optionalString (peer.endpoint != null) "Endpoint = ${peer.endpoint}\n" +

     

       247
       247
       +
                 optionalString (peer.persistentKeepalive != null) "PersistentKeepalive = ${toString peer.persistentKeepalive}\n" +

     

       248
       248
       +
                 optionalString (peer.allowedIPs != []) "AllowedIPs = ${concatStringsSep "," peer.allowedIPs}\n"

     

       249
       249
       +
               ) values.peers;

     

       250
       250
       +
             };

     

       251
       251
       +
             configPath = "${configDir}/${name}.conf";

     

       252
       252
       +
           in

     

       253
       253
       +
           nameValuePair "wg-quick-${name}"

     

       254
       254
       +
             {

     

       255
       255
       +
               description = "wg-quick WireGuard Tunnel - ${name}";

     

       256
       256
       +
               requires = [ "network-online.target" ];

     

       257
       257
       +
               after = [ "network.target" "network-online.target" ];

     

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

     

       259
       259
       +
               environment.DEVICE = name;

     

       260
       260
       +
               path = [ pkgs.kmod pkgs.wireguard-tools ];

     

       261
       261
       +
       

     

       262
       262
       +
               serviceConfig = {

     

       263
       263
       +
                 Type = "oneshot";

     

       264
       264
       +
                 RemainAfterExit = true;

     

       265
       265
       +
               };

     

       266
       266
       +
       

     

       267
       267
       +
               script = ''

     

       268
       268
       +
                 ${optionalString (!config.boot.isContainer) "modprobe wireguard"}

     

       269
       269
       +
                 wg-quick up ${configPath}

     

       270
       270
       +
               '';

     

       271
       271
       +
       

     

       272
       272
       +
               preStop = ''

     

       273
       273
       +
                 wg-quick down ${configPath}

     

       274
       274
       +
               '';

     

       275
       275
       +
             };

     

       276
       276
       +
       in {

     

       277
       277
       +
       

     

       278
       278
       +
         ###### interface

     

       279
       279
       +
       

     

       280
       280
       +
         options = {

     

       281
       281
       +
           networking.wg-quick = {

     

       282
       282
       +
             interfaces = mkOption {

     

       283
       283
       +
               description = "Wireguard interfaces.";

     

       284
       284
       +
               default = {};

     

       285
       285
       +
               example = {

     

       286
       286
       +
                 wg0 = {

     

       287
       287
       +
                   address = [ "192.168.20.4/24" ];

     

       288
       288
       +
                   privateKey = "yAnz5TF+lXXJte14tji3zlMNq+hd2rYUIgJBgB3fBmk=";

     

       289
       289
       +
                   peers = [

     

       290
       290
       +
                     { allowedIPs = [ "192.168.20.1/32" ];

     

       291
       291
       +
                       publicKey  = "xTIBA5rboUvnH4htodjb6e697QjLERt1NAB4mZqp8Dg=";

     

       292
       292
       +
                       endpoint   = "demo.wireguard.io:12913"; }

     

       293
       293
       +
                   ];

     

       294
       294
       +
                 };

     

       295
       295
       +
               };

     

       296
       296
       +
               type = with types; attrsOf (submodule interfaceOpts);

     

       297
       297
       +
             };

     

       298
       298
       +
           };

     

       299
       299
       +
         };

     

       300
       300
       +
       

     

       301
       301
       +
       

     

       302
       302
       +
         ###### implementation

     

       303
       303
       +
       

     

       304
       304
       +
         config = mkIf (cfg.interfaces != {}) {

     

       305
       305
       +
           boot.extraModulePackages = [ kernel.wireguard ];

     

       306
       306
       +
           environment.systemPackages = [ pkgs.wireguard-tools ];

     

       307
       307
       +
           # This is forced to false for now because the default "--validmark" rpfilter we apply on reverse path filtering

     

       308
       308
       +
           # breaks the wg-quick routing because wireguard packets leave with a fwmark from wireguard.

     

       309
       309
       +
           networking.firewall.checkReversePath = false;

     

       310
       310
       +
           systemd.services = mapAttrs' generateUnit cfg.interfaces;

     

       311
       311
       +
         };

     

       312
       312
       +
       }

nixos/tests/all-tests.nix

···

       182
       182
        
         osrm-backend = handleTest ./osrm-backend.nix {};

     

       183
       183
        
         ostree = handleTest ./ostree.nix {};

     

       184
       184
        
         overlayfs = handleTest ./overlayfs.nix {};

     

       185
       185
       +
         packagekit = handleTest ./packagekit.nix {};

     

       185
       186
        
         pam-oath-login = handleTest ./pam-oath-login.nix {};

     

       186
       187
        
         pam-u2f = handleTest ./pam-u2f.nix {};

     

       187
       188
        
         pantheon = handleTest ./pantheon.nix {};

+24

nixos/tests/packagekit.nix

···

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

     

       2
       2
       +
         name = "packagekit";

     

       3
       3
       +
         meta = with pkgs.stdenv.lib.maintainers; {

     

       4
       4
       +
           maintainers = [ peterhoeg ];

     

       5
       5
       +
         };

     

       6
       6
       +
       

     

       7
       7
       +
         machine = { ... }: {

     

       8
       8
       +
           environment.systemPackages = with pkgs; [ dbus ];

     

       9
       9
       +
           services.packagekit = {

     

       10
       10
       +
             enable = true;

     

       11
       11
       +
             backend = "test_nop";

     

       12
       12
       +
           };

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         testScript = ''

     

       16
       16
       +
           startAll;

     

       17
       17
       +
       

     

       18
       18
       +
           # send a dbus message to activate the service

     

       19
       19
       +
           $machine->succeed("dbus-send --system --type=method_call --print-reply --dest=org.freedesktop.PackageKit /org/freedesktop/PackageKit org.freedesktop.DBus.Introspectable.Introspect");

     

       20
       20
       +
       

     

       21
       21
       +
           # so now it should be running

     

       22
       22
       +
           $machine->succeed("systemctl is-active packagekit.service");

     

       23
       23
       +
         '';

     

       24
       24
       +
       })

+29 -11

pkgs/applications/audio/lollypop/default.nix

···

       1
       1
       -
       { stdenv, fetchgit, meson, ninja, pkgconfig

     

       2
       2
       -
       , python3, gtk3, gst_all_1, libsecret, libsoup

     

       3
       3
       -
       , appstream-glib, desktop-file-utils, totem-pl-parser

     

       4
       4
       -
       , hicolor-icon-theme, gobject-introspection, wrapGAppsHook }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , fetchgit

     

       3
       3
       +
       , meson

     

       4
       4
       +
       , ninja

     

       5
       5
       +
       , pkgconfig

     

       6
       6
       +
       , python3

     

       7
       7
       +
       , gtk3

     

       8
       8
       +
       , gst_all_1

     

       9
       9
       +
       , libsecret

     

       10
       10
       +
       , libsoup

     

       11
       11
       +
       , appstream-glib

     

       12
       12
       +
       , desktop-file-utils

     

       13
       13
       +
       , totem-pl-parser

     

       14
       14
       +
       , hicolor-icon-theme

     

       15
       15
       +
       , gobject-introspection

     

       16
       16
       +
       , wrapGAppsHook

     

       17
       17
       +
       , lastFMSupport ? true

     

       18
       18
       +
       , wikipediaSupport ? true

     

       19
       19
       +
       , youtubeSupport ? true, youtube-dl

     

       20
       20
       +
       }:

     

       5
       21
        
       

     

       6
       22
        
       python3.pkgs.buildPythonApplication rec  {

     

       7
       23
        
         pname = "lollypop";

     

       8
       8
       -
         version = "1.0.5";

     

       24
       24
       +
         version = "1.0.7";

     

       9
       25
        
       

     

       10
       26
        
         format = "other";

     

       11
       27
        
         doCheck = false;

     
···

       14
       30
        
           url = "https://gitlab.gnome.org/World/lollypop";

     

       15
       31
        
           rev = "refs/tags/${version}";

     

       16
       32
        
           fetchSubmodules = true;

     

       17
       17
       -
           sha256 = "1p6glzvbbha3cvq462ymbn1q58skclfk469kk28cr1hlsf5x2pry";

     

       33
       33
       +
           sha256 = "0gdds4qssn32axsa5janqny5i4426azj5wyj6bzn026zs3z38svn";

     

       18
       34
        
         };

     

       19
       35
        
       

     

       20
       36
        
         nativeBuildInputs = [

     
···

       37
       53
        
           gstreamer

     

       38
       54
        
           gtk3

     

       39
       55
        
           hicolor-icon-theme

     

       40
       40
       -
           libsecret

     

       41
       56
        
           libsoup

     

       42
       57
        
           totem-pl-parser

     

       43
       43
       -
         ];

     

       58
       58
       +
         ] ++ lib.optional lastFMSupport libsecret;

     

       44
       59
        
       

     

       45
       60
        
         propagatedBuildInputs = with python3.pkgs; [

     

       46
       61
        
           beautifulsoup4

     
···

       49
       64
        
           pycairo

     

       50
       65
        
           pydbus

     

       51
       66
        
           pygobject3

     

       52
       52
       -
           pylast

     

       53
       53
       -
         ];

     

       67
       67
       +
         ]

     

       68
       68
       +
         ++ lib.optional lastFMSupport pylast

     

       69
       69
       +
         ++ lib.optional wikipediaSupport wikipedia

     

       70
       70
       +
         ++ lib.optional youtubeSupport youtube-dl

     

       71
       71
       +
         ;

     

       54
       72
        
       

     

       55
       73
        
         postPatch = ''

     

       56
       74
        
           chmod +x meson_post_install.py

     
···

       62
       80
        
           patchPythonScript "$out/libexec/lollypop-sp"

     

       63
       81
        
         '';

     

       64
       82
        
       

     

       65
       65
       -
         meta = with stdenv.lib; {

     

       83
       83
       +
         meta = with lib; {

     

       66
       84
        
           description = "A modern music player for GNOME";

     

       67
       85
        
           homepage = https://wiki.gnome.org/Apps/Lollypop;

     

       68
       86
        
           license = licenses.gpl3Plus;

+2 -2

pkgs/applications/audio/padthv1/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "padthv1-${version}";

     

       5
       5
       -
         version = "0.9.5";

     

       5
       5
       +
         version = "0.9.6";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "mirror://sourceforge/padthv1/${name}.tar.gz";

     

       9
       9
       -
           sha256 = "0cd1jfb3ynfrsbz8jwfsbvs5liyddxg4zghrvz931qkkqi117hbh";

     

       9
       9
       +
           sha256 = "0ddvlpjlg6zr9ckanqhisw0sgm8rxibvj1aj5dxzs9xb2wlwd8rr";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         buildInputs = [ libjack2 alsaLib libsndfile liblo lv2 qt5.qtbase qt5.qttools fftw ];

+3 -3

pkgs/applications/editors/android-studio/default.nix

···

       14
       14
        
         };

     

       15
       15
        
         betaVersion = stableVersion;

     

       16
       16
        
         latestVersion = { # canary & dev

     

       17
       17
       -
           version = "3.5.0.11"; # "Android Studio 3.5 Canary 12"

     

       18
       18
       -
           build = "191.5471097";

     

       19
       19
       -
           sha256Hash = "1dz9iy8f12fzqp8wv9c5v01d33djy97aha8rxxp18vi6myak42ca";

     

       17
       17
       +
           version = "3.5.0.12"; # "Android Studio 3.5 Canary 13"

     

       18
       18
       +
           build = "191.5487692";

     

       19
       19
       +
           sha256Hash = "0iwd2qa551rs9b0w4rs7wmzdbh3r4j76xvs815l6i5pilk0s47gz";

     

       20
       20
        
         };

     

       21
       21
        
       in rec {

     

       22
       22
        
         # Attributes are named by their corresponding release channels

+2 -2

pkgs/applications/gis/qgis/unwrapped.nix

···

       10
       10
        
           [ qscintilla-qt5 gdal jinja2 numpy psycopg2

     

       11
       11
        
             chardet dateutil pyyaml pytz requests urllib3 pygments pyqt5 sip owslib six ];

     

       12
       12
        
       in stdenv.mkDerivation rec {

     

       13
       13
       -
         version = "3.4.6";

     

       13
       13
       +
         version = "3.4.7";

     

       14
       14
        
         name = "qgis-unwrapped-${version}";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchurl {

     

       17
       17
        
           url = "http://qgis.org/downloads/qgis-${version}.tar.bz2";

     

       18
       18
       -
           sha256 = "1skdimcbcv41hi4ii7iq8ka29k2zizzqv04fwidzfbxqclz7300h";

     

       18
       18
       +
           sha256 = "15w2cb5ac0n3g3jbnbk6qyqs7kx3y64zbyvcsw09p0dn9rnw4hdr";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         passthru = {

+4 -3

pkgs/applications/graphics/epeg/default.nix

···

       3
       3
        
       }:

     

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
       -
         name = "epeg-0.9.1.042"; # version taken from configure.ac

     

       6
       6
       +
         pname = "epeg";

     

       7
       7
       +
         version = "0.9.2";

     

       7
       8
        
       

     

       8
       9
        
         src = fetchFromGitHub {

     

       9
       10
        
           owner = "mattes";

     

       10
       11
        
           repo = "epeg";

     

       11
       11
       -
           rev = "248ae9fc3f1d6d06e6062a1f7bf5df77d4f7de9b";

     

       12
       12
       -
           sha256 = "14ad33w3pxrg2yfc2xzyvwyvjirwy2d00889dswisq8b84cmxfia";

     

       12
       12
       +
           rev = "v${version}";

     

       13
       13
       +
           sha256 = "14bjl9v6zzac4df25gm3bkw3n0mza5iazazsi65gg3m6661x6c5g";

     

       13
       14
        
         };

     

       14
       15
        
       

     

       15
       16
        
         enableParallelBuilding = true;

+3 -43

pkgs/applications/graphics/freecad/default.nix

···

       9
       9
        
         pythonPackages = python27Packages;

     

       10
       10
        
       in stdenv.mkDerivation rec {

     

       11
       11
        
         name = "freecad-${version}";

     

       12
       12
       -
         version = "0.17";

     

       12
       12
       +
         version = "0.18.1";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           url = "https://github.com/FreeCAD/FreeCAD/archive/${version}.tar.gz";

     

       16
       16
       -
           sha256 = "1yv6abdzlpn4wxy315943xwrnbywxqfgkjib37qwfvbb8y9p60df";

     

       16
       16
       +
           sha256 = "0lamrs84zv99v4z7yi6d9amjmnh7r6frairc2aajgfic380720bc";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         buildInputs = [ cmake coin3d xercesc ode eigen qt4 opencascade gts

     
···

       21
       21
        
         ] ++ (with pythonPackages; [

     

       22
       22
        
           matplotlib pycollada pyside pysideShiboken pysideTools pivy python boost

     

       23
       23
        
         ]);

     

       24
       24
       -
       

     

       25
       25
       -
         patches = [

     

       26
       26
       -
           # Fix for finding boost_python. Boost >= 1.67.0 appends the Python version.

     

       27
       27
       -
           (fetchpatch {

     

       28
       28
       -
             url = https://github.com/FreeCAD/FreeCAD/commit/3c9e6b038ed544e446c61695dab62f83e781a28a.patch;

     

       29
       29
       -
             sha256 = "0f09qywzn0y41hylizb5g8jy74fi53iqmvqr5zznaz16wpw4hqbp";

     

       30
       30
       -
           })

     

       31
       31
       -
         ];

     

       32
       24
        
       

     

       33
       25
        
         enableParallelBuilding = true;

     

       34
       26
        
       

     
···

       45
       37
        
         postInstall = ''

     

       46
       38
        
           wrapProgram $out/bin/FreeCAD --prefix PYTHONPATH : $PYTHONPATH \

     

       47
       39
        
             --set COIN_GL_NO_CURRENT_CONTEXT_CHECK 1

     

       48
       48
       -
       

     

       49
       49
       -
           mkdir -p $out/share/mime/packages

     

       50
       50
       -
           cat << EOF > $out/share/mime/packages/freecad.xml

     

       51
       51
       -
           <?xml version="1.0" encoding="UTF-8"?>

     

       52
       52
       -
           <mime-info xmlns='http://www.freedesktop.org/standards/shared-mime-info'>

     

       53
       53
       -
             <mime-type type="application/x-extension-fcstd">

     

       54
       54
       -
               <sub-class-of type="application/zip"/>

     

       55
       55
       -
               <comment>FreeCAD Document</comment>

     

       56
       56
       -
               <glob pattern="*.fcstd"/>

     

       57
       57
       -
             </mime-type>

     

       58
       58
       -
           </mime-info>

     

       59
       59
       -
           EOF

     

       60
       60
       -
       

     

       61
       61
       -
           mkdir -p $out/share/applications

     

       62
       62
       -
           cp $desktopItem/share/applications/* $out/share/applications/

     

       63
       63
       -
           for entry in $out/share/applications/*.desktop; do

     

       64
       64
       -
             substituteAllInPlace $entry

     

       65
       65
       -
           done

     

       66
       40
        
         '';

     

       67
       67
       -
       

     

       68
       68
       -
         desktopItem = makeDesktopItem {

     

       69
       69
       -
           name = "freecad";

     

       70
       70
       -
           desktopName = "FreeCAD";

     

       71
       71
       -
           genericName = "CAD Application";

     

       72
       72
       -
           comment = meta.description;

     

       73
       73
       -
           exec = "@out@/bin/FreeCAD %F";

     

       74
       74
       -
           categories = "Science;Education;Engineering;";

     

       75
       75
       -
           startupNotify = "true";

     

       76
       76
       -
           mimeType = "application/x-extension-fcstd;";

     

       77
       77
       -
           extraEntries = ''

     

       78
       78
       -
             Path=@out@/share/freecad

     

       79
       79
       -
           '';

     

       80
       80
       -
         };

     

       81
       81
       -
       

     

       41
       41
       +
           

     

       82
       42
        
         meta = with stdenv.lib; {

     

       83
       43
        
           description = "General purpose Open Source 3D CAD/MCAD/CAx/CAE/PLM modeler";

     

       84
       44
        
           homepage = https://www.freecadweb.org/;

+1 -1

pkgs/applications/graphics/goxel/default.nix

···

       32
       32
        
           description = "Open Source 3D voxel editor";

     

       33
       33
        
           homepage = https://guillaumechereau.github.io/goxel/;

     

       34
       34
        
           license = licenses.gpl3;

     

       35
       35
       -
           platforms = [ "x86_64-linux" ]; # see https://github.com/guillaumechereau/goxel/issues/125

     

       35
       35
       +
           platforms = platforms.linux;

     

       36
       36
        
           maintainers = with maintainers; [ tilpner ];

     

       37
       37
        
         };

     

       38
       38
        
       }

+2 -8

pkgs/applications/misc/guake/default.nix

···

       2
       2
        
       , gtk3, keybinder3, libnotify, libutempter, vte }:

     

       3
       3
        
       

     

       4
       4
        
       let

     

       5
       5
       -
         version = "3.4.0";

     

       5
       5
       +
         version = "3.5.0";

     

       6
       6
        
       in python3.pkgs.buildPythonApplication rec {

     

       7
       7
        
         name = "guake-${version}";

     

       8
       8
        
         format = "other";

     
···

       11
       11
        
           owner = "Guake";

     

       12
       12
        
           repo = "guake";

     

       13
       13
        
           rev = version;

     

       14
       14
       -
           sha256 = "1j38z968ha8ij6wrgbwvr8ad930nvhybm9g7pf4s4zv6d3vln0vm";

     

       14
       14
       +
           sha256 = "0fz0gciw5fpxrp6yyji27l7q8c0r9ljsq6vw584mr70bcl1gzjqx";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         # Strict deps breaks guake

     
···

       28
       28
        
         LC_ALL = "en_US.UTF-8"; # fixes weird encoding error, see https://github.com/NixOS/nixpkgs/pull/38642#issuecomment-379727699

     

       29
       29
        
       

     

       30
       30
        
         PBR_VERSION = version; # pbr needs either .git directory, sdist, or env var

     

       31
       31
       -
       

     

       32
       32
       -
         postPatch = ''

     

       33
       33
       -
           # unnecessary /usr/bin/env in Makefile

     

       34
       34
       -
           # https://github.com/Guake/guake/pull/1285

     

       35
       35
       -
           substituteInPlace "Makefile" --replace "/usr/bin/env python3" "python3"

     

       36
       36
       -
         '';

     

       37
       31
        
       

     

       38
       32
        
         makeFlags = [

     

       39
       33
        
           "prefix=$(out)"

+2 -2

pkgs/applications/misc/hugo/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         name = "hugo-${version}";

     

       5
       5
       -
         version = "0.55.3";

     

       5
       5
       +
         version = "0.55.4";

     

       6
       6
        
       

     

       7
       7
        
         goPackagePath = "github.com/gohugoio/hugo";

     

       8
       8
        
       

     
···

       10
       10
        
           owner  = "gohugoio";

     

       11
       11
        
           repo   = "hugo";

     

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

     

       13
       13
       -
           sha256 = "0hpyaxfjgfm04fcw3qha2rdx93fr326mw5aiw95vnj5i0x1xbs3x";

     

       13
       13
       +
           sha256 = "0hbkl8dhhdic0admrkvlp1h1bmfrrwfnvipx27clyk0f88jcvb7y";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         modSha256 = "0yrwkaaasj9ihjjfbywnzkppix1y2znagg3dkyikk21sl5n0nz23";

+13 -18

pkgs/applications/misc/joplin-desktop/default.nix

···

       1
       1
       -
       { stdenv, appimage-run, fetchurl, gsettings-desktop-schemas, gtk3, gobject-introspection, wrapGAppsHook }:

     

       1
       1
       +
       { appimageTools, fetchurl, lib, gsettings-desktop-schemas, gtk3 }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       +
         pname = "joplin-desktop";

     

       4
       5
        
         version = "1.0.143";

     

       5
       5
       -
         sha256 = "1waglwxpr18a07m7ix9al6ac4hrdqzzqmy1qgp45b922nbkw9g10";

     

       6
       6
       -
       in

     

       7
       7
       -
         stdenv.mkDerivation rec {

     

       8
       8
       -
         name = "joplin-${version}";

     

       9
       9
       -
       

     

       6
       6
       +
       in appimageTools.wrapType2 rec {

     

       7
       7
       +
         name = "${pname}-${version}";

     

       10
       8
        
         src = fetchurl {

     

       11
       9
        
           url = "https://github.com/laurent22/joplin/releases/download/v${version}/Joplin-${version}-x86_64.AppImage";

     

       12
       12
       -
           inherit sha256;

     

       10
       10
       +
           sha256 = "1waglwxpr18a07m7ix9al6ac4hrdqzzqmy1qgp45b922nbkw9g10";

     

       13
       11
        
         };

     

       14
       12
        
       

     

       15
       15
       -
         nativeBuildInputs = [ wrapGAppsHook ];

     

       16
       16
       -
         buildInputs = [ appimage-run gtk3 gsettings-desktop-schemas gobject-introspection ];

     

       17
       13
        
       

     

       18
       18
       -
         unpackPhase = ":";

     

       14
       14
       +
         profile = ''

     

       15
       15
       +
           export LC_ALL=C.UTF-8

     

       16
       16
       +
           export XDG_DATA_DIRS=${gsettings-desktop-schemas}/share/gsettings-schemas/${gsettings-desktop-schemas.name}:${gtk3}/share/gsettings-schemas/${gtk3.name}:$XDG_DATA_DIRS

     

       17
       17
       +
         '';

     

       19
       18
        
       

     

       20
       20
       -
         installPhase = ''

     

       21
       21
       -
           mkdir -p $out/{bin,share}

     

       22
       22
       -
           cp $src $out/share/joplin.AppImage

     

       23
       23
       -
           echo "#!/bin/sh" > $out/bin/joplin-desktop

     

       24
       24
       -
           echo "${appimage-run}/bin/appimage-run $out/share/joplin.AppImage" >> $out/bin/joplin-desktop

     

       25
       25
       -
           chmod +x $out/bin/joplin-desktop $out/share/joplin.AppImage

     

       26
       26
       -
         '';

     

       19
       19
       +
         multiPkgs = null; # no 32bit needed

     

       20
       20
       +
         extraPkgs = appimageTools.defaultFhsEnvArgs.multiPkgs;

     

       21
       21
       +
         extraInstallCommands = "mv $out/bin/{${name},${pname}}";

     

       27
       22
        
       

     

       28
       28
       -
         meta = with stdenv.lib; {

     

       23
       23
       +
         meta = with lib; {

     

       29
       24
        
           description = "An open source note taking and to-do application with synchronisation capabilities";

     

       30
       25
        
           longDescription = ''

     

       31
       26
        
             Joplin is a free, open source note taking and to-do application, which can

+5 -2

pkgs/applications/misc/librecad/default.nix

···

       18
       18
        
         qmakeFlags = [ "MUPARSER_DIR=${muparser}" "BOOST_DIR=${boost.dev}" ];

     

       19
       19
        
       

     

       20
       20
        
         installPhase = ''

     

       21
       21
       -
           mkdir -p $out/bin $out/share

     

       22
       22
       -
           cp -R unix/librecad $out/bin

     

       21
       21
       +
           install -m 555 -D unix/librecad $out/bin/librecad

     

       22
       22
       +
           install -m 444 -D desktop/librecad.desktop $out/share/applications/librecad.desktop

     

       23
       23
       +
           install -m 444 -D desktop/librecad.sharedmimeinfo $out/share/mime/packages/librecad.xml

     

       24
       24
       +
           install -m 444 -D desktop/graphics_icons_and_splash/Icon\ LibreCAD/Icon_Librecad.svg \

     

       25
       25
       +
             $out/share/icons/hicolor/scalable/apps/librecad.svg

     

       23
       26
        
           cp -R unix/resources $out/share/librecad

     

       24
       27
        
         '';

     

       25
       28

+30

pkgs/applications/misc/notable/default.nix

···

       1
       1
       +
       { appimageTools, fetchurl, lib, gsettings-desktop-schemas, gtk3 }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         pname = "notable";

     

       5
       5
       +
         version = "1.4.0";

     

       6
       6
       +
       in

     

       7
       7
       +
       appimageTools.wrapType2 rec {

     

       8
       8
       +
         name = "${pname}-${version}";

     

       9
       9
       +
         src = fetchurl {

     

       10
       10
       +
           url = "https://github.com/notable/notable/releases/download/v${version}/Notable.${version}.AppImage";

     

       11
       11
       +
           sha256 = "0ldmxnhqcphr92rb7imgb1dfx7bb3p515nrdds8jn4b8x6jgmnjr";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         profile = ''

     

       15
       15
       +
           export LC_ALL=C.UTF-8

     

       16
       16
       +
           export XDG_DATA_DIRS=${gsettings-desktop-schemas}/share/gsettings-schemas/${gsettings-desktop-schemas.name}:${gtk3}/share/gsettings-schemas/${gtk3.name}:$XDG_DATA_DIRS

     

       17
       17
       +
         '';

     

       18
       18
       +
       

     

       19
       19
       +
         multiPkgs = null; # no 32bit needed

     

       20
       20
       +
         extraPkgs = appimageTools.defaultFhsEnvArgs.multiPkgs;

     

       21
       21
       +
         extraInstallCommands = "mv $out/bin/{${name},${pname}}";

     

       22
       22
       +
       

     

       23
       23
       +
         meta = with lib; {

     

       24
       24
       +
           description = "The markdown-based note-taking app that doesn't suck";

     

       25
       25
       +
           homepage = https://github.com/notable/notable;

     

       26
       26
       +
           license = licenses.agpl3;

     

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

     

       28
       28
       +
           maintainers = with maintainers; [ dtzWill ];

     

       29
       29
       +
         };

     

       30
       30
       +
       }

+4 -3

pkgs/applications/misc/orca/default.nix

···

       4
       4
        
       , python, pygobject3, gtk3, gnome3, substituteAll

     

       5
       5
        
       , at-spi2-atk, at-spi2-core, pyatspi, dbus, dbus-python, pyxdg

     

       6
       6
        
       , xkbcomp, procps, lsof, coreutils, gsettings-desktop-schemas

     

       7
       7
       -
       , speechd, brltty, setproctitle, gst_all_1, gst-python

     

       7
       7
       +
       , speechd, brltty, liblouis, setproctitle, gst_all_1, gst-python

     

       8
       8
        
       }:

     

       9
       9
        
       

     

       10
       10
        
       buildPythonApplication rec {

     
···

       34
       34
        
         ];

     

       35
       35
        
       

     

       36
       36
        
         propagatedBuildInputs = [

     

       37
       37
       -
           # TODO: re-add liblouis when it is fixed

     

       38
       38
       -
           pygobject3 pyatspi dbus-python pyxdg brltty speechd gst-python setproctitle

     

       37
       37
       +
           pygobject3 pyatspi dbus-python pyxdg brltty liblouis speechd gst-python setproctitle

     

       39
       38
        
         ];

     

       39
       39
       +
       

     

       40
       40
       +
         strictDeps = false;

     

       40
       41
        
       

     

       41
       42
        
         buildInputs = [

     

       42
       43
        
           python gtk3 at-spi2-atk at-spi2-core dbus gsettings-desktop-schemas

+10 -7

pkgs/applications/misc/pwsafe/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, cmake, pkgconfig, zip, gettext, perl

     

       2
       2
       -
       , wxGTK31, libXi, libXt, libXtst, xercesc, xorgproto

     

       2
       2
       +
       , wxGTK31, libXext, libXi, libXt, libXtst, xercesc

     

       3
       3
        
       , qrencode, libuuid, libyubikey, yubikey-personalization

     

       4
       4
       +
       , curl, openssl

     

       4
       5
        
       }:

     

       5
       6
        
       

     

       6
       7
        
       stdenv.mkDerivation rec {

     

       7
       8
        
         pname = "pwsafe";

     

       8
       8
       -
         version = "1.06";

     

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

     

       9
       9
       +
         version = "1.07";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "${pname}";

     

       13
       13
        
           repo = "${pname}";

     

       14
       14
        
           rev = "${version}BETA";

     

       15
       15
       -
           sha256 = "1q3xi7i4r3nmz3hc79lx8l15sr1nqhwbi3lrnfqr356nv6aaf03y";

     

       15
       15
       +
           sha256 = "0syxmliybgvm9j6d426l7j12ryrl42azy80m66jc56fv9nkqwaya";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         nativeBuildInputs = [ cmake pkgconfig zip ];

     

       18
       18
       +
         nativeBuildInputs = [ 

     

       19
       19
       +
         	cmake gettext perl pkgconfig zip

     

       20
       20
       +
         ];

     

       19
       21
        
         buildInputs = [

     

       20
       20
       -
           gettext perl qrencode libuuid

     

       21
       21
       -
           libXi libXt libXtst wxGTK31 xercesc xorgproto

     

       22
       22
       +
           libXext libXi libXt libXtst wxGTK31

     

       23
       23
       +
           curl qrencode libuuid openssl xercesc

     

       22
       24
        
           libyubikey yubikey-personalization

     

       23
       25
        
         ];

     

       26
       26
       +
       

     

       24
       27
        
         cmakeFlags = [

     

       25
       28
        
           "-DNO_GTEST=ON"

     

       26
       29
        
           "-DCMAKE_CXX_FLAGS=-I${yubikey-personalization}/include/ykpers-1"

+18

pkgs/applications/misc/pydf/default.nix

···

       1
       1
       +
       { stdenv, python3Packages }:

     

       2
       2
       +
       

     

       3
       3
       +
       python3Packages.buildPythonPackage rec {

     

       4
       4
       +
         pname = "pydf";

     

       5
       5
       +
         version = "12";

     

       6
       6
       +
       

     

       7
       7
       +
         src = python3Packages.fetchPypi {

     

       8
       8
       +
           inherit pname version;

     

       9
       9
       +
           sha256 = "7f47a7c3abfceb1ac04fc009ded538df1ae449c31203962a1471a4eb3bf21439";

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         meta = with stdenv.lib; {

     

       13
       13
       +
           description = "colourised df(1)-clone";

     

       14
       14
       +
           homepage = http://kassiopeia.juls.savba.sk/~garabik/software/pydf/;

     

       15
       15
       +
           license = licenses.publicDomain;

     

       16
       16
       +
           maintainers = with maintainers; [ monsieurp ];

     

       17
       17
       +
         };

     

       18
       18
       +
       }

+34

pkgs/applications/misc/taskopen/default.nix

···

       1
       1
       +
       { fetchurl, stdenv, makeWrapper, which, perl, perlPackages }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         name = "taskopen-1.1.4";

     

       5
       5
       +
         src = fetchurl {

     

       6
       6
       +
           url = "https://github.com/ValiValpas/taskopen/archive/v1.1.4.tar.gz";

     

       7
       7
       +
           sha256 = "774dd89f5c92462098dd6227e181268e5ec9930bbc569f25784000df185c71ba";

     

       8
       8
       +
         };

     

       9
       9
       +
       

     

       10
       10
       +
         nativeBuildInputs = [ makeWrapper ];

     

       11
       11
       +
         buildInputs = [ which perl ] ++ (with perlPackages; [ JSON ]);

     

       12
       12
       +
       

     

       13
       13
       +
         installPhase = ''

     

       14
       14
       +
           # We don't need a DESTDIR and an empty string results in an absolute path

     

       15
       15
       +
           # (due to the trailing slash) which breaks the build.

     

       16
       16
       +
           sed 's|$(DESTDIR)/||' -i Makefile

     

       17
       17
       +
       

     

       18
       18
       +
           make PREFIX=$out

     

       19
       19
       +
           make PREFIX=$out install

     

       20
       20
       +
         '';

     

       21
       21
       +
       

     

       22
       22
       +
         postFixup = ''

     

       23
       23
       +
           wrapProgram $out/bin/taskopen \

     

       24
       24
       +
                --set PERL5LIB "$PERL5LIB"

     

       25
       25
       +
         '';

     

       26
       26
       +
       

     

       27
       27
       +
         meta = with stdenv.lib; {

     

       28
       28
       +
           description = "Script for taking notes and open urls with taskwarrior";

     

       29
       29
       +
           homepage = https://github.com/ValiValpas/taskopen;

     

       30
       30
       +
           platforms = platforms.linux;

     

       31
       31
       +
           license = stdenv.lib.licenses.free ;

     

       32
       32
       +
           maintainers = [ maintainers.winpat ];

     

       33
       33
       +
         };

     

       34
       34
       +
       }

+9 -9

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

···

       1
       1
        
       # This file is autogenerated from update.sh in the same directory.

     

       2
       2
        
       {

     

       3
       3
        
         beta = {

     

       4
       4
       -
           sha256 = "1lpgkf292f6v6v19zjp1si6vvizixk9192yjx76pq1d790678qrb";

     

       5
       5
       -
           sha256bin64 = "028c3gjh5zbxr53wkk3s5jvgwc2fz9cnvnyr58q4la91vyrbjslm";

     

       6
       6
       -
           version = "74.0.3729.61";

     

       4
       4
       +
           sha256 = "0vsvjhmrc2p8mf4rfp9bf9y4nqkbbi5v8008cdvr6c14zq35w7hy";

     

       5
       5
       +
           sha256bin64 = "1zzmk08y2rhirm297a91bvq5q30vvxll8fzfp7z5cpqb6az80y2h";

     

       6
       6
       +
           version = "74.0.3729.108";

     

       7
       7
        
         };

     

       8
       8
        
         dev = {

     

       9
       9
       -
           sha256 = "15197r2gbx4h7dsasvgz0vcl7mqmj0glc4sip99dw145drwdpmsq";

     

       10
       10
       -
           sha256bin64 = "1qf089l5k7l69msrn49z5lkg932n1rgnzgr9yg5ja89arcgynacv";

     

       11
       11
       -
           version = "75.0.3753.4";

     

       9
       9
       +
           sha256 = "1wrg4r2q043i8i4vq9zn69yvnzjxzmxyn21k367909kci83hhi44";

     

       10
       10
       +
           sha256bin64 = "1jv9wi4nddijjp9y0r77rxciqsd1rkd87ipvagyq5nzpxr6wdzsa";

     

       11
       11
       +
           version = "75.0.3766.2";

     

       12
       12
        
         };

     

       13
       13
        
         stable = {

     

       14
       14
       -
           sha256 = "1bskjr7yiwvdab1b5mp36y6964xqpgks6dqazm4qifwqvqcw80pb";

     

       15
       15
       -
           sha256bin64 = "00ndrqhmnk567sw6xj22m84126qvivq0jzfx0v46ya3kq6ln22gr";

     

       16
       16
       -
           version = "73.0.3683.103";

     

       14
       14
       +
           sha256 = "0vsvjhmrc2p8mf4rfp9bf9y4nqkbbi5v8008cdvr6c14zq35w7hy";

     

       15
       15
       +
           sha256bin64 = "0zs3khzszppmjf5s4rs6fbmhgc9y0abj4q4q8j3hn6nisddi9q9c";

     

       16
       16
       +
           version = "74.0.3729.108";

     

       17
       17
        
         };

     

       18
       18
        
       }

+4 -4

pkgs/applications/networking/mpop/default.nix

···

       3
       3
        
       with stdenv.lib;

     

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
       -
         version = "1.4.3";

     

       7
       7
       -
         name = "mpop-${version}";

     

       6
       6
       +
         pname = "mpop";

     

       7
       7
       +
         version = "1.4.4";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchurl {

     

       10
       10
       -
           url = "https://marlam.de/mpop/releases/${name}.tar.xz";

     

       11
       11
       -
           sha256 = "1di86frxv4gj8fasni409m87qmv0j0vmj13lawkz1pwv9hbynhjb";

     

       10
       10
       +
           url = "https://marlam.de/${pname}/releases/${pname}-${version}.tar.xz";

     

       11
       11
       +
           sha256 = "0j21cp8bw12vgfymxi3i4av3j97lrcyb5y9xa3mb59wr17izz73x";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ pkgconfig ];

+3 -4

pkgs/applications/networking/msmtp/default.nix

···

       9
       9
        
       

     

       10
       10
        
       in stdenv.mkDerivation rec {

     

       11
       11
        
         pname = "msmtp";

     

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

     

       13
       13
       -
         version = "1.8.3";

     

       12
       12
       +
         version = "1.8.4";

     

       14
       13
        
       

     

       15
       14
        
         src = fetchurl {

     

       16
       16
       -
           url = "https://marlam.de/msmtp/releases/${name}.tar.xz";

     

       17
       17
       -
           sha256 = "1d4jdgrx4czp66nnwdsy938lzr4llhwyy0715pwg0j6h6gyyxciw";

     

       15
       15
       +
           url = "https://marlam.de/${pname}/releases/${pname}-${version}.tar.xz";

     

       16
       16
       +
           sha256 = "1xr926lyy44baqdgv9q0sw5z6ll2cb4lx2g4lgpgbqn8bglpzpg5";

     

       18
       17
        
         };

     

       19
       18
        
       

     

       20
       19
        
         patches = [

+2 -2

pkgs/applications/office/atlassian-cli/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "atlassian-cli-${version}";

     

       5
       5
       -
         version = "8.0.0";

     

       5
       5
       +
         version = "8.2.0";

     

       6
       6
        
         

     

       7
       7
        
         src = fetchzip {

     

       8
       8
        
           url  = "https://bobswift.atlassian.net/wiki/download/attachments/16285777/${name}-distribution.zip";

     

       9
       9
       -
           sha256  = "0ysyam06ll70d0baa3hb7wcgqnqflssr64bqjr3db6fnk1q096m8";

     

       9
       9
       +
           sha256  = "0lcyyay2fyywcn096y33d77r6fpvwggv5qdkky5qy16lh6rfx1lm";

     

       10
       10
        
           extraPostFetch = "chmod go-w $out";

     

       11
       11
        
         };

     

       12
       12

+31

pkgs/applications/office/minetime/default.nix

···

       1
       1
       +
       { appimageTools, fetchurl, lib, gsettings-desktop-schemas, gtk3 }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         pname = "minetime";

     

       5
       5
       +
         version = "1.5.1";

     

       6
       6
       +
       in

     

       7
       7
       +
       appimageTools.wrapType2 rec {

     

       8
       8
       +
         name = "${pname}-${version}";

     

       9
       9
       +
         src = fetchurl {

     

       10
       10
       +
           url = "https://github.com/marcoancona/MineTime/releases/download/v${version}/${name}-x86_64.AppImage";

     

       11
       11
       +
           sha256 = "0099cq4p7j01bzs7q79y9xi7g6ji17v9g7cykfjggwsgqfmvd0hz";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         profile = ''

     

       15
       15
       +
           export LC_ALL=C.UTF-8

     

       16
       16
       +
           export XDG_DATA_DIRS=${gsettings-desktop-schemas}/share/gsettings-schemas/${gsettings-desktop-schemas.name}:${gtk3}/share/gsettings-schemas/${gtk3.name}:$XDG_DATA_DIRS

     

       17
       17
       +
         '';

     

       18
       18
       +
       

     

       19
       19
       +
         multiPkgs = null; # no 32bit needed

     

       20
       20
       +
         extraPkgs = appimageTools.defaultFhsEnvArgs.multiPkgs;

     

       21
       21
       +
         extraInstallCommands = "mv $out/bin/{${name},${pname}}";

     

       22
       22
       +
       

     

       23
       23
       +
         meta = with lib; {

     

       24
       24
       +
           description = "Modern, intuitive and smart calendar application";

     

       25
       25
       +
           homepage = https://minetime.ai;

     

       26
       26
       +
           license = licenses.unfree;

     

       27
       27
       +
           # Should be cross-platform, but for now we just grab the appimage

     

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

     

       29
       29
       +
           maintainers = with maintainers; [ dtzWill ];

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+5 -1

pkgs/applications/office/wordgrinder/default.nix

···

       16
       16
        
           "PREFIX=$(out)"

     

       17
       17
        
           "LUA_INCLUDE=${lua52Packages.lua}/include"

     

       18
       18
        
           "LUA_LIB=${lua52Packages.lua}/lib/liblua.so"

     

       19
       19
       -
         ] ++ stdenv.lib.optional stdenv.isLinux "XFT_PACKAGE=--libs=\{-lX11 -lXft\}";

     

       19
       19
       +
         ];

     

       20
       20
       +
       

     

       21
       21
       +
         preBuild = stdenv.lib.optionalString stdenv.isLinux ''

     

       22
       22
       +
           makeFlagsArray+=('XFT_PACKAGE=--cflags={} --libs={-lX11 -lXft}')

     

       23
       23
       +
         '';

     

       20
       24
        
       

     

       21
       25
        
         dontUseNinjaBuild = true;

     

       22
       26
        
         dontUseNinjaInstall = true;

+65

pkgs/applications/science/biology/sumatools/default.nix

···

       1
       1
       +
       { gccStdenv, fetchFromGitLab, zlib }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         stdenv = gccStdenv;

     

       5
       5
       +
         meta = with stdenv.lib; {

     

       6
       6
       +
           description = "Fast and exact comparison and clustering of sequences";

     

       7
       7
       +
           homepage = https://metabarcoding.org/sumatra;

     

       8
       8
       +
           maintainers = [ maintainers.bzizou ];

     

       9
       9
       +
           platforms = platforms.unix;

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
       in rec {

     

       13
       13
       +
       

     

       14
       14
       +
         # Suma library

     

       15
       15
       +
         sumalibs = stdenv.mkDerivation rec {

     

       16
       16
       +
           version = "1.0.34";

     

       17
       17
       +
           pname = "sumalibs";

     

       18
       18
       +
           src = fetchFromGitLab {

     

       19
       19
       +
             domain = "git.metabarcoding.org";

     

       20
       20
       +
             owner = "obitools";

     

       21
       21
       +
             repo = pname;

     

       22
       22
       +
             rev = "sumalib_v${version}";

     

       23
       23
       +
             sha256 = "0hwkrxzfz7m5wdjvmrhkjg8kis378iaqr5n4nhdhkwwhn8x1jn5a";

     

       24
       24
       +
           };

     

       25
       25
       +
           makeFlags = "PREFIX=$(out)";

     

       26
       26
       +
         };

     

       27
       27
       +
       

     

       28
       28
       +
         # Sumatra

     

       29
       29
       +
         sumatra = stdenv.mkDerivation rec {

     

       30
       30
       +
           version = "1.0.34";

     

       31
       31
       +
           pname = "sumatra";

     

       32
       32
       +
           src = fetchFromGitLab {

     

       33
       33
       +
             domain = "git.metabarcoding.org";

     

       34
       34
       +
             owner = "obitools";

     

       35
       35
       +
             repo = pname;

     

       36
       36
       +
             rev = "${pname}_v${version}";

     

       37
       37
       +
             sha256 = "1bbpbdkshdc3xffqnr1qfy8qk64ldsmdc3s8mrcrlx132rgbi5f6";

     

       38
       38
       +
           };

     

       39
       39
       +
           buildInputs = [ sumalibs zlib ];

     

       40
       40
       +
           makeFlags = [

     

       41
       41
       +
             "LIBSUMA=${sumalibs}/lib/libsuma.a"

     

       42
       42
       +
             "LIBSUMAPATH=-L${sumalibs}"

     

       43
       43
       +
             "PREFIX=$(out)"

     

       44
       44
       +
           ];

     

       45
       45
       +
         };

     

       46
       46
       +
       

     

       47
       47
       +
         # Sumaclust

     

       48
       48
       +
         sumaclust = stdenv.mkDerivation rec {

     

       49
       49
       +
           version = "1.0.34";

     

       50
       50
       +
           pname = "sumaclust";

     

       51
       51
       +
           src = fetchFromGitLab {

     

       52
       52
       +
             domain = "git.metabarcoding.org";

     

       53
       53
       +
             owner = "obitools";

     

       54
       54
       +
             repo = pname;

     

       55
       55
       +
             rev = "${pname}_v${version}";

     

       56
       56
       +
             sha256 = "0x8yi3k3jxhmv2krp4rcjlj2f9zg0qrk7gx4kpclf9c3yxgsgrds";

     

       57
       57
       +
           };

     

       58
       58
       +
           buildInputs = [ sumalibs ];

     

       59
       59
       +
           makeFlags = [

     

       60
       60
       +
             "LIBSUMA=${sumalibs}/lib/libsuma.a"

     

       61
       61
       +
             "LIBSUMAPATH=-L${sumalibs}"

     

       62
       62
       +
             "PREFIX=$(out)"

     

       63
       63
       +
           ];

     

       64
       64
       +
         };

     

       65
       65
       +
       }

+2 -2

pkgs/applications/science/electronics/eagle/eagle.nix

···

       13
       13
        
         in

     

       14
       14
        
         stdenv.mkDerivation rec {

     

       15
       15
        
           name = "eagle-${version}";

     

       16
       16
       -
           version = "9.3.1";

     

       16
       16
       +
           version = "9.3.2";

     

       17
       17
        
       

     

       18
       18
        
           src = fetchurl {

     

       19
       19
        
             url = "https://eagle-updates.circuits.io/downloads/${builtins.replaceStrings ["."] ["_"] version}/Autodesk_EAGLE_${version}_English_Linux_64bit.tar.gz";

     

       20
       20
       -
             sha256 = "0hrbw368kskjzwjnqrri5j7c10d0z5m81h3s9zhqfrmwym42vdc5";

     

       20
       20
       +
             sha256 = "0xrrd2d86gxrkbqvssbg8zki40hk05h48w73b0hv7wnc7wg1msir";

     

       21
       21
        
           };

     

       22
       22
        
       

     

       23
       23
        
           desktopItem = makeDesktopItem {

+2 -2

pkgs/applications/science/math/gmsh/default.nix

···

       1
       1
        
       { stdenv, fetchurl, cmake, openblasCompat, gfortran, gmm, fltk, libjpeg

     

       2
       2
        
       , zlib, libGLU_combined, libGLU, xorg }:

     

       3
       3
        
       

     

       4
       4
       -
       let version = "4.2.2"; in

     

       4
       4
       +
       let version = "4.2.3"; in

     

       5
       5
        
       

     

       6
       6
        
       stdenv.mkDerivation {

     

       7
       7
        
         name = "gmsh-${version}";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchurl {

     

       10
       10
        
           url = "http://gmsh.info/src/gmsh-${version}-source.tgz";

     

       11
       11
       -
           sha256 = "e9ee9f5c606bbec5f2adbb8c3d6023c4e2577f487fa4e4ecfcfc94a241cc8dcc";

     

       11
       11
       +
           sha256 = "0n18wmj8i4m1pzri3r0676lx1427zf8qmsrgnn07drv6if1cia2q";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         buildInputs = [ cmake openblasCompat gmm fltk libjpeg zlib libGLU_combined

+8 -10

pkgs/applications/version-management/git-review/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, pythonPackages} :

     

       1
       1
       +
       { stdenv, fetchFromGitHub, pythonPackages} :

     

       2
       2
        
       

     

       3
       3
        
       pythonPackages.buildPythonApplication rec {

     

       4
       4
       -
         name = "git-review-${version}";

     

       5
       5
       -
         version = "1.27.0";

     

       4
       4
       +
         pname = "git-review";

     

       5
       5
       +
         version = "1.28.0";

     

       6
       6
        
       

     

       7
       7
        
         # Manually set version because prb wants to get it from the git

     

       8
       8
        
         # upstream repository (and we are installing from tarball instead)

     

       9
       9
        
         PBR_VERSION = "${version}";

     

       10
       10
        
       

     

       11
       11
       -
         postPatch = ''

     

       12
       12
       -
           sed -i -e '/argparse/d' requirements.txt

     

       13
       13
       -
         '';

     

       14
       14
       -
       

     

       15
       15
       -
         src = fetchurl rec {

     

       16
       16
       -
           url = "https://github.com/openstack-infra/git-review/archive/${version}.tar.gz";

     

       17
       17
       -
           sha256 = "0smdkps9avnj58izyfc5m0amq8nafgs9iqlyaf7ncrlvypia1f3q";

     

       11
       11
       +
         src = fetchFromGitHub rec {

     

       12
       12
       +
           owner = "openstack-infra";

     

       13
       13
       +
           repo = pname;

     

       14
       14
       +
           rev = version;

     

       15
       15
       +
           sha256 = "1hgw1dkl94m3idv4izc7wf2j7al2c7nnsqywy7g53nzkv9pfv47s";

     

       18
       16
        
         };

     

       19
       17
        
       

     

       20
       18
        
         propagatedBuildInputs = with pythonPackages; [ pbr requests setuptools ];

+5 -2

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

···

       27
       27
        
         nativeBuildInputs = [ makeWrapper ]

     

       28
       28
        
           ++ optional pamSupport pam;

     

       29
       29
        
       

     

       30
       30
       -
         buildFlags = optional sqliteSupport "-tags sqlite"

     

       31
       31
       -
           ++ optional pamSupport "-tags pam";

     

       30
       30
       +
         buildFlags = "-tags";

     

       31
       31
       +
       

     

       32
       32
       +
         buildFlagsArray =

     

       33
       33
       +
           (  optional sqliteSupport "sqlite"

     

       34
       34
       +
           ++ optional pamSupport "pam");

     

       32
       35
        
       

     

       33
       36
        
         outputs = [ "bin" "out" "data" ];

     

       34
       37

+7 -9

pkgs/build-support/appimage/default.nix

···

       23
       23
        
           buildCommand = ''

     

       24
       24
        
             install $src ./appimage

     

       25
       25
        
             patchelf \

     

       26
       26
       -
               --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \

     

       26
       26
       +
               --set-interpreter ${stdenv.cc.bintools.dynamicLinker} \

     

       27
       27
        
               --replace-needed libz.so.1 ${zlib}/lib/libz.so.1 \

     

       28
       28
        
               ./appimage

     

       29
       29
        
       

     
···

       33
       33
        
           '';

     

       34
       34
        
         };

     

       35
       35
        
       

     

       36
       36
       -
         wrapAppImage = { name, src, extraPkgs }: buildFHSUserEnv (defaultFhsEnvArgs // {

     

       36
       36
       +
         wrapAppImage = args@{ name, src, extraPkgs, ... }: buildFHSUserEnv (defaultFhsEnvArgs // {

     

       37
       37
        
           inherit name;

     

       38
       38
        
       

     

       39
       39
        
           targetPkgs = pkgs: defaultFhsEnvArgs.targetPkgs pkgs ++ extraPkgs pkgs;

     
···

       46
       46
        
             cd $APPDIR

     

       47
       47
        
             exec ./AppRun "$@"

     

       48
       48
        
           '';

     

       49
       49
       -
         });

     

       49
       49
       +
         } // (removeAttrs args (builtins.attrNames (builtins.functionArgs wrapAppImage))));

     

       50
       50
        
       

     

       51
       51
       -
         wrapType1 = args@{ name, src, extraPkgs ? pkgs: [] }: wrapAppImage {

     

       52
       52
       -
           inherit name extraPkgs;

     

       51
       51
       +
         wrapType1 = args@{ name, src, extraPkgs ? pkgs: [], ... }: wrapAppImage (args // {

     

       53
       52
        
           src = extractType1 { inherit name src; };

     

       54
       54
       -
         };

     

       53
       53
       +
         });

     

       55
       54
        
       

     

       56
       56
       -
         wrapType2 = args@{ name, src, extraPkgs ? pkgs: [] }: wrapAppImage {

     

       57
       57
       -
           inherit name extraPkgs;

     

       55
       55
       +
         wrapType2 = args@{ name, src, extraPkgs ? pkgs: [], ... }: wrapAppImage (args // {

     

       58
       56
        
           src = extractType2 { inherit name src; };

     

       59
       59
       -
         };

     

       57
       57
       +
         });

     

       60
       58
        
       

     

       61
       59
        
         defaultFhsEnvArgs = {

     

       62
       60
        
           name = "appimage-env";

+28

pkgs/data/fonts/xkcd-font/default.nix

···

       1
       1
       +
       { stdenv, fetchFromGitHub }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         pname = "xkcd-font";

     

       5
       5
       +
         version = "unstable-2017-08-24";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "ipython";

     

       9
       9
       +
           repo = pname;

     

       10
       10
       +
           rev = "5632fde618845dba5c22f14adc7b52bf6c52d46d";

     

       11
       11
       +
           sha256 = "01wpfc1yp93b37r472mx2b459il5gywnv5sl7pp9afpycb3i4f6l";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         phases = [ "unpackPhase" "installPhase" ];

     

       15
       15
       +
       

     

       16
       16
       +
         installPhase = ''

     

       17
       17
       +
           install -Dm444 -t $out/share/fonts/opentype/ xkcd/build/xkcd.otf

     

       18
       18
       +
           install -Dm444 -t $out/share/fonts/truetype/ xkcd-script/font/xkcd-script.ttf

     

       19
       19
       +
         '';

     

       20
       20
       +
       

     

       21
       21
       +
         meta = with stdenv.lib; {

     

       22
       22
       +
           description = "The xkcd font";

     

       23
       23
       +
           homepage = https://github.com/ipython/xkcd-font;

     

       24
       24
       +
           license = licenses.cc-by-nc-30;

     

       25
       25
       +
           platforms = platforms.all;

     

       26
       26
       +
           maintainers = [ maintainers.marsam ];

     

       27
       27
       +
         };

     

       28
       28
       +
       }

+2 -2

pkgs/development/compilers/ocaml/4.08.nix

···

       1
       1
        
       import ./generic.nix {

     

       2
       2
        
         major_version = "4";

     

       3
       3
        
         minor_version = "08";

     

       4
       4
       -
         patch_version = "0+beta2";

     

       5
       5
       -
         sha256 = "1ngsrw74f3hahzsglxkrdxzv86bkmpsiaaynnzjwfwyzvy8sqrac";

     

       4
       4
       +
         patch_version = "0+beta3";

     

       5
       5
       +
         sha256 = "02pk4bxrgqb12hvpbxyqnl4nwr4g2h96wsfzfd1k8vj8h0jmxzc4";

     

       6
       6
        
       

     

       7
       7
        
         # If the executable is stripped it does not work

     

       8
       8
        
         dontStrip = true;

+2 -1

pkgs/development/compilers/oraclejdk/jdk-linux-base.nix

···

       89
       89
        
             armv7l-linux  = "linux-arm32-vfp-hflt";

     

       90
       90
        
             aarch64-linux = "linux-arm64-vfp-hflt";

     

       91
       91
        
           }.${stdenv.hostPlatform.system};

     

       92
       92
       +
           javadlPlatformName = "linux-i586";

     

       92
       93
        
         in fetchurl {

     

       93
       93
       -
          url = "http://download.oracle.com/otn-pub/java/jdk/${productVersion}u${patchVersion}-b${buildVersion}/${releaseToken}/jdk-${productVersion}u${patchVersion}-${platformName}.tar.gz";

     

       94
       94
       +
          url = "http://javadl.oracle.com/webapps/download/GetFile/1.${productVersion}.0_${patchVersion}-b${buildVersion}/${releaseToken}/${javadlPlatformName}/jdk-${productVersion}u${patchVersion}-${platformName}.tar.gz";

     

       94
       95
        
          curlOpts = "-b oraclelicense=a";

     

       95
       96
        
          sha256 = sha256.${stdenv.hostPlatform.system};

     

       96
       97
        
         };

+28

pkgs/development/compilers/pforth/default.nix

···

       1
       1
       +
       { stdenv, fetchFromGitHub }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         version = "28";

     

       5
       5
       +
         pname = "pforth";

     

       6
       6
       +
         src = fetchFromGitHub {

     

       7
       7
       +
           owner = "philburk";

     

       8
       8
       +
           repo = "pforth";

     

       9
       9
       +
           rev = "9190005e32c6151b76ac707b30eeb4d5d9dd1d36";

     

       10
       10
       +
           sha256 = "0k3pmcgybsnwrxy75piyb2420r8d4ij190606js32j99062glr3x";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         makeFlags = [ "SRCDIR=." ];

     

       14
       14
       +
         makefile = "build/unix/Makefile";

     

       15
       15
       +
       

     

       16
       16
       +
         installPhase = ''

     

       17
       17
       +
           install -Dm755 pforth_standalone $out/bin/pforth

     

       18
       18
       +
         '';

     

       19
       19
       +
       

     

       20
       20
       +
       

     

       21
       21
       +
         meta = {

     

       22
       22
       +
           description = "Portable ANSI style Forth written in ANSI C";

     

       23
       23
       +
           homepage = http://www.softsynth.com/pforth/;

     

       24
       24
       +
           license = stdenv.lib.licenses.publicDomain;

     

       25
       25
       +
           platforms = stdenv.lib.platforms.unix;

     

       26
       26
       +
           maintainers = with stdenv.lib.maintainers; [ yrashk ];

     

       27
       27
       +
         };

     

       28
       28
       +
       }

+6 -6

pkgs/development/compilers/purescript/purescript/default.nix

···

       17
       17
        
               '';

     

       18
       18
        
       

     

       19
       19
        
       in stdenv.mkDerivation rec {

     

       20
       20
       -
         name = "purs-simple";

     

       21
       21
       -
         version = "v0.12.4";

     

       20
       20
       +
         pname = "purescript";

     

       21
       21
       +
         version = "0.12.5";

     

       22
       22
        
       

     

       23
       23
        
         src =

     

       24
       24
        
           if stdenv.isDarwin

     

       25
       25
        
           then

     

       26
       26
        
           fetchurl {

     

       27
       27
       -
             url = "https://github.com/purescript/purescript/releases/download/v0.12.4/macos.tar.gz";

     

       28
       28
       -
             sha256 = "046b18plakwvqr77x1hybhfiyzrhnnq0q5ixcmypri1mkkdsmczx";

     

       27
       27
       +
             url = "https://github.com/${pname}/${pname}/releases/download/v${version}/macos.tar.gz";

     

       28
       28
       +
             sha256 = "15j9lkrl15dicx37bmh0199b3qdixig7w24wvdzi20jqbacz8nkn";

     

       29
       29
        
           }

     

       30
       30
        
           else

     

       31
       31
        
           fetchurl {

     

       32
       32
       -
             url = "https://github.com/purescript/purescript/releases/download/v0.12.4/linux64.tar.gz";

     

       33
       33
       -
             sha256 = "18yny533sjfgacxqx1ki306nhznj4q6nv52c83l82gqj8amyj7k0";

     

       32
       32
       +
             url = "https://github.com/${pname}/${pname}/releases/download/v${version}/linux64.tar.gz";

     

       33
       33
       +
             sha256 = "07dva5gxq77g787krscv4dsz5088fzkvpmm9fwxw9a59jszzs7kq";

     

       34
       34
        
           };

     

       35
       35
        
       

     

       36
       36

pkgs/development/coq-modules/Verdi/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, coq, Cheerios, InfSeqExt, ssreflect }:

     

       2
       2
        
       

     

       3
       3
        
       let param =

     

       4
       4
       +
         if stdenv.lib.versionAtLeast coq.coq-version "8.7" then

     

       4
       5
        
         {

     

       6
       6
       +
             version = "20190202";

     

       7
       7
       +
             rev = "bc193be9ea8485add7646a0f72e2aa76a9c7e01f";

     

       8
       8
       +
             sha256 = "1adkwxnmc9qfah2bya0hpd2vzkmk1y212z4n7fcmvr1a85ykgd7z";

     

       9
       9
       +
         } else {

     

       5
       10
        
             version = "20181102";

     

       6
       11
        
             rev = "25b79cf1be5527ab8dc1b8314fcee93e76a2e564";

     

       7
       12
        
             sha256 = "1vw47c37k5vaa8vbr6ryqy8riagngwcrfmb3rai37yi9xhdqg55z";

+1 -1

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

···

       1259
       1259
        
         # Use latest pandoc despite what LTS says.

     

       1260
       1260
        
         # Test suite fails in both 2.5 and 2.6: https://github.com/jgm/pandoc/issues/5309.

     

       1261
       1261
        
         pandoc = doDistribute super.pandoc_2_7_2;

     

       1262
       1262
       -
         pandoc-citeproc = doDistribute super.pandoc-citeproc_0_16_1_3;

     

       1262
       1262
       +
         pandoc-citeproc = doDistribute super.pandoc-citeproc_0_16_2;

     

       1263
       1263
        
       

     

       1264
       1264
        
         # https://github.com/qfpl/tasty-hedgehog/issues/24

     

       1265
       1265
        
         tasty-hedgehog = dontCheck super.tasty-hedgehog;

+27 -14

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

···

       46
       46
        
         # Newer versions don't work in LTS-12.x

     

       47
       47
        
         - alsa-mixer < 0.3

     

       48
       48
        
         - cassava-megaparsec < 2

     

       49
       49
       -
         # LTS Haskell 13.17

     

       49
       49
       +
         # LTS Haskell 13.18

     

       50
       50
        
         - abstract-deque ==0.3

     

       51
       51
        
         - abstract-deque-tests ==0.3

     

       52
       52
        
         - abstract-par ==0.3.3

     
···

       239
       239
        
         - avers ==0.0.17.1

     

       240
       240
        
         - avers-api ==0.1.0

     

       241
       241
        
         - avers-server ==0.1.0.1

     

       242
       242
       -
         - avro ==0.4.4.1

     

       242
       242
       +
         - avro ==0.4.4.2

     

       243
       243
        
         - avwx ==0.3.0.2

     

       244
       244
        
         - axel ==0.0.9

     

       245
       245
        
         - backprop ==0.2.6.2

     
···

       382
       382
        
         - ChannelT ==0.0.0.7

     

       383
       383
        
         - charset ==0.3.7.1

     

       384
       384
        
         - charsetdetect-ae ==1.1.0.4

     

       385
       385
       +
         - Chart ==1.9.1

     

       386
       386
       +
         - Chart-diagrams ==1.9.2

     

       385
       387
        
         - chaselev-deque ==0.5.0.5

     

       386
       388
        
         - cheapskate ==0.1.1.1

     

       387
       389
        
         - cheapskate-highlight ==0.1.0.0

     
···

       588
       590
        
         - diagrams-contrib ==1.4.3

     

       589
       591
        
         - diagrams-core ==1.4.1.1

     

       590
       592
        
         - diagrams-lib ==1.4.2.3

     

       593
       593
       +
         - diagrams-postscript ==1.4.1

     

       591
       594
        
         - diagrams-rasterific ==1.4.1.1

     

       592
       595
        
         - diagrams-solve ==0.1.1

     

       593
       596
        
         - diagrams-svg ==1.4.2

     
···

       815
       818
        
         - getopt-generics ==0.13.0.3

     

       816
       819
        
         - ghc-core ==0.5.6

     

       817
       820
        
         - ghc-exactprint ==0.5.8.2

     

       818
       818
       -
         - ghcid ==0.7.2

     

       821
       821
       +
         - ghcid ==0.7.4

     

       819
       822
        
         - ghci-hexcalc ==0.1.0.2

     

       820
       823
        
         - ghcjs-codemirror ==0.0.0.2

     

       821
       824
        
         - ghc-paths ==0.1.0.9

     
···

       1043
       1046
        
         - http-common ==0.8.2.0

     

       1044
       1047
        
         - http-conduit ==2.3.7

     

       1045
       1048
        
         - http-date ==0.0.8

     

       1049
       1049
       +
         - http-directory ==0.1.1

     

       1046
       1050
        
         - httpd-shed ==0.4.0.3

     

       1047
       1051
        
         - http-link-header ==1.0.3.1

     

       1048
       1052
        
         - http-media ==0.7.1.3

     
···

       1116
       1120
        
         - insert-ordered-containers ==0.2.1.0

     

       1117
       1121
        
         - inspection-testing ==0.4.1.2

     

       1118
       1122
        
         - instance-control ==0.1.2.0

     

       1119
       1119
       -
         - integer-logarithms ==1.0.2.2

     

       1123
       1123
       +
         - integer-logarithms ==1.0.3

     

       1120
       1124
        
         - integration ==0.2.1

     

       1121
       1125
        
         - intern ==0.9.2

     

       1122
       1126
        
         - interpolate ==0.2.0

     
···

       1196
       1200
        
         - language-haskell-extract ==0.2.4

     

       1197
       1201
        
         - language-java ==0.2.9

     

       1198
       1202
        
         - language-javascript ==0.6.0.11

     

       1199
       1199
       -
         - language-puppet ==1.4.3

     

       1203
       1203
       +
         - language-puppet ==1.4.4

     

       1200
       1204
        
         - lapack-ffi ==0.0.2

     

       1201
       1205
        
         - lapack-ffi-tools ==0.1.2

     

       1202
       1206
        
         - largeword ==1.2.5

     
···

       1260
       1264
        
         - long-double ==0.1

     

       1261
       1265
        
         - loop ==0.3.0

     

       1262
       1266
        
         - lrucaching ==0.3.3

     

       1263
       1263
       -
         - lsp-test ==0.5.1.0

     

       1267
       1267
       +
         - lsp-test ==0.5.1.1

     

       1264
       1268
        
         - lucid ==2.9.11

     

       1265
       1269
        
         - lucid-extras ==0.1.0.1

     

       1266
       1270
        
         - lxd-client-config ==0.1.0.1

     
···

       1422
       1426
        
         - network-messagepack-rpc ==0.1.1.0

     

       1423
       1427
        
         - network-multicast ==0.2.0

     

       1424
       1428
        
         - network-simple ==0.4.3

     

       1425
       1425
       -
         - network-simple-tls ==0.3.1

     

       1429
       1429
       +
         - network-simple-tls ==0.3.2

     

       1426
       1430
        
         - network-transport ==0.5.2

     

       1427
       1431
        
         - network-transport-composed ==0.2.1

     

       1428
       1432
        
         - network-uri ==2.6.1.0

     
···

       1526
       1530
        
         - pem ==0.2.4

     

       1527
       1531
        
         - percent-format ==0.0.1

     

       1528
       1532
        
         - perfect-hash-generator ==0.2.0.6

     

       1529
       1529
       -
         - persist ==0.1.1.2

     

       1533
       1533
       +
         - persist ==0.1.1.3

     

       1530
       1534
        
         - persistable-record ==0.6.0.4

     

       1531
       1535
        
         - persistable-types-HDBC-pg ==0.0.3.5

     

       1532
       1536
        
         - persistent ==2.9.2

     
···

       1621
       1625
        
         - protocol-radius ==0.0.1.1

     

       1622
       1626
        
         - protocol-radius-test ==0.0.1.0

     

       1623
       1627
        
         - proto-lens ==0.4.0.1

     

       1624
       1624
       -
         - proto-lens-arbitrary ==0.1.2.6

     

       1628
       1628
       +
         - proto-lens-arbitrary ==0.1.2.7

     

       1625
       1629
        
         - proto-lens-combinators ==0.4.0.1

     

       1626
       1630
        
         - proto-lens-optparse ==0.1.1.5

     

       1627
       1631
        
         - proto-lens-protobuf-types ==0.4.0.1

     
···

       1702
       1706
        
         - regex-tdfa ==1.2.3.1

     

       1703
       1707
        
         - regex-tdfa-text ==1.0.0.3

     

       1704
       1708
        
         - regex-with-pcre ==1.0.2.0

     

       1705
       1705
       -
         - registry ==0.1.3.4

     

       1709
       1709
       +
         - registry ==0.1.3.5

     

       1706
       1710
        
         - reinterpret-cast ==0.1.0

     

       1707
       1711
        
         - relapse ==1.0.0.0

     

       1708
       1712
        
         - relational-query ==0.12.1.0

     
···

       2054
       2058
        
         - th-strict-compat ==0.1.0.1

     

       2055
       2059
        
         - th-utilities ==0.2.1.0

     

       2056
       2060
        
         - thyme ==0.3.5.5

     

       2057
       2057
       -
         - tidal ==1.0.10

     

       2061
       2061
       +
         - tidal ==1.0.11

     

       2058
       2062
        
         - tile ==0.3.0.0

     

       2059
       2063
        
         - time-compat ==0.1.0.3

     

       2060
       2064
        
         - timeit ==2.0

     
···

       2097
       2101
        
         - tuples-homogenous-h98 ==0.1.1.0

     

       2098
       2102
        
         - tuple-sop ==0.3.1.0

     

       2099
       2103
        
         - tuple-th ==0.2.5

     

       2100
       2100
       -
         - turtle ==1.5.13

     

       2104
       2104
       +
         - turtle ==1.5.14

     

       2101
       2105
        
         - typed-process ==0.2.4.0

     

       2102
       2106
        
         - type-fun ==0.1.1

     

       2103
       2107
        
         - type-hint ==0.1

     
···

       2190
       2194
        
         - vector-split ==1.0.0.2

     

       2191
       2195
        
         - vector-th-unbox ==0.2.1.6

     

       2192
       2196
        
         - verbosity ==0.2.3.0

     

       2193
       2193
       -
         - versions ==3.5.0

     

       2197
       2197
       +
         - versions ==3.5.1

     

       2194
       2198
        
         - ViennaRNAParser ==1.3.3

     

       2195
       2199
        
         - vinyl ==0.10.0.1

     

       2196
       2200
        
         - vivid ==0.4.2.3

     
···

       2237
       2241
        
         - websockets-snap ==0.10.3.0

     

       2238
       2242
        
         - weigh ==0.0.14

     

       2239
       2243
        
         - wide-word ==0.1.0.8

     

       2240
       2240
       -
         - wikicfp-scraper ==0.1.0.10

     

       2244
       2244
       +
         - wikicfp-scraper ==0.1.0.11

     

       2241
       2245
        
         - wild-bind ==0.1.2.3

     

       2242
       2246
        
         - wild-bind-x11 ==0.2.0.6

     

       2243
       2247
        
         - Win32-notify ==0.3.0.3

     
···

       6888
       6892
        
         - minesweeper

     

       6889
       6893
        
         - miniforth

     

       6890
       6894
        
         - minilens

     

       6895
       6895
       +
         - minilight

     

       6891
       6896
        
         - minimung

     

       6892
       6897
        
         - minio-hs

     

       6893
       6898
        
         - minions

     
···

       6895
       6900
        
         - miniplex

     

       6896
       6901
        
         - minirotate

     

       6897
       6902
        
         - ministg

     

       6903
       6903
       +
         - minitypeset-opengl

     

       6898
       6904
        
         - minst-idx

     

       6899
       6905
        
         - mios

     

       6900
       6906
        
         - mirror-tweet

     
···

       7184
       7190
        
         - network-server

     

       7185
       7191
        
         - network-service

     

       7186
       7192
        
         - network-simple-sockaddr

     

       7193
       7193
       +
         - network-simple-wss

     

       7187
       7194
        
         - network-stream

     

       7188
       7195
        
         - network-topic-models

     

       7189
       7196
        
         - network-transport-amqp

     
···

       7954
       7961
        
         - rascal

     

       7955
       7962
        
         - Rasenschach

     

       7956
       7963
        
         - rating-chgk-info

     

       7964
       7964
       +
         - rattle

     

       7957
       7965
        
         - rattletrap

     

       7958
       7966
        
         - raven-haskell-scotty

     

       7959
       7967
        
         - raw-feldspar

     
···

       8223
       8231
        
         - safe-failure-cme

     

       8224
       8232
        
         - safe-freeze

     

       8225
       8233
        
         - safe-globals

     

       8234
       8234
       +
         - safe-json

     

       8226
       8235
        
         - safe-lazy-io

     

       8227
       8236
        
         - safe-length

     

       8228
       8237
        
         - safe-money

     
···

       8478
       8487
        
         - shellish

     

       8479
       8488
        
         - shellmate

     

       8480
       8489
        
         - shellmate-extras

     

       8490
       8490
       +
         - shh

     

       8491
       8491
       +
         - shh-extras

     

       8481
       8492
        
         - shivers-cfg

     

       8482
       8493
        
         - shoap

     

       8483
       8494
        
         - shopify

     
···

       8526
       8537
        
         - simple-tar

     

       8527
       8538
        
         - simple-templates

     

       8528
       8539
        
         - simple-ui

     

       8540
       8540
       +
         - simple-units

     

       8529
       8541
        
         - simple-vec3

     

       8530
       8542
        
         - simple-zipper

     

       8531
       8543
        
         - simpleargs

     
···

       9834
       9846
        
         - yam

     

       9835
       9847
        
         - yam-datasource

     

       9836
       9848
        
         - yam-job

     

       9849
       9849
       +
         - yam-redis

     

       9837
       9850
        
         - yam-servant

     

       9838
       9851
        
         - yam-transaction-odbc

     

       9839
       9852
        
         - yam-web

+1727 -408

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

···

       942
       942
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       943
       943
        
            }) {};

     

       944
       944
        
       

     

       945
       945
       -
         "Allure_0_9_3_3" = callPackage

     

       945
       945
       +
         "Allure_0_9_4_1" = callPackage

     

       946
       946
        
           ({ mkDerivation, async, base, enummapset, filepath, ghc-compact

     

       947
       947
        
            , LambdaHack, optparse-applicative, primitive, random

     

       948
       948
        
            , template-haskell, text, transformers

     

       949
       949
        
            }:

     

       950
       950
        
            mkDerivation {

     

       951
       951
        
              pname = "Allure";

     

       952
       952
       -
              version = "0.9.3.3";

     

       953
       953
       -
              sha256 = "0s2f8fmcbcyvqg9vx492irr69ihkrwwf6nhp511b4y5xcgw69k12";

     

       952
       952
       +
              version = "0.9.4.1";

     

       953
       953
       +
              sha256 = "05zmidzwl24aqzgvnbv3hmsav7a6wq90qjhiirrbqpck3c33xqb9";

     

       954
       954
        
              isLibrary = true;

     

       955
       955
        
              isExecutable = true;

     

       956
       956
        
              enableSeparateDataOutput = true;

     
···

       6213
       6213
        
              broken = true;

     

       6214
       6214
        
            }) {};

     

       6215
       6215
        
       

     

       6216
       6216
       +
         "Frames-map-reduce" = callPackage

     

       6217
       6217
       +
           ({ mkDerivation, base, containers, foldl, Frames, hashable

     

       6218
       6218
       +
            , map-reduce-folds, newtype, profunctors, random, text, vinyl

     

       6219
       6219
       +
            }:

     

       6220
       6220
       +
            mkDerivation {

     

       6221
       6221
       +
              pname = "Frames-map-reduce";

     

       6222
       6222
       +
              version = "0.1.0.0";

     

       6223
       6223
       +
              sha256 = "05xk49qc5l8h7qnxhyxj9k2r2igcf7qc4njiw9w28fajlmnrgcw3";

     

       6224
       6224
       +
              isLibrary = true;

     

       6225
       6225
       +
              isExecutable = true;

     

       6226
       6226
       +
              libraryHaskellDepends = [

     

       6227
       6227
       +
                base containers foldl Frames hashable map-reduce-folds newtype

     

       6228
       6228
       +
                profunctors vinyl

     

       6229
       6229
       +
              ];

     

       6230
       6230
       +
              executableHaskellDepends = [ base foldl Frames random text vinyl ];

     

       6231
       6231
       +
              description = "Frames wrapper for map-reduce-folds and some extra folds helpers";

     

       6232
       6232
       +
              license = stdenv.lib.licenses.bsd3;

     

       6233
       6233
       +
            }) {};

     

       6234
       6234
       +
       

     

       6216
       6235
        
         "Frank" = callPackage

     

       6217
       6236
        
           ({ mkDerivation, base, mtl, newtype, she, void }:

     

       6218
       6237
        
            mkDerivation {

     
···

       11789
       11808
        
              broken = true;

     

       11790
       11809
        
            }) {};

     

       11791
       11810
        
       

     

       11792
       11792
       -
         "LambdaHack_0_9_3_1" = callPackage

     

       11811
       11811
       +
         "LambdaHack_0_9_4_1" = callPackage

     

       11793
       11812
        
           ({ mkDerivation, assert-failure, async, base, base-compat, binary

     

       11794
       11813
        
            , bytestring, containers, deepseq, directory, enummapset, filepath

     

       11795
       11814
        
            , ghc-compact, ghc-prim, hashable, hsini, keys, miniutter

     
···

       11799
       11818
        
            }:

     

       11800
       11819
        
            mkDerivation {

     

       11801
       11820
        
              pname = "LambdaHack";

     

       11802
       11802
       -
              version = "0.9.3.1";

     

       11803
       11803
       -
              sha256 = "1s1xz5iz81wdwxc1bmgbpj2s19qlvz1d5q7c2l01cdzqwd2iwn3f";

     

       11821
       11821
       +
              version = "0.9.4.1";

     

       11822
       11822
       +
              sha256 = "05p80yrfa5v5fq7zyhwpd8ndbw2kgc7a6i2hnikb222lna99b6gk";

     

       11804
       11823
        
              isLibrary = true;

     

       11805
       11824
        
              isExecutable = true;

     

       11806
       11825
        
              enableSeparateDataOutput = true;

     
···

       13224
       13243
        
              broken = true;

     

       13225
       13244
        
            }) {};

     

       13226
       13245
        
       

     

       13246
       13246
       +
         "Monadoro" = callPackage

     

       13247
       13247
       +
           ({ mkDerivation, ansi-terminal, base, process, time }:

     

       13248
       13248
       +
            mkDerivation {

     

       13249
       13249
       +
              pname = "Monadoro";

     

       13250
       13250
       +
              version = "0.1.2.0";

     

       13251
       13251
       +
              sha256 = "1bqaiarr5gv42xl8fww67iryyh1mscwdkgcahdc988y19ag8a4j9";

     

       13252
       13252
       +
              isLibrary = true;

     

       13253
       13253
       +
              isExecutable = true;

     

       13254
       13254
       +
              libraryHaskellDepends = [ ansi-terminal base process time ];

     

       13255
       13255
       +
              executableHaskellDepends = [ ansi-terminal base process time ];

     

       13256
       13256
       +
              testHaskellDepends = [ ansi-terminal base process time ];

     

       13257
       13257
       +
              description = "A minimalistic CLI Pomodoro timer, based on a library of the same purpose";

     

       13258
       13258
       +
              license = stdenv.lib.licenses.mit;

     

       13259
       13259
       +
            }) {};

     

       13260
       13260
       +
       

     

       13227
       13261
        
         "Monaris" = callPackage

     

       13228
       13262
        
           ({ mkDerivation, array, base, containers, directory, free

     

       13229
       13263
        
            , free-game, mtl

     
···

       13620
       13654
        
              description = "Naperian Functors for APL-like programming";

     

       13621
       13655
        
              license = "unknown";

     

       13622
       13656
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       13657
       13657
       +
            }) {};

     

       13658
       13658
       +
       

     

       13659
       13659
       +
         "NaperianNetCDF" = callPackage

     

       13660
       13660
       +
           ({ mkDerivation, base, hnetcdf, Naperian, split, vector }:

     

       13661
       13661
       +
            mkDerivation {

     

       13662
       13662
       +
              pname = "NaperianNetCDF";

     

       13663
       13663
       +
              version = "0.1.0.1";

     

       13664
       13664
       +
              sha256 = "0hyx9lg9hs124h9a666ym6cpnd3amdcl3v727shzc5v3hzwbvqgj";

     

       13665
       13665
       +
              isLibrary = true;

     

       13666
       13666
       +
              isExecutable = true;

     

       13667
       13667
       +
              libraryHaskellDepends = [ base hnetcdf Naperian vector ];

     

       13668
       13668
       +
              executableHaskellDepends = [ base hnetcdf Naperian split ];

     

       13669
       13669
       +
              description = "Instances of NcStore for hypercuboids";

     

       13670
       13670
       +
              license = stdenv.lib.licenses.bsd3;

     

       13623
       13671
        
            }) {};

     

       13624
       13672
        
       

     

       13625
       13673
        
         "NaturalLanguageAlphabets" = callPackage

     
···

       22198
       22246
        
              license = stdenv.lib.licenses.publicDomain;

     

       22199
       22247
        
            }) {};

     

       22200
       22248
        
       

     

       22249
       22249
       +
         "acme-this" = callPackage

     

       22250
       22250
       +
           ({ mkDerivation, base, template-haskell }:

     

       22251
       22251
       +
            mkDerivation {

     

       22252
       22252
       +
              pname = "acme-this";

     

       22253
       22253
       +
              version = "0.1.0.0";

     

       22254
       22254
       +
              sha256 = "16zmjrf849m066mnj7rlc10jcddy31ck83mg0b7pmn4cvp95q8k5";

     

       22255
       22255
       +
              revision = "1";

     

       22256
       22256
       +
              editedCabalFile = "1xizmz9yyhxkkaynlk9x0l1nv5maz0shk3d1ipaphc9c6q4b1mjq";

     

       22257
       22257
       +
              libraryHaskellDepends = [ base template-haskell ];

     

       22258
       22258
       +
              description = "import This";

     

       22259
       22259
       +
              license = stdenv.lib.licenses.bsd3;

     

       22260
       22260
       +
            }) {};

     

       22261
       22261
       +
       

     

       22201
       22262
        
         "acme-timemachine" = callPackage

     

       22202
       22263
        
           ({ mkDerivation, base, ghc-prim, mtl, transformers }:

     

       22203
       22264
        
            mkDerivation {

     
···

       22305
       22366
        
              pname = "active";

     

       22306
       22367
        
              version = "0.2.0.13";

     

       22307
       22368
        
              sha256 = "1yw029rh0gb63bhwwjynbv173mny14is4cyjkrlvzvxwb0fi96jx";

     

       22308
       22308
       -
              revision = "7";

     

       22309
       22309
       -
              editedCabalFile = "0z4l6j1q3y5zq4941bsb6ypkhfg3pyvb5gcmasymh2nj9g952xkd";

     

       22369
       22369
       +
              revision = "8";

     

       22370
       22370
       +
              editedCabalFile = "1j771jblfaygc3qf8iaw9b87yrqxhkq79mdi9zyhvlr2vcac362s";

     

       22310
       22371
        
              libraryHaskellDepends = [

     

       22311
       22372
        
                base lens linear semigroupoids semigroups vector

     

       22312
       22373
        
              ];

     
···

       27585
       27646
        
              license = stdenv.lib.licenses.bsd3;

     

       27586
       27647
        
            }) {};

     

       27587
       27648
        
       

     

       27649
       27649
       +
         "amqp_0_18_2" = callPackage

     

       27650
       27650
       +
           ({ mkDerivation, base, binary, bytestring, clock, connection

     

       27651
       27651
       +
            , containers, data-binary-ieee754, hspec, hspec-expectations

     

       27652
       27652
       +
            , monad-control, network, network-uri, split, stm, text, vector

     

       27653
       27653
       +
            , xml

     

       27654
       27654
       +
            }:

     

       27655
       27655
       +
            mkDerivation {

     

       27656
       27656
       +
              pname = "amqp";

     

       27657
       27657
       +
              version = "0.18.2";

     

       27658
       27658
       +
              sha256 = "0sp7c9vbgaxc5rhfc402q52djr0qpqgmfklhcrx45av2rqymkyxv";

     

       27659
       27659
       +
              isLibrary = true;

     

       27660
       27660
       +
              isExecutable = true;

     

       27661
       27661
       +
              libraryHaskellDepends = [

     

       27662
       27662
       +
                base binary bytestring clock connection containers

     

       27663
       27663
       +
                data-binary-ieee754 monad-control network network-uri split stm

     

       27664
       27664
       +
                text vector

     

       27665
       27665
       +
              ];

     

       27666
       27666
       +
              executableHaskellDepends = [ base containers xml ];

     

       27667
       27667
       +
              testHaskellDepends = [

     

       27668
       27668
       +
                base binary bytestring clock connection containers

     

       27669
       27669
       +
                data-binary-ieee754 hspec hspec-expectations network network-uri

     

       27670
       27670
       +
                split stm text vector

     

       27671
       27671
       +
              ];

     

       27672
       27672
       +
              description = "Client library for AMQP servers (currently only RabbitMQ)";

     

       27673
       27673
       +
              license = stdenv.lib.licenses.bsd3;

     

       27674
       27674
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       27675
       27675
       +
            }) {};

     

       27676
       27676
       +
       

     

       27588
       27677
        
         "amqp-conduit" = callPackage

     

       27589
       27678
        
           ({ mkDerivation, amqp, base, bytestring, conduit, exceptions, hspec

     

       27590
       27679
        
            , HUnit, lifted-base, monad-control, mtl, resourcet, text

     
···

       30093
       30182
        
              broken = true;

     

       30094
       30183
        
            }) {debian-mirror = null; help = null;};

     

       30095
       30184
        
       

     

       30185
       30185
       +
         "archive-sig" = callPackage

     

       30186
       30186
       +
           ({ mkDerivation, base, bytestring, composition-prelude, directory

     

       30187
       30187
       +
            , filepath

     

       30188
       30188
       +
            }:

     

       30189
       30189
       +
            mkDerivation {

     

       30190
       30190
       +
              pname = "archive-sig";

     

       30191
       30191
       +
              version = "0.2.0.0";

     

       30192
       30192
       +
              sha256 = "1imbailszvxahmhxg9g0qrygi6433gmyg5pby3zq9k5gcc16mmy2";

     

       30193
       30193
       +
              libraryHaskellDepends = [

     

       30194
       30194
       +
                base bytestring composition-prelude directory filepath

     

       30195
       30195
       +
              ];

     

       30196
       30196
       +
              description = "Backpack signature for archive libraries";

     

       30197
       30197
       +
              license = stdenv.lib.licenses.bsd3;

     

       30198
       30198
       +
            }) {};

     

       30199
       30199
       +
       

     

       30200
       30200
       +
         "archive-tar" = callPackage

     

       30201
       30201
       +
           ({ mkDerivation, base, bytestring, composition-prelude, tar }:

     

       30202
       30202
       +
            mkDerivation {

     

       30203
       30203
       +
              pname = "archive-tar";

     

       30204
       30204
       +
              version = "0.2.0.0";

     

       30205
       30205
       +
              sha256 = "0svbxr9734ysskilv5kvhfd7s436spn149pb5bcsq3hjz1zq5xq7";

     

       30206
       30206
       +
              libraryHaskellDepends = [

     

       30207
       30207
       +
                base bytestring composition-prelude tar

     

       30208
       30208
       +
              ];

     

       30209
       30209
       +
              description = "Common interface using the tar package";

     

       30210
       30210
       +
              license = stdenv.lib.licenses.bsd3;

     

       30211
       30211
       +
            }) {};

     

       30212
       30212
       +
       

     

       30096
       30213
        
         "archiver" = callPackage

     

       30097
       30214
        
           ({ mkDerivation, base, bytestring, containers, curl, HTTP, network

     

       30098
       30215
        
            , process, random

     
···

       32389
       32506
        
       

     

       32390
       32507
        
         "attoparsec-data" = callPackage

     

       32391
       32508
        
           ({ mkDerivation, attoparsec, attoparsec-time, base, base-prelude

     

       32392
       32392
       -
            , bytestring, scientific, text, time

     

       32509
       32509
       +
            , bytestring, scientific, text, time, uuid

     

       32393
       32510
        
            }:

     

       32394
       32511
        
            mkDerivation {

     

       32395
       32512
        
              pname = "attoparsec-data";

     

       32396
       32396
       -
              version = "1.0.3";

     

       32397
       32397
       -
              sha256 = "02bkrbdipd0940aq34dx4156z538jbfxpgdk3pkbb6vjdcghcw9g";

     

       32513
       32513
       +
              version = "1.0.4";

     

       32514
       32514
       +
              sha256 = "03pgzx7l9hh8233r8afhgbk0adw58pln3si83vmrv1h6d8s2x4nr";

     

       32398
       32515
        
              libraryHaskellDepends = [

     

       32399
       32516
        
                attoparsec attoparsec-time base base-prelude bytestring scientific

     

       32400
       32400
       -
                text time

     

       32517
       32517
       +
                text time uuid

     

       32401
       32518
        
              ];

     

       32402
       32519
        
              description = "Parsers for the standard Haskell data types";

     

       32403
       32520
        
              license = stdenv.lib.licenses.mit;

     
···

       33294
       33411
        
           ({ mkDerivation, aeson, array, base, base16-bytestring, bifunctors

     

       33295
       33412
        
            , binary, bytestring, containers, data-binary-ieee754, deepseq

     

       33296
       33413
        
            , directory, extra, fail, gauge, hashable, hspec, hspec-discover

     

       33297
       33297
       -
            , lens, lens-aeson, mtl, pure-zlib, QuickCheck, random, scientific

     

       33298
       33298
       -
            , semigroups, tagged, template-haskell, text, tf-random

     

       33299
       33299
       -
            , transformers, unordered-containers, vector, zlib

     

       33414
       33414
       +
            , lens, lens-aeson, mtl, pure-zlib, QuickCheck, random

     

       33415
       33415
       +
            , raw-strings-qq, scientific, semigroups, tagged, template-haskell

     

       33416
       33416
       +
            , text, tf-random, transformers, unordered-containers, vector, zlib

     

       33300
       33417
        
            }:

     

       33301
       33418
        
            mkDerivation {

     

       33302
       33419
        
              pname = "avro";

     

       33303
       33303
       -
              version = "0.4.4.1";

     

       33304
       33304
       -
              sha256 = "12mrgjhms4m9zjax6zqlzn9cisdr482sa642xh5p9h6hdp86ay59";

     

       33420
       33420
       +
              version = "0.4.4.2";

     

       33421
       33421
       +
              sha256 = "1x01f05rhz4nhvzbzai5817c9ajqnph1vfn0z8cp4y7r4srm55w0";

     

       33305
       33422
        
              libraryHaskellDepends = [

     

       33306
       33423
        
                aeson array base base16-bytestring bifunctors binary bytestring

     

       33307
       33424
        
                containers data-binary-ieee754 deepseq fail hashable mtl scientific

     
···

       33311
       33428
        
              testHaskellDepends = [

     

       33312
       33429
        
                aeson array base base16-bytestring bifunctors binary bytestring

     

       33313
       33430
        
                containers directory extra fail hashable hspec lens lens-aeson mtl

     

       33314
       33314
       -
                pure-zlib QuickCheck scientific semigroups tagged template-haskell

     

       33315
       33315
       -
                text tf-random transformers unordered-containers vector

     

       33431
       33431
       +
                pure-zlib QuickCheck raw-strings-qq scientific semigroups tagged

     

       33432
       33432
       +
                template-haskell text tf-random transformers unordered-containers

     

       33433
       33433
       +
                vector

     

       33316
       33434
        
              ];

     

       33317
       33435
        
              testToolDepends = [ hspec-discover ];

     

       33318
       33436
        
              benchmarkHaskellDepends = [

     

       33319
       33319
       -
                aeson base bytestring containers gauge hashable mtl random text

     

       33320
       33320
       -
                transformers unordered-containers vector

     

       33437
       33437
       +
                aeson base bytestring containers gauge hashable mtl random

     

       33438
       33438
       +
                raw-strings-qq text transformers unordered-containers vector

     

       33321
       33439
        
              ];

     

       33322
       33440
        
              description = "Avro serialization support for Haskell";

     

       33323
       33441
        
              license = stdenv.lib.licenses.bsd3;

     
···

       41903
       42021
        
              broken = true;

     

       41904
       42022
        
            }) {};

     

       41905
       42023
        
       

     

       42024
       42024
       +
         "brotli" = callPackage

     

       42025
       42025
       +
           ({ mkDerivation, base, bytestring, HUnit, libbrotlidec

     

       42026
       42026
       +
            , libbrotlienc, QuickCheck, tasty, tasty-hunit, tasty-quickcheck

     

       42027
       42027
       +
            , transformers

     

       42028
       42028
       +
            }:

     

       42029
       42029
       +
            mkDerivation {

     

       42030
       42030
       +
              pname = "brotli";

     

       42031
       42031
       +
              version = "0.0.0.0";

     

       42032
       42032
       +
              sha256 = "1l9qiw5cl0k1rcnqnj9pb7vgj1b06wckkk5i73nqr15ixgcjmr9j";

     

       42033
       42033
       +
              libraryHaskellDepends = [ base bytestring transformers ];

     

       42034
       42034
       +
              libraryPkgconfigDepends = [ libbrotlidec libbrotlienc ];

     

       42035
       42035
       +
              testHaskellDepends = [

     

       42036
       42036
       +
                base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck

     

       42037
       42037
       +
              ];

     

       42038
       42038
       +
              description = "Brotli (RFC7932) compression and decompression";

     

       42039
       42039
       +
              license = stdenv.lib.licenses.gpl3;

     

       42040
       42040
       +
            }) {libbrotlidec = null; libbrotlienc = null;};

     

       42041
       42041
       +
       

     

       42042
       42042
       +
         "brotli-conduit" = callPackage

     

       42043
       42043
       +
           ({ mkDerivation, base, brotli, bytestring, conduit, HUnit

     

       42044
       42044
       +
            , QuickCheck, resourcet, test-framework, test-framework-hunit

     

       42045
       42045
       +
            , test-framework-quickcheck2, transformers

     

       42046
       42046
       +
            }:

     

       42047
       42047
       +
            mkDerivation {

     

       42048
       42048
       +
              pname = "brotli-conduit";

     

       42049
       42049
       +
              version = "0.0.0.0";

     

       42050
       42050
       +
              sha256 = "00hl8g4aw4klzvq8gbgx3ff5iq5diz7lxk9ssn7q8icdpl8w5fbf";

     

       42051
       42051
       +
              libraryHaskellDepends = [

     

       42052
       42052
       +
                base brotli bytestring conduit resourcet transformers

     

       42053
       42053
       +
              ];

     

       42054
       42054
       +
              testHaskellDepends = [

     

       42055
       42055
       +
                base bytestring conduit HUnit QuickCheck resourcet test-framework

     

       42056
       42056
       +
                test-framework-hunit test-framework-quickcheck2

     

       42057
       42057
       +
              ];

     

       42058
       42058
       +
              description = "Conduit interface for Brotli (RFC7932) compression";

     

       42059
       42059
       +
              license = stdenv.lib.licenses.bsd3;

     

       42060
       42060
       +
            }) {};

     

       42061
       42061
       +
       

     

       42062
       42062
       +
         "brotli-streams" = callPackage

     

       42063
       42063
       +
           ({ mkDerivation, base, brotli, bytestring, HUnit, io-streams

     

       42064
       42064
       +
            , QuickCheck, test-framework, test-framework-hunit

     

       42065
       42065
       +
            , test-framework-quickcheck2

     

       42066
       42066
       +
            }:

     

       42067
       42067
       +
            mkDerivation {

     

       42068
       42068
       +
              pname = "brotli-streams";

     

       42069
       42069
       +
              version = "0.0.0.0";

     

       42070
       42070
       +
              sha256 = "14jc1nhm50razsl99d95amdf4njf75dnzx8vqkihgrgp7qisyz3z";

     

       42071
       42071
       +
              libraryHaskellDepends = [ base brotli bytestring io-streams ];

     

       42072
       42072
       +
              testHaskellDepends = [

     

       42073
       42073
       +
                base bytestring HUnit io-streams QuickCheck test-framework

     

       42074
       42074
       +
                test-framework-hunit test-framework-quickcheck2

     

       42075
       42075
       +
              ];

     

       42076
       42076
       +
              description = "IO-Streams interface for Brotli (RFC7932) compression";

     

       42077
       42077
       +
              license = stdenv.lib.licenses.bsd3;

     

       42078
       42078
       +
            }) {};

     

       42079
       42079
       +
       

     

       41906
       42080
        
         "browscap" = callPackage

     

       41907
       42081
        
           ({ mkDerivation, base, bytestring, deepseq, ini, lens, lrucache

     

       41908
       42082
        
            , mtl, text, unordered-containers, wreq

     
···

       42821
       42995
        
            }:

     

       42822
       42996
        
            mkDerivation {

     

       42823
       42997
        
              pname = "byline";

     

       42824
       42824
       -
              version = "0.3.2.0";

     

       42825
       42825
       -
              sha256 = "100s2f4w0lgnsjgjazck7hnbk3k9ibg1i4rdcyza9jphp67vjgar";

     

       42998
       42998
       +
              version = "0.3.2.1";

     

       42999
       42999
       +
              sha256 = "196c75i7cz7yww3d5pi5p51wd5bf3a8v8nsb2vkiv25ndwrsb20w";

     

       42826
       43000
        
              isLibrary = true;

     

       42827
       43001
        
              isExecutable = true;

     

       42828
       43002
        
              libraryHaskellDepends = [

     
···

       46591
       46765
        
            }:

     

       46592
       46766
        
            mkDerivation {

     

       46593
       46767
        
              pname = "cassava-streams";

     

       46594
       46594
       -
              version = "0.3.0.3";

     

       46595
       46595
       -
              sha256 = "01s0h2mi9b4h3jy405jvz2an8w6fdvg370mizfk910anx7wsa3ix";

     

       46768
       46768
       +
              version = "0.3.0.4";

     

       46769
       46769
       +
              sha256 = "17g3qrinzfpmbcqyjrnwaycplmys0p93hb6841cp5rr1pjramb55";

     

       46596
       46770
        
              isLibrary = true;

     

       46597
       46771
        
              isExecutable = true;

     

       46598
       46772
        
              libraryHaskellDepends = [

     
···

       55490
       55664
        
              pname = "connection";

     

       55491
       55665
        
              version = "0.2.8";

     

       55492
       55666
        
              sha256 = "1swkb9w5vx9ph7x55y51dc0srj2z27nd9ibgn8c0qcl6hx7g9cbh";

     

       55493
       55493
       -
              revision = "1";

     

       55494
       55494
       -
              editedCabalFile = "15qdwqqjv60w14m319a58yjmhzr39dydsnk6r26ydkwxwh23rk73";

     

       55667
       55667
       +
              revision = "2";

     

       55668
       55668
       +
              editedCabalFile = "0bhwcd9dqa2jk23bdz3z3vn2p1gzssinp96dxzznb7af4y5x2gmk";

     

       55495
       55669
        
              libraryHaskellDepends = [

     

       55496
       55670
        
                base byteable bytestring containers data-default-class network

     

       55497
       55671
        
                socks tls x509 x509-store x509-system x509-validation

     

       55498
       55672
        
              ];

     

       55499
       55673
        
              description = "Simple and easy network connections API";

     

       55500
       55674
        
              license = stdenv.lib.licenses.bsd3;

     

       55675
       55675
       +
            }) {};

     

       55676
       55676
       +
       

     

       55677
       55677
       +
         "connection_0_3_0" = callPackage

     

       55678
       55678
       +
           ({ mkDerivation, base, basement, bytestring, containers

     

       55679
       55679
       +
            , data-default-class, network, socks, tls, x509, x509-store

     

       55680
       55680
       +
            , x509-system, x509-validation

     

       55681
       55681
       +
            }:

     

       55682
       55682
       +
            mkDerivation {

     

       55683
       55683
       +
              pname = "connection";

     

       55684
       55684
       +
              version = "0.3.0";

     

       55685
       55685
       +
              sha256 = "1f53bysp8zr8c8dhivrq2k9qmlwnk84d4c1s31sd62ws9yddcw34";

     

       55686
       55686
       +
              revision = "1";

     

       55687
       55687
       +
              editedCabalFile = "0cm421anscv6h4nvhkaqvi5s3lwkc0f34p6z8lzap4wyc4gv578k";

     

       55688
       55688
       +
              libraryHaskellDepends = [

     

       55689
       55689
       +
                base basement bytestring containers data-default-class network

     

       55690
       55690
       +
                socks tls x509 x509-store x509-system x509-validation

     

       55691
       55691
       +
              ];

     

       55692
       55692
       +
              description = "Simple and easy network connections API";

     

       55693
       55693
       +
              license = stdenv.lib.licenses.bsd3;

     

       55694
       55694
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       55501
       55695
        
            }) {};

     

       55502
       55696
        
       

     

       55503
       55697
        
         "connection-pool" = callPackage

     
···

       57417
       57611
        
            }) {};

     

       57418
       57612
        
       

     

       57419
       57613
        
         "cpkg" = callPackage

     

       57420
       57420
       -
           ({ mkDerivation, base, binary, bytestring, bzlib

     

       57421
       57421
       -
            , composition-prelude, containers, cpphs, dhall, directory

     

       57422
       57422
       -
            , filemanip, filepath, hashable, hspec, hspec-megaparsec

     

       57423
       57423
       -
            , http-client, http-client-tls, libarchive, lzma, megaparsec

     

       57424
       57424
       -
            , microlens, mtl, network-uri, optparse-applicative, prettyprinter

     

       57425
       57425
       -
            , process, recursion, tar, temporary, text, zip-archive, zlib

     

       57614
       57614
       +
           ({ mkDerivation, base, binary, bytestring, bzlib, containers, cpphs

     

       57615
       57615
       +
            , dhall, directory, filemanip, filepath, hashable, hspec

     

       57616
       57616
       +
            , hspec-megaparsec, http-client, http-client-tls, libarchive, lzma

     

       57617
       57617
       +
            , megaparsec, microlens, mtl, network-uri, optparse-applicative

     

       57618
       57618
       +
            , prettyprinter, process, recursion, tar, temporary, text

     

       57619
       57619
       +
            , zip-archive, zlib

     

       57426
       57620
        
            }:

     

       57427
       57621
        
            mkDerivation {

     

       57428
       57622
        
              pname = "cpkg";

     

       57429
       57429
       -
              version = "0.1.1.1";

     

       57430
       57430
       -
              sha256 = "06nwkys90i0rdhg1nvwzii88z5f3ijn9kjwrg6lgy2m973zr8668";

     

       57431
       57431
       -
              revision = "1";

     

       57432
       57432
       -
              editedCabalFile = "0dqfgr06mv9xmqs2whzklzgj9ny17ncm6202bhykh9xp8qvzfbyy";

     

       57623
       57623
       +
              version = "0.1.2.1";

     

       57624
       57624
       +
              sha256 = "1wn084r71fq3kx5qjvsg7l7v4njsfxbp1s4rv7f3dgyh7h36xgjj";

     

       57433
       57625
        
              isLibrary = true;

     

       57434
       57626
        
              isExecutable = true;

     

       57435
       57627
        
              libraryHaskellDepends = [

     

       57436
       57436
       -
                base binary bytestring bzlib composition-prelude containers dhall

     

       57437
       57437
       -
                directory filemanip filepath hashable http-client http-client-tls

     

       57438
       57438
       -
                libarchive lzma megaparsec microlens mtl network-uri prettyprinter

     

       57439
       57439
       -
                process recursion tar temporary text zip-archive zlib

     

       57628
       57628
       +
                base binary bytestring bzlib containers dhall directory filemanip

     

       57629
       57629
       +
                filepath hashable http-client http-client-tls libarchive lzma

     

       57630
       57630
       +
                megaparsec microlens mtl network-uri prettyprinter process

     

       57631
       57631
       +
                recursion tar temporary text zip-archive zlib

     

       57440
       57632
        
              ];

     

       57441
       57633
        
              libraryToolDepends = [ cpphs ];

     

       57442
       57634
        
              executableHaskellDepends = [

     
···

       61394
       61586
        
              license = stdenv.lib.licenses.bsd3;

     

       61395
       61587
        
            }) {};

     

       61396
       61588
        
       

     

       61589
       61589
       +
         "data-compat" = callPackage

     

       61590
       61590
       +
           ({ mkDerivation, base, constraints }:

     

       61591
       61591
       +
            mkDerivation {

     

       61592
       61592
       +
              pname = "data-compat";

     

       61593
       61593
       +
              version = "0.1.0.0";

     

       61594
       61594
       +
              sha256 = "0j9gx0sg2bwqigw9w3kg286bm6imqa35jkgkzagdjg9mfkgy6kwy";

     

       61595
       61595
       +
              libraryHaskellDepends = [ base constraints ];

     

       61596
       61596
       +
              description = "Define Backwards Compatibility Schemes for Arbitrary Data";

     

       61597
       61597
       +
              license = stdenv.lib.licenses.mit;

     

       61598
       61598
       +
            }) {};

     

       61599
       61599
       +
       

     

       61397
       61600
        
         "data-concurrent-queue" = callPackage

     

       61398
       61601
        
           ({ mkDerivation, base, stm }:

     

       61399
       61602
        
            mkDerivation {

     
···

       62932
       63135
        
            }:

     

       62933
       63136
        
            mkDerivation {

     

       62934
       63137
        
              pname = "datadog-tracing";

     

       62935
       62935
       -
              version = "1.4.0";

     

       62936
       62936
       -
              sha256 = "02gdkh7yxjh2lnjjm4cgpabl0ywwqs145gd5in6s22999chf0hif";

     

       63138
       63138
       +
              version = "1.4.2";

     

       63139
       63139
       +
              sha256 = "1yrig10a38sy6zkj18snqiv4r7b1gd16xk3ni9jm8vn7ls7niwcc";

     

       62937
       63140
        
              isLibrary = true;

     

       62938
       63141
        
              isExecutable = true;

     

       62939
       63142
        
              libraryHaskellDepends = [

     
···

       66424
       66627
        
              pname = "diagrams-contrib";

     

       66425
       66628
        
              version = "1.4.3";

     

       66426
       66629
        
              sha256 = "01r081rvxkb9i56iqi28zw4054nm62pf9f1szd9i0avmnxxsiyv5";

     

       66427
       66427
       -
              revision = "2";

     

       66428
       66428
       -
              editedCabalFile = "0xpw4myq4n6k5lxdll1wg76m3gfymwb746x6qd48qfy3z22nrymw";

     

       66630
       66630
       +
              revision = "3";

     

       66631
       66631
       +
              editedCabalFile = "0mm1mmagx6q8g6dxk1cagqka38z6393ihp0lvf6095prlvidasqs";

     

       66429
       66632
        
              libraryHaskellDepends = [

     

       66430
       66633
        
                base circle-packing colour containers cubicbezier data-default

     

       66431
       66634
        
                data-default-class diagrams-core diagrams-lib diagrams-solve

     
···

       67892
       68095
        
              license = stdenv.lib.licenses.bsd3;

     

       67893
       68096
        
            }) {};

     

       67894
       68097
        
       

     

       68098
       68098
       +
         "direm" = callPackage

     

       68099
       68099
       +
           ({ mkDerivation, base, directory }:

     

       68100
       68100
       +
            mkDerivation {

     

       68101
       68101
       +
              pname = "direm";

     

       68102
       68102
       +
              version = "0.1.0.0";

     

       68103
       68103
       +
              sha256 = "048503bgikwffvqa00yxawr1lmqy523i9zvs05dyim6v927m1fmx";

     

       68104
       68104
       +
              isLibrary = false;

     

       68105
       68105
       +
              isExecutable = true;

     

       68106
       68106
       +
              executableHaskellDepends = [ base directory ];

     

       68107
       68107
       +
              description = "Deletes a directory and retains its contents in the parent directory";

     

       68108
       68108
       +
              license = stdenv.lib.licenses.gpl3;

     

       68109
       68109
       +
            }) {};

     

       68110
       68110
       +
       

     

       67895
       68111
        
         "dirfiles" = callPackage

     

       67896
       68112
        
           ({ mkDerivation, aeson, base, containers, hblock, safecopy, text

     

       67897
       68113
        
            , time, unordered-containers

     
···

       67989
       68205
        
            }:

     

       67990
       68206
        
            mkDerivation {

     

       67991
       68207
        
              pname = "discord-haskell";

     

       67992
       67992
       -
              version = "0.8.1";

     

       67993
       67993
       -
              sha256 = "0r7nlivcrqazjgsh54k8qrl64h7065c9vdg4ndv8bahvxvw1ld8r";

     

       68208
       68208
       +
              version = "0.8.2";

     

       68209
       68209
       +
              sha256 = "0ig8qwz0qgr41x5rk59npgkyd9d2g15xvmhnq4igxzaql0b2f0pl";

     

       67994
       68210
        
              libraryHaskellDepends = [

     

       67995
       68211
        
                aeson async base base64-bytestring bytestring containers

     

       67996
       68212
        
                data-default http-client iso8601-time JuicyPixels MonadRandom req

     
···

       71294
       71510
        
              broken = true;

     

       71295
       71511
        
            }) {};

     

       71296
       71512
        
       

     

       71513
       71513
       +
         "dura" = callPackage

     

       71514
       71514
       +
           ({ mkDerivation, base, bytestring, directory, filepath }:

     

       71515
       71515
       +
            mkDerivation {

     

       71516
       71516
       +
              pname = "dura";

     

       71517
       71517
       +
              version = "0.1";

     

       71518
       71518
       +
              sha256 = "0sm5f8678lym1maavvx0jsl0px3phry6687wsvf5askbrdyla84m";

     

       71519
       71519
       +
              revision = "1";

     

       71520
       71520
       +
              editedCabalFile = "018pwi48hx6jcy9gkbbc4gcbjxa2n8b4lbfmd18mnm49ymwyyqlv";

     

       71521
       71521
       +
              libraryHaskellDepends = [ base bytestring directory filepath ];

     

       71522
       71522
       +
              description = "durable/atomic file system writes (from rio package)";

     

       71523
       71523
       +
              license = stdenv.lib.licenses.bsd3;

     

       71524
       71524
       +
            }) {};

     

       71525
       71525
       +
       

     

       71297
       71526
        
         "duration" = callPackage

     

       71298
       71527
        
           ({ mkDerivation, base, doctest, hspec, parsec, template-haskell

     

       71299
       71528
        
            , time

     
···

       73099
       73328
        
              pname = "ekg-prometheus-adapter";

     

       73100
       73329
        
              version = "0.1.0.4";

     

       73101
       73330
        
              sha256 = "1i9bqbn8zj7hbkc7iypmjji4sh8s2h9jix2ngp77mkmii6wblfx2";

     

       73331
       73331
       +
              revision = "1";

     

       73332
       73332
       +
              editedCabalFile = "1aq3x5j33bb0rwlip0p3y6ppk8m1x8k3hnrwnb7pca98gyz8fm6r";

     

       73102
       73333
        
              libraryHaskellDepends = [

     

       73103
       73334
        
                base containers ekg-core microlens-th prometheus text transformers

     

       73104
       73335
        
                unordered-containers

     
···

       74635
       74866
        
              pname = "enummapset-th";

     

       74636
       74867
        
              version = "0.6.1.1";

     

       74637
       74868
        
              sha256 = "0anmarswk8vvd9c8qhkhgwzmr5h2yq0bdx48ww5lbca1zf6h5hkw";

     

       74869
       74869
       +
              revision = "1";

     

       74870
       74870
       +
              editedCabalFile = "0fyjwcw7ibm0x5k2281q53drwm1ddsmkc890fywcv7r6b9jdx5py";

     

       74638
       74871
        
              libraryHaskellDepends = [

     

       74639
       74872
        
                base containers deepseq template-haskell

     

       74640
       74873
        
              ];

     
···

       76699
       76932
        
           ({ mkDerivation, base, template-haskell }:

     

       76700
       76933
        
            mkDerivation {

     

       76701
       76934
        
              pname = "exception-hierarchy";

     

       76702
       76702
       -
              version = "0.1.0.1";

     

       76703
       76703
       -
              sha256 = "1zk06z8fwr4g701c79vvsqmagjcm2h850d9m96zrig08kz3lshm9";

     

       76935
       76935
       +
              version = "0.1.0.2";

     

       76936
       76936
       +
              sha256 = "1srzc1dz3cpplxsqjiw3iiy0jnwyc57qxmdgibkkymjlaksi721i";

     

       76704
       76937
        
              libraryHaskellDepends = [ base template-haskell ];

     

       76705
       76938
        
              description = "Exception type hierarchy with TemplateHaskell";

     

       76706
       76939
        
              license = stdenv.lib.licenses.bsd3;

     
···

       77724
       77957
        
            }:

     

       77725
       77958
        
            mkDerivation {

     

       77726
       77959
        
              pname = "extensible-effects-concurrent";

     

       77727
       77727
       -
              version = "0.21.1";

     

       77728
       77728
       -
              sha256 = "1ijk6z4g6y5bfif5rv3w3ld2rfm1ad1sqqicpx9n6lkvh0awc3vp";

     

       77960
       77960
       +
              version = "0.22.1";

     

       77961
       77961
       +
              sha256 = "1vjd8rr60zxgvv96i9fx5vjbvvxagj8fxz6891irmjgxhlb1v75z";

     

       77729
       77962
        
              isLibrary = true;

     

       77730
       77963
        
              isExecutable = true;

     

       77731
       77964
        
              libraryHaskellDepends = [

     
···

       77801
       78034
        
              license = stdenv.lib.licenses.bsd3;

     

       77802
       78035
        
            }) {};

     

       77803
       78036
        
       

     

       78037
       78037
       +
         "extra_1_6_15" = callPackage

     

       78038
       78038
       +
           ({ mkDerivation, base, clock, directory, filepath, process

     

       78039
       78039
       +
            , QuickCheck, semigroups, time, unix

     

       78040
       78040
       +
            }:

     

       78041
       78041
       +
            mkDerivation {

     

       78042
       78042
       +
              pname = "extra";

     

       78043
       78043
       +
              version = "1.6.15";

     

       78044
       78044
       +
              sha256 = "1kbx15x1y6mdzydm4apizym89in4dd71imwk239ywyg27hl8f4gv";

     

       78045
       78045
       +
              libraryHaskellDepends = [

     

       78046
       78046
       +
                base clock directory filepath process semigroups time unix

     

       78047
       78047
       +
              ];

     

       78048
       78048
       +
              testHaskellDepends = [ base directory filepath QuickCheck unix ];

     

       78049
       78049
       +
              description = "Extra functions I use";

     

       78050
       78050
       +
              license = stdenv.lib.licenses.bsd3;

     

       78051
       78051
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       78052
       78052
       +
            }) {};

     

       78053
       78053
       +
       

     

       77804
       78054
        
         "extract-dependencies" = callPackage

     

       77805
       78055
        
           ({ mkDerivation, async, base, Cabal, containers

     

       77806
       78056
        
            , package-description-remote

     
···

       79327
       79577
        
            }:

     

       79328
       79578
        
            mkDerivation {

     

       79329
       79579
        
              pname = "fedora-img-dl";

     

       79330
       79330
       -
              version = "0.2";

     

       79331
       79331
       -
              sha256 = "0jk9wljmqszfjr4alhx13112bbdgi84662v1f1fslq8w0q17y3m2";

     

       79580
       79580
       +
              version = "0.3";

     

       79581
       79581
       +
              sha256 = "0mly2lmrirzskralw9ajywmcirmsv67gjws4dckvf1ns24cx33lw";

     

       79332
       79582
        
              isLibrary = false;

     

       79333
       79583
        
              isExecutable = true;

     

       79334
       79584
        
              executableHaskellDepends = [

     
···

       79916
       80166
        
            }:

     

       79917
       80167
        
            mkDerivation {

     

       79918
       80168
        
              pname = "ffunctor";

     

       79919
       79919
       -
              version = "1.1.99";

     

       79920
       79920
       -
              sha256 = "0b6r72921cr6xrwwnvlw7ndnhfyavrk5a4vsgz3xvisf3i0slb4c";

     

       79921
       79921
       -
              revision = "2";

     

       79922
       79922
       -
              editedCabalFile = "0772irhfscf3bkxgiy33g7np8wrkdc8pzc7pnap362qvd8v2xkjj";

     

       80169
       80169
       +
              version = "1.1.100";

     

       80170
       80170
       +
              sha256 = "07s9ax9pi8bxvj94dfh237wfxdmx63gglkw8cx7pn2w1jybpb8v9";

     

       79923
       80171
        
              libraryHaskellDepends = [ base transformers ];

     

       79924
       80172
        
              testHaskellDepends = [

     

       79925
       80173
        
                aeson base exceptions generic-lens http-client mtl servant

     
···

       80951
       81199
        
              broken = true;

     

       80952
       81200
        
            }) {};

     

       80953
       81201
        
       

     

       81202
       81202
       +
         "fits-parse" = callPackage

     

       81203
       81203
       +
           ({ mkDerivation, base, binary, bytestring, data-default

     

       81204
       81204
       +
            , fast-logger, JuicyPixels, megaparsec, optparse-applicative

     

       81205
       81205
       +
            , parser-combinators, statistics, text, text-latin1, vector

     

       81206
       81206
       +
            }:

     

       81207
       81207
       +
            mkDerivation {

     

       81208
       81208
       +
              pname = "fits-parse";

     

       81209
       81209
       +
              version = "0.0.1";

     

       81210
       81210
       +
              sha256 = "13a072ribpn10hfiiqkx2bkns8rjcsf32zx4lsvxzfhm7p24p499";

     

       81211
       81211
       +
              isLibrary = true;

     

       81212
       81212
       +
              isExecutable = true;

     

       81213
       81213
       +
              libraryHaskellDepends = [

     

       81214
       81214
       +
                base binary bytestring data-default megaparsec parser-combinators

     

       81215
       81215
       +
                text text-latin1

     

       81216
       81216
       +
              ];

     

       81217
       81217
       +
              executableHaskellDepends = [

     

       81218
       81218
       +
                base bytestring fast-logger JuicyPixels optparse-applicative

     

       81219
       81219
       +
                statistics vector

     

       81220
       81220
       +
              ];

     

       81221
       81221
       +
              description = "Parse FITS files";

     

       81222
       81222
       +
              license = stdenv.lib.licenses.bsd2;

     

       81223
       81223
       +
            }) {};

     

       81224
       81224
       +
       

     

       80954
       81225
        
         "fitsio" = callPackage

     

       80955
       81226
        
           ({ mkDerivation, base, cfitsio, filepath, mtl }:

     

       80956
       81227
        
            mkDerivation {

     
···

       81629
       81900
        
           ({ mkDerivation, base, directory, parsec }:

     

       81630
       81901
        
            mkDerivation {

     

       81631
       81902
        
              pname = "flat-tex";

     

       81632
       81632
       -
              version = "0.6.1";

     

       81633
       81633
       -
              sha256 = "1g116pdjlxx8mz3w2bapbcfd4jgk8jl24fg7fck3j2gyh8282zbm";

     

       81903
       81903
       +
              version = "0.7.0";

     

       81904
       81904
       +
              sha256 = "19djkalk3pw309y8ngia88qrppm3c6128db7lk7q6l0w18vrnb9d";

     

       81634
       81905
        
              isLibrary = false;

     

       81635
       81906
        
              isExecutable = true;

     

       81636
       81907
        
              executableHaskellDepends = [ base directory parsec ];

     
···

       84674
       84945
        
            }) {};

     

       84675
       84946
        
       

     

       84676
       84947
        
         "front" = callPackage

     

       84677
       84677
       -
           ({ mkDerivation, base, blaze-html, blaze-markup, bytestring, fay

     

       84678
       84678
       -
            , text

     

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

     

       84949
       84949
       +
            , bytestring, conduit, fay, fay-dom, fay-websockets, mtl, stm

     

       84950
       84950
       +
            , stm-lifted, text, websockets

     

       84679
       84951
        
            }:

     

       84680
       84952
        
            mkDerivation {

     

       84681
       84953
        
              pname = "front";

     

       84682
       84682
       -
              version = "0.0.0.1";

     

       84683
       84683
       -
              sha256 = "1iaabr2cfvgismar58w7nazi4mckcvxv37qrkjqnxm82zhnv2fgc";

     

       84954
       84954
       +
              version = "0.0.0.2";

     

       84955
       84955
       +
              sha256 = "106y0qnz5lyvxy69s24fapqkys6i373kl2v51bpkvfwq5ppax0b0";

     

       84956
       84956
       +
              isLibrary = true;

     

       84957
       84957
       +
              isExecutable = true;

     

       84684
       84958
        
              libraryHaskellDepends = [

     

       84685
       84685
       -
                base blaze-html blaze-markup bytestring fay text

     

       84959
       84959
       +
                aeson async base blaze-html blaze-markup bytestring conduit fay

     

       84960
       84960
       +
                fay-dom fay-websockets mtl stm stm-lifted text websockets

     

       84686
       84961
        
              ];

     

       84687
       84962
        
              description = "A reactive frontend web framework";

     

       84688
       84963
        
              license = stdenv.lib.licenses.bsd3;

     
···

       85165
       85440
        
              pname = "full-text-search";

     

       85166
       85441
        
              version = "0.2.1.4";

     

       85167
       85442
        
              sha256 = "1qbfklpyxdf5d4d5s1ka9s5a43y892387b0lyjsx9fq3g6d2vck7";

     

       85443
       85443
       +
              revision = "1";

     

       85444
       85444
       +
              editedCabalFile = "0dma678xflfplrld48aca1p9kjnnwlsqdrqmkgwh9dp54wrxzxl1";

     

       85168
       85445
        
              isLibrary = true;

     

       85169
       85446
        
              isExecutable = true;

     

       85170
       85447
        
              libraryHaskellDepends = [ array base containers text vector ];

     
···

       85753
       86030
        
              license = stdenv.lib.licenses.bsd3;

     

       85754
       86031
        
            }) {};

     

       85755
       86032
        
       

     

       85756
       85756
       -
         "fused-effects_0_3_0_0" = callPackage

     

       86033
       86033
       +
         "fused-effects_0_3_1_0" = callPackage

     

       85757
       86034
        
           ({ mkDerivation, base, criterion, deepseq, doctest, hspec

     

       85758
       85758
       -
            , MonadRandom, QuickCheck, random, transformers

     

       86035
       86035
       +
            , inspection-testing, MonadRandom, QuickCheck, random, transformers

     

       86036
       86036
       +
            , unliftio-core

     

       85759
       86037
        
            }:

     

       85760
       86038
        
            mkDerivation {

     

       85761
       86039
        
              pname = "fused-effects";

     

       85762
       85762
       -
              version = "0.3.0.0";

     

       85763
       85763
       -
              sha256 = "1plivl5vdgzpb2pbbhyiv2i6jk39l43bwa574qs9nb5jx5i7n056";

     

       86040
       86040
       +
              version = "0.3.1.0";

     

       86041
       86041
       +
              sha256 = "0mg6sgp4j6my34wzsdpvjvsb07s9k515shvi8nnrnzf0djqq95rv";

     

       85764
       86042
        
              libraryHaskellDepends = [

     

       85765
       85765
       -
                base deepseq MonadRandom random transformers

     

       86043
       86043
       +
                base deepseq MonadRandom random transformers unliftio-core

     

       86044
       86044
       +
              ];

     

       86045
       86045
       +
              testHaskellDepends = [

     

       86046
       86046
       +
                base doctest hspec inspection-testing QuickCheck transformers

     

       85766
       86047
        
              ];

     

       85767
       85767
       -
              testHaskellDepends = [ base doctest hspec QuickCheck ];

     

       85768
       86048
        
              benchmarkHaskellDepends = [ base criterion ];

     

       85769
       86049
        
              description = "A fast, flexible, fused effect system";

     

       85770
       86050
        
              license = stdenv.lib.licenses.bsd3;

     
···

       88618
       88898
        
              license = stdenv.lib.licenses.bsd3;

     

       88619
       88899
        
            }) {};

     

       88620
       88900
        
       

     

       88621
       88621
       -
         "ghc_8_6_4" = callPackage

     

       88901
       88901
       +
         "ghc_8_6_5" = callPackage

     

       88622
       88902
        
           ({ mkDerivation, array, base, binary, bytestring, containers

     

       88623
       88903
        
            , deepseq, directory, filepath, ghc-boot, ghc-boot-th, ghc-heap

     

       88624
       88904
        
            , ghci, hpc, process, template-haskell, terminfo, time

     
···

       88626
       88906
        
            }:

     

       88627
       88907
        
            mkDerivation {

     

       88628
       88908
        
              pname = "ghc";

     

       88629
       88629
       -
              version = "8.6.4";

     

       88630
       88630
       -
              sha256 = "1ninm000qkpvvfgfrlvj0259451wwmfayh46px3zg6mkr19x64yi";

     

       88909
       88909
       +
              version = "8.6.5";

     

       88910
       88910
       +
              sha256 = "13sh7f40pib5v00wd5bdxrwz7m5q398l93kky0z14q47130mpp20";

     

       88631
       88911
        
              libraryHaskellDepends = [

     

       88632
       88912
        
                array base binary bytestring containers deepseq directory filepath

     

       88633
       88913
        
                ghc-boot ghc-boot-th ghc-heap ghci hpc process template-haskell

     
···

       88638
       88918
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       88639
       88919
        
            }) {};

     

       88640
       88920
        
       

     

       88641
       88641
       -
         "ghc-boot_8_6_4" = callPackage

     

       88921
       88921
       +
         "ghc-boot_8_6_5" = callPackage

     

       88642
       88922
        
           ({ mkDerivation, base, binary, bytestring, directory, filepath

     

       88643
       88923
        
            , ghc-boot-th

     

       88644
       88924
        
            }:

     

       88645
       88925
        
            mkDerivation {

     

       88646
       88926
        
              pname = "ghc-boot";

     

       88647
       88647
       -
              version = "8.6.4";

     

       88648
       88648
       -
              sha256 = "1clk84l47bdyj74jykyzqzlwxgpwhs2r9x9bxfnw6f7c24xiv4xp";

     

       88927
       88927
       +
              version = "8.6.5";

     

       88928
       88928
       +
              sha256 = "1sxar25ji02a4yaz6s5hksf7b8pbl66vv9nb3bfc7fxq6gzj5n4b";

     

       88649
       88929
        
              libraryHaskellDepends = [

     

       88650
       88930
        
                base binary bytestring directory filepath ghc-boot-th

     

       88651
       88931
        
              ];

     
···

       88654
       88934
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       88655
       88935
        
            }) {};

     

       88656
       88936
        
       

     

       88657
       88657
       -
         "ghc-boot-th_8_6_4" = callPackage

     

       88937
       88937
       +
         "ghc-boot-th_8_6_5" = callPackage

     

       88658
       88938
        
           ({ mkDerivation, base }:

     

       88659
       88939
        
            mkDerivation {

     

       88660
       88940
        
              pname = "ghc-boot-th";

     

       88661
       88661
       -
              version = "8.6.4";

     

       88662
       88662
       -
              sha256 = "15hvcns1vpagx0bdpzgm1cgwnxvz4cbbhbzsvdzpl8zf4y0jd8jz";

     

       88941
       88941
       +
              version = "8.6.5";

     

       88942
       88942
       +
              sha256 = "18gjvxp3668np9n3c5l65q03nlqhgfjhh9wizvifmk673g0cl7n9";

     

       88663
       88943
        
              libraryHaskellDepends = [ base ];

     

       88664
       88664
       -
              description = "Shared functionality between GHC and the @template-haskell@ library";

     

       88944
       88944
       +
              description = "Shared functionality between GHC and the `template-haskell` library";

     

       88665
       88945
        
              license = stdenv.lib.licenses.bsd3;

     

       88666
       88946
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       88667
       88947
        
            }) {};

     
···

       89088
       89368
        
            }:

     

       89089
       89369
        
            mkDerivation {

     

       89090
       89370
        
              pname = "ghc-lib";

     

       89091
       89091
       -
              version = "0.20190402";

     

       89092
       89092
       -
              sha256 = "1w91n0bh5xyfgzk4kgn43s3wnx4a0h2la9phwf11327ajiacch4l";

     

       89371
       89371
       +
              version = "0.20190423";

     

       89372
       89372
       +
              sha256 = "1jj4ph9ldxicccs3myqmll9x3a1rl9zv95b797mm9yas80sbijnx";

     

       89093
       89373
        
              isLibrary = true;

     

       89094
       89374
        
              isExecutable = true;

     

       89095
       89375
        
              enableSeparateDataOutput = true;

     
···

       89113
       89393
        
            }:

     

       89114
       89394
        
            mkDerivation {

     

       89115
       89395
        
              pname = "ghc-lib-parser";

     

       89116
       89116
       -
              version = "0.20190402";

     

       89117
       89117
       -
              sha256 = "0ppp7grcmbml472yi766hsmzlnwvb6dawr4f72k41s3xwkfpjmpg";

     

       89396
       89396
       +
              version = "0.20190423";

     

       89397
       89397
       +
              sha256 = "1vwfsyyj8h0x56zq498mhjbpj6bz9n901v3mwyn5hzp7c25zdv5k";

     

       89118
       89398
        
              enableSeparateDataOutput = true;

     

       89119
       89399
        
              libraryHaskellDepends = [

     

       89120
       89400
        
                array base binary bytestring containers deepseq directory filepath

     
···

       89697
       89977
        
              broken = true;

     

       89698
       89978
        
            }) {};

     

       89699
       89979
        
       

     

       89700
       89700
       -
         "ghci_8_6_4" = callPackage

     

       89980
       89980
       +
         "ghci_8_6_5" = callPackage

     

       89701
       89981
        
           ({ mkDerivation, array, base, binary, bytestring, containers

     

       89702
       89982
        
            , deepseq, filepath, ghc-boot, ghc-boot-th, ghc-heap

     

       89703
       89983
        
            , template-haskell, transformers, unix

     

       89704
       89984
        
            }:

     

       89705
       89985
        
            mkDerivation {

     

       89706
       89986
        
              pname = "ghci";

     

       89707
       89707
       -
              version = "8.6.4";

     

       89708
       89708
       -
              sha256 = "0gjl2bs2alv56j45khylcdjm3cl71kfcadc83lw3b1zpiinhkb7m";

     

       89987
       89987
       +
              version = "8.6.5";

     

       89988
       89988
       +
              sha256 = "0h011kixzv5x5bjb2i71bl9dnffc6if7k6jmsncbyvj0vvchrrn8";

     

       89709
       89989
        
              libraryHaskellDepends = [

     

       89710
       89990
        
                array base binary bytestring containers deepseq filepath ghc-boot

     

       89711
       89991
        
                ghc-boot-th ghc-heap template-haskell transformers unix

     
···

       89848
       90128
        
            }:

     

       89849
       90129
        
            mkDerivation {

     

       89850
       90130
        
              pname = "ghcid";

     

       89851
       89851
       -
              version = "0.7.2";

     

       89852
       89852
       -
              sha256 = "1h50438brxazk6vx8ym3f8y83rijh0lnkf6ac2rwhxi07r016h7s";

     

       90131
       90131
       +
              version = "0.7.4";

     

       90132
       90132
       +
              sha256 = "1wd278xligp0qj98zhqp3lkxdzpgb8k7yy0vhva6cs1ch6032gpp";

     

       89853
       90133
        
              isLibrary = true;

     

       89854
       90134
        
              isExecutable = true;

     

       89855
       90135
        
              libraryHaskellDepends = [

     
···

       89867
       90147
        
              license = stdenv.lib.licenses.bsd3;

     

       89868
       90148
        
            }) {};

     

       89869
       90149
        
       

     

       89870
       89870
       -
         "ghcid_0_7_3" = callPackage

     

       89871
       89871
       -
           ({ mkDerivation, ansi-terminal, base, cmdargs, containers

     

       89872
       89872
       -
            , directory, extra, filepath, fsnotify, process, tasty, tasty-hunit

     

       89873
       89873
       -
            , terminal-size, time, unix

     

       89874
       89874
       -
            }:

     

       89875
       89875
       -
            mkDerivation {

     

       89876
       89876
       -
              pname = "ghcid";

     

       89877
       89877
       -
              version = "0.7.3";

     

       89878
       89878
       -
              sha256 = "00af44r0y4n8nz9sc8mgbydgwzjmp32yrnf1k15lrlyahqrixhfl";

     

       89879
       89879
       -
              isLibrary = true;

     

       89880
       89880
       -
              isExecutable = true;

     

       89881
       89881
       -
              libraryHaskellDepends = [

     

       89882
       89882
       -
                ansi-terminal base cmdargs directory extra filepath process time

     

       89883
       89883
       -
              ];

     

       89884
       89884
       -
              executableHaskellDepends = [

     

       89885
       89885
       -
                ansi-terminal base cmdargs containers directory extra filepath

     

       89886
       89886
       -
                fsnotify process terminal-size time unix

     

       89887
       89887
       -
              ];

     

       89888
       89888
       -
              testHaskellDepends = [

     

       89889
       89889
       -
                ansi-terminal base cmdargs containers directory extra filepath

     

       89890
       89890
       -
                fsnotify process tasty tasty-hunit terminal-size time unix

     

       89891
       89891
       -
              ];

     

       89892
       89892
       -
              description = "GHCi based bare bones IDE";

     

       89893
       89893
       -
              license = stdenv.lib.licenses.bsd3;

     

       89894
       89894
       -
              hydraPlatforms = stdenv.lib.platforms.none;

     

       89895
       89895
       -
            }) {};

     

       89896
       89896
       -
       

     

       89897
       90150
        
         "ghcjs-ajax" = callPackage

     

       89898
       90151
        
           ({ mkDerivation, aeson, base, http-types, text }:

     

       89899
       90152
        
            mkDerivation {

     
···

       97289
       97542
        
           ({ mkDerivation, base, containers, json, text }:

     

       97290
       97543
        
            mkDerivation {

     

       97291
       97544
        
              pname = "graphql-w-persistent";

     

       97292
       97292
       -
              version = "0.3.1.1";

     

       97293
       97293
       -
              sha256 = "1cfq41s18n73fpn0zzwrvw0b2n7l2h7i71dz9wvifsjxrpla50q1";

     

       97545
       97545
       +
              version = "0.3.1.2";

     

       97546
       97546
       +
              sha256 = "0kd73yxack1allp27l4pp4xsdw3rs3g44kbk6qadhdvrws7d105z";

     

       97294
       97547
        
              libraryHaskellDepends = [ base containers json text ];

     

       97295
       97548
        
              description = "Haskell GraphQL query parser-interpreter-data processor";

     

       97296
       97549
        
              license = stdenv.lib.licenses.isc;

     
···

       97452
       97705
        
            }:

     

       97453
       97706
        
            mkDerivation {

     

       97454
       97707
        
              pname = "gray-extended";

     

       97455
       97455
       -
              version = "1.5.6";

     

       97456
       97456
       -
              sha256 = "13a18vri2akfahp8k7s5sg6knn0plcsf6lqdzy05628wymiia2s3";

     

       97708
       97708
       +
              version = "1.5.7";

     

       97709
       97709
       +
              sha256 = "0j2lzy15jiykz9b6cqzh7xhpf1idwxp8illvy3r50g1g4hc8zvyp";

     

       97457
       97710
        
              libraryHaskellDepends = [ base ];

     

       97458
       97711
        
              testHaskellDepends = [

     

       97459
       97712
        
                base QuickCheck test-framework test-framework-quickcheck2

     
···

       99672
       99925
        
              license = stdenv.lib.licenses.publicDomain;

     

       99673
       99926
        
            }) {};

     

       99674
       99927
        
       

     

       99928
       99928
       +
         "hablo" = callPackage

     

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

     

       99930
       99930
       +
            , filepath, lucid, mtl, optparse-applicative, parsec, template

     

       99931
       99931
       +
            , text, time, unix

     

       99932
       99932
       +
            }:

     

       99933
       99933
       +
            mkDerivation {

     

       99934
       99934
       +
              pname = "hablo";

     

       99935
       99935
       +
              version = "1.0.0.0";

     

       99936
       99936
       +
              sha256 = "19lhchfvkyqjfbr7i07y6a26dyk19w83s0qa6drgnr6zqsvdqkg8";

     

       99937
       99937
       +
              isLibrary = false;

     

       99938
       99938
       +
              isExecutable = true;

     

       99939
       99939
       +
              enableSeparateDataOutput = true;

     

       99940
       99940
       +
              executableHaskellDepends = [

     

       99941
       99941
       +
                aeson base bytestring containers directory filepath lucid mtl

     

       99942
       99942
       +
                optparse-applicative parsec template text time unix

     

       99943
       99943
       +
              ];

     

       99944
       99944
       +
              description = "A minimalist static blog generator";

     

       99945
       99945
       +
              license = stdenv.lib.licenses.bsd3;

     

       99946
       99946
       +
            }) {};

     

       99947
       99947
       +
       

     

       99675
       99948
        
         "hablog" = callPackage

     

       99676
       99949
        
           ({ mkDerivation, base, bifunctors, blaze-html, blaze-markup

     

       99677
       99950
        
            , bytestring, containers, directory, filepath, markdown, mime-types

     
···

       101021
       101294
        
            }:

     

       101022
       101295
        
            mkDerivation {

     

       101023
       101296
        
              pname = "haiji";

     

       101024
       101024
       -
              version = "0.2.3.0";

     

       101025
       101025
       -
              sha256 = "12g7nlfci2hrsqi19z8mi7i8vqd1s7a8c3sr8k43f0hhzk6b528i";

     

       101297
       101297
       +
              version = "0.3.0.0";

     

       101298
       101298
       +
              sha256 = "079q3m3c39ip86hpirq9c5l3b9hw030zd5slwi2bssbmq2bhfv5i";

     

       101026
       101299
        
              libraryHaskellDepends = [

     

       101027
       101300
        
                aeson attoparsec base data-default mtl scientific tagged

     

       101028
       101301
        
                template-haskell text transformers unordered-containers vector

     
···

       103491
       103764
        
              pname = "hasbolt";

     

       103492
       103765
        
              version = "0.1.3.2";

     

       103493
       103766
        
              sha256 = "14sq3iqbrfkwyswdka2285cdhwx3c6srfhn5qb7yw1nfjx2bdb1i";

     

       103494
       103494
       -
              revision = "3";

     

       103495
       103495
       -
              editedCabalFile = "10h7pbkrkc9cdxx09zk0s8ygcdva2xy646zq3k8czph3vdaffzqx";

     

       103767
       103767
       +
              revision = "4";

     

       103768
       103768
       +
              editedCabalFile = "0h38mjkr3cqhsr9hwf2wj27mknnxyb2y3swzp18s7q4vmrb1ijyz";

     

       103496
       103769
        
              libraryHaskellDepends = [

     

       103497
       103770
        
                base binary bytestring connection containers data-binary-ieee754

     

       103498
       103771
        
                data-default network text transformers

     
···

       103504
       103777
        
              license = stdenv.lib.licenses.bsd3;

     

       103505
       103778
        
            }) {};

     

       103506
       103779
        
       

     

       103780
       103780
       +
         "hasbolt_0_1_3_3" = callPackage

     

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

     

       103782
       103782
       +
            , data-binary-ieee754, data-default, hex, hspec, network

     

       103783
       103783
       +
            , QuickCheck, text, transformers

     

       103784
       103784
       +
            }:

     

       103785
       103785
       +
            mkDerivation {

     

       103786
       103786
       +
              pname = "hasbolt";

     

       103787
       103787
       +
              version = "0.1.3.3";

     

       103788
       103788
       +
              sha256 = "1l1p9iz9k8i1car5cd6cfd2bpidkrfbr2354hxvg8gpnw1i5jsbb";

     

       103789
       103789
       +
              libraryHaskellDepends = [

     

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

     

       103791
       103791
       +
                data-default network text transformers

     

       103792
       103792
       +
              ];

     

       103793
       103793
       +
              testHaskellDepends = [

     

       103794
       103794
       +
                base bytestring containers hex hspec QuickCheck text

     

       103795
       103795
       +
              ];

     

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

     

       103797
       103797
       +
              license = stdenv.lib.licenses.bsd3;

     

       103798
       103798
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       103799
       103799
       +
            }) {};

     

       103800
       103800
       +
       

     

       103507
       103801
        
         "hasbolt-extras" = callPackage

     

       103508
       103802
        
           ({ mkDerivation, aeson, aeson-casing, base, bytestring, containers

     

       103509
       103803
        
            , data-default, free, hasbolt, lens, mtl, neat-interpolation

     
···

       104998
       105292
        
              pname = "haskell-lsp";

     

       104999
       105293
        
              version = "0.8.2.0";

     

       105000
       105294
        
              sha256 = "18qkrybwvmyz5h03xj9wjigpqs6s6rw9wi1lqcla4ppg1pkd5zyd";

     

       105295
       105295
       +
              revision = "1";

     

       105296
       105296
       +
              editedCabalFile = "0m6kprfsgxcmif0mmb1vpc46jyr0kjk6fqv3k1sqfvpjpldh0mvy";

     

       105001
       105297
        
              isLibrary = true;

     

       105002
       105298
        
              isExecutable = true;

     

       105003
       105299
        
              libraryHaskellDepends = [

     
···

       105018
       105314
        
              license = stdenv.lib.licenses.mit;

     

       105019
       105315
        
            }) {};

     

       105020
       105316
        
       

     

       105317
       105317
       +
         "haskell-lsp_0_10_0_0" = callPackage

     

       105318
       105318
       +
           ({ mkDerivation, aeson, base, bytestring, containers, data-default

     

       105319
       105319
       +
            , directory, filepath, hashable, haskell-lsp-types, hslogger, hspec

     

       105320
       105320
       +
            , hspec-discover, lens, mtl, network-uri, parsec, QuickCheck

     

       105321
       105321
       +
            , quickcheck-instances, sorted-list, stm, text, time, transformers

     

       105322
       105322
       +
            , unordered-containers, vector, yi-rope

     

       105323
       105323
       +
            }:

     

       105324
       105324
       +
            mkDerivation {

     

       105325
       105325
       +
              pname = "haskell-lsp";

     

       105326
       105326
       +
              version = "0.10.0.0";

     

       105327
       105327
       +
              sha256 = "01vfpv4zi6h9rdn39l7rx3y0mm2gsabwsf5ny2dbrca8x7462vys";

     

       105328
       105328
       +
              isLibrary = true;

     

       105329
       105329
       +
              isExecutable = true;

     

       105330
       105330
       +
              libraryHaskellDepends = [

     

       105331
       105331
       +
                aeson base bytestring containers data-default directory filepath

     

       105332
       105332
       +
                hashable haskell-lsp-types hslogger lens mtl network-uri parsec

     

       105333
       105333
       +
                sorted-list stm text time unordered-containers yi-rope

     

       105334
       105334
       +
              ];

     

       105335
       105335
       +
              executableHaskellDepends = [

     

       105336
       105336
       +
                aeson base bytestring containers data-default directory filepath

     

       105337
       105337
       +
                hslogger lens mtl network-uri parsec stm text time transformers

     

       105338
       105338
       +
                unordered-containers vector yi-rope

     

       105339
       105339
       +
              ];

     

       105340
       105340
       +
              testHaskellDepends = [

     

       105341
       105341
       +
                aeson base bytestring containers data-default directory filepath

     

       105342
       105342
       +
                hashable hspec lens network-uri QuickCheck quickcheck-instances

     

       105343
       105343
       +
                sorted-list stm text yi-rope

     

       105344
       105344
       +
              ];

     

       105345
       105345
       +
              testToolDepends = [ hspec-discover ];

     

       105346
       105346
       +
              description = "Haskell library for the Microsoft Language Server Protocol";

     

       105347
       105347
       +
              license = stdenv.lib.licenses.mit;

     

       105348
       105348
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       105349
       105349
       +
            }) {};

     

       105350
       105350
       +
       

     

       105021
       105351
        
         "haskell-lsp-client" = callPackage

     

       105022
       105352
        
           ({ mkDerivation, aeson, base, bytestring, containers, directory

     

       105023
       105353
        
            , haskell-lsp, lens, process, text, unix

     
···

       105055
       105385
        
              ];

     

       105056
       105386
        
              description = "Haskell library for the Microsoft Language Server Protocol, data types";

     

       105057
       105387
        
              license = stdenv.lib.licenses.mit;

     

       105388
       105388
       +
            }) {};

     

       105389
       105389
       +
       

     

       105390
       105390
       +
         "haskell-lsp-types_0_10_0_0" = callPackage

     

       105391
       105391
       +
           ({ mkDerivation, aeson, base, bytestring, data-default, filepath

     

       105392
       105392
       +
            , hashable, lens, network-uri, scientific, text

     

       105393
       105393
       +
            , unordered-containers

     

       105394
       105394
       +
            }:

     

       105395
       105395
       +
            mkDerivation {

     

       105396
       105396
       +
              pname = "haskell-lsp-types";

     

       105397
       105397
       +
              version = "0.10.0.0";

     

       105398
       105398
       +
              sha256 = "03k8sip1mgcpr93075cpylp7d9h956vxx6dpcli1r46filbb88an";

     

       105399
       105399
       +
              libraryHaskellDepends = [

     

       105400
       105400
       +
                aeson base bytestring data-default filepath hashable lens

     

       105401
       105401
       +
                network-uri scientific text unordered-containers

     

       105402
       105402
       +
              ];

     

       105403
       105403
       +
              description = "Haskell library for the Microsoft Language Server Protocol, data types";

     

       105404
       105404
       +
              license = stdenv.lib.licenses.mit;

     

       105405
       105405
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       105058
       105406
        
            }) {};

     

       105059
       105407
        
       

     

       105060
       105408
        
         "haskell-menu" = callPackage

     
···

       107046
       107394
        
            }:

     

       107047
       107395
        
            mkDerivation {

     

       107048
       107396
        
              pname = "haskoin-node";

     

       107049
       107049
       -
              version = "0.9.9";

     

       107050
       107050
       -
              sha256 = "0d4bv1wr3c89x7r6aakvvwklwzk8g90bl21bc52k4d88znyclqvm";

     

       107397
       107397
       +
              version = "0.9.10";

     

       107398
       107398
       +
              sha256 = "05pnj7caia2ifr793pryfdc8q8p203rii4agrgy4i123mcfmxqjq";

     

       107051
       107399
        
              libraryHaskellDepends = [

     

       107052
       107400
        
                base bytestring cereal conduit conduit-extra containers

     

       107053
       107401
        
                data-default hashable haskoin-core monad-logger mtl network nqe

     
···

       107125
       107473
        
            }:

     

       107126
       107474
        
            mkDerivation {

     

       107127
       107475
        
              pname = "haskoin-store";

     

       107128
       107128
       -
              version = "0.14.0";

     

       107129
       107129
       -
              sha256 = "0d508vs1rhj54iixh1m4s7jcszav83bwbxd7g6d4hgn0vwf2l1wh";

     

       107476
       107476
       +
              version = "0.14.1";

     

       107477
       107477
       +
              sha256 = "0n5c51if17gm6ldsbpapqwc4bdshbnkxd403ssfgy3b923cmqm1r";

     

       107130
       107478
        
              isLibrary = true;

     

       107131
       107479
        
              isExecutable = true;

     

       107132
       107480
        
              libraryHaskellDepends = [

     
···

       107995
       108343
        
              benchmarkHaskellDepends = [ bug criterion rerebase ];

     

       107996
       108344
        
              description = "An efficient PostgreSQL driver and a flexible mapping API";

     

       107997
       108345
        
              license = stdenv.lib.licenses.mit;

     

       108346
       108346
       +
            }) {};

     

       108347
       108347
       +
       

     

       108348
       108348
       +
         "hasql_1_3_0_5" = callPackage

     

       108349
       108349
       +
           ({ mkDerivation, attoparsec, base, base-prelude, bug, bytestring

     

       108350
       108350
       +
            , bytestring-strict-builder, contravariant, contravariant-extras

     

       108351
       108351
       +
            , criterion, data-default-class, dlist, hashable, hashtables

     

       108352
       108352
       +
            , loch-th, mtl, placeholders, postgresql-binary, postgresql-libpq

     

       108353
       108353
       +
            , profunctors, QuickCheck, quickcheck-instances, rebase, rerebase

     

       108354
       108354
       +
            , tasty, tasty-hunit, tasty-quickcheck, text, text-builder

     

       108355
       108355
       +
            , transformers, vector

     

       108356
       108356
       +
            }:

     

       108357
       108357
       +
            mkDerivation {

     

       108358
       108358
       +
              pname = "hasql";

     

       108359
       108359
       +
              version = "1.3.0.5";

     

       108360
       108360
       +
              sha256 = "0qs2x4gbaffrxndivb4237vxc6qrzn2rs5kbf04n4d6py9cdhbjv";

     

       108361
       108361
       +
              libraryHaskellDepends = [

     

       108362
       108362
       +
                attoparsec base base-prelude bytestring bytestring-strict-builder

     

       108363
       108363
       +
                contravariant contravariant-extras data-default-class dlist

     

       108364
       108364
       +
                hashable hashtables loch-th mtl placeholders postgresql-binary

     

       108365
       108365
       +
                postgresql-libpq profunctors text text-builder transformers vector

     

       108366
       108366
       +
              ];

     

       108367
       108367
       +
              testHaskellDepends = [

     

       108368
       108368
       +
                bug data-default-class QuickCheck quickcheck-instances rebase

     

       108369
       108369
       +
                rerebase tasty tasty-hunit tasty-quickcheck

     

       108370
       108370
       +
              ];

     

       108371
       108371
       +
              benchmarkHaskellDepends = [ bug criterion rerebase ];

     

       108372
       108372
       +
              description = "An efficient PostgreSQL driver and a flexible mapping API";

     

       108373
       108373
       +
              license = stdenv.lib.licenses.mit;

     

       108374
       108374
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       107998
       108375
        
            }) {};

     

       107999
       108376
        
       

     

       108000
       108377
        
         "hasql-backend" = callPackage

     
···

       110283
       110660
        
              broken = true;

     

       110284
       110661
        
            }) {};

     

       110285
       110662
        
       

     

       110663
       110663
       +
         "hedgehog-generic" = callPackage

     

       110664
       110664
       +
           ({ mkDerivation, base, hedgehog }:

     

       110665
       110665
       +
            mkDerivation {

     

       110666
       110666
       +
              pname = "hedgehog-generic";

     

       110667
       110667
       +
              version = "0.1";

     

       110668
       110668
       +
              sha256 = "1166jwk3f4bfw54qaxk3q3gxrfmffwwfkmd8xyvwj7i3whwzxq0f";

     

       110669
       110669
       +
              libraryHaskellDepends = [ base hedgehog ];

     

       110670
       110670
       +
              description = "GHC Generics automatically derived hedgehog generators";

     

       110671
       110671
       +
              license = stdenv.lib.licenses.bsd3;

     

       110672
       110672
       +
            }) {};

     

       110673
       110673
       +
       

     

       110286
       110674
        
         "hedgehog-quickcheck" = callPackage

     

       110287
       110675
        
           ({ mkDerivation, base, hedgehog, QuickCheck, transformers }:

     

       110288
       110676
        
            mkDerivation {

     
···

       110320
       110708
        
              license = stdenv.lib.licenses.bsd3;

     

       110321
       110709
        
            }) {};

     

       110322
       110710
        
       

     

       110323
       110323
       -
         "hedis_0_12_1" = callPackage

     

       110711
       110711
       +
         "hedis_0_12_2" = callPackage

     

       110324
       110712
        
           ({ mkDerivation, async, base, bytestring, bytestring-lexing

     

       110325
       110713
        
            , deepseq, doctest, errors, HTTP, HUnit, mtl, network, network-uri

     

       110326
       110714
        
            , resource-pool, scanner, stm, test-framework, test-framework-hunit

     
···

       110328
       110716
        
            }:

     

       110329
       110717
        
            mkDerivation {

     

       110330
       110718
        
              pname = "hedis";

     

       110331
       110331
       -
              version = "0.12.1";

     

       110332
       110332
       -
              sha256 = "01l8fmwwanw00bj3rzyv8k9swgvvzbvh920li67w10w5qlwvmgri";

     

       110719
       110719
       +
              version = "0.12.2";

     

       110720
       110720
       +
              sha256 = "13kvi01v2bbz8xn44s4plmzka8khz3a4hc6pinw1walpfi8kygsx";

     

       110333
       110721
        
              libraryHaskellDepends = [

     

       110334
       110722
        
                async base bytestring bytestring-lexing deepseq errors HTTP mtl

     

       110335
       110723
        
                network network-uri resource-pool scanner stm text time tls

     
···

       114229
       114617
        
            }) {};

     

       114230
       114618
        
       

     

       114231
       114619
        
         "hledger-flow" = callPackage

     

       114232
       114232
       -
           ({ mkDerivation, base, containers, foldl, HUnit, stm, text, time

     

       114233
       114233
       -
            , turtle

     

       114620
       114620
       +
           ({ mkDerivation, base, containers, foldl, HUnit

     

       114621
       114621
       +
            , optparse-applicative, stm, text, time, turtle

     

       114234
       114622
        
            }:

     

       114235
       114623
        
            mkDerivation {

     

       114236
       114624
        
              pname = "hledger-flow";

     

       114237
       114237
       -
              version = "0.11.0.0";

     

       114238
       114238
       -
              sha256 = "1zjmy80r7iifj4cw53jskxqnnhrn8ysall5nx7xxhzfx4mwixq6f";

     

       114625
       114625
       +
              version = "0.11.2.0";

     

       114626
       114626
       +
              sha256 = "17v9iqh9dhild0m67j2141yxv4hx5p59fjn51yl5q0jbib63gq14";

     

       114239
       114627
        
              isLibrary = true;

     

       114240
       114628
        
              isExecutable = true;

     

       114241
       114629
        
              libraryHaskellDepends = [

     

       114242
       114630
        
                base containers foldl stm text time turtle

     

       114243
       114631
        
              ];

     

       114244
       114244
       -
              executableHaskellDepends = [ base text turtle ];

     

       114632
       114632
       +
              executableHaskellDepends = [

     

       114633
       114633
       +
                base optparse-applicative text turtle

     

       114634
       114634
       +
              ];

     

       114245
       114635
        
              testHaskellDepends = [

     

       114246
       114636
        
                base containers foldl HUnit stm text turtle

     

       114247
       114637
        
              ];

     
···

       114531
       114921
        
            }:

     

       114532
       114922
        
            mkDerivation {

     

       114533
       114923
        
              pname = "hlint";

     

       114534
       114534
       -
              version = "2.1.16";

     

       114535
       114535
       -
              sha256 = "027v3aigghmghwbiwkhv9iadwv15fa40brkin489ahi6jwrlnp32";

     

       114924
       114924
       +
              version = "2.1.17";

     

       114925
       114925
       +
              sha256 = "0brinb3fjy619qh8yingqz2k03gcixc7mvqxzhzjadj69zlns6j3";

     

       114536
       114926
        
              isLibrary = true;

     

       114537
       114927
        
              isExecutable = true;

     

       114538
       114928
        
              enableSeparateDataOutput = true;

     
···

       115382
       115772
        
       

     

       115383
       115773
        
         "hnix" = callPackage

     

       115384
       115774
        
           ({ mkDerivation, aeson, array, base, base16-bytestring, binary

     

       115385
       115385
       -
            , bytestring, comonad, containers, criterion, cryptohash-md5

     

       115386
       115386
       -
            , cryptohash-sha1, cryptohash-sha256, cryptohash-sha512, data-fix

     

       115387
       115387
       -
            , deepseq, dependent-sum, deriving-compat, Diff, directory

     

       115388
       115388
       -
            , exceptions, filepath, free, generic-random, Glob, hashable

     

       115389
       115389
       -
            , hashing, haskeline, hedgehog, hnix-store-core, http-client

     

       115390
       115390
       -
            , http-client-tls, http-types, interpolate, lens-family

     

       115391
       115391
       -
            , lens-family-core, lens-family-th, logict, megaparsec

     

       115392
       115392
       -
            , monad-control, monadlist, mtl, optparse-applicative

     

       115393
       115393
       -
            , parser-combinators, pretty-show, prettyprinter, process, ref-tf

     

       115394
       115394
       -
            , regex-tdfa, regex-tdfa-text, repline, scientific, semigroups

     

       115395
       115395
       -
            , serialise, split, syb, tasty, tasty-hedgehog, tasty-hunit

     

       115396
       115396
       -
            , tasty-quickcheck, tasty-th, template-haskell, text, these, time

     

       115397
       115397
       -
            , transformers, transformers-base, unix, unordered-containers

     

       115398
       115398
       -
            , vector, xml

     

       115775
       115775
       +
            , bytestring, comonad, containers, contravariant, criterion

     

       115776
       115776
       +
            , cryptohash-md5, cryptohash-sha1, cryptohash-sha256

     

       115777
       115777
       +
            , cryptohash-sha512, data-fix, deepseq, dependent-sum

     

       115778
       115778
       +
            , deriving-compat, Diff, directory, exceptions, filepath, free

     

       115779
       115779
       +
            , generic-random, Glob, hashable, hashing, haskeline, hedgehog

     

       115780
       115780
       +
            , hnix-store-core, http-client, http-client-tls, http-types

     

       115781
       115781
       +
            , interpolate, lens-family, lens-family-core, lens-family-th

     

       115782
       115782
       +
            , logict, megaparsec, monad-control, monadlist, mtl

     

       115783
       115783
       +
            , optparse-applicative, parser-combinators, pretty-show

     

       115784
       115784
       +
            , prettyprinter, process, ref-tf, regex-tdfa, regex-tdfa-text

     

       115785
       115785
       +
            , repline, scientific, semigroups, serialise, split, syb, tasty

     

       115786
       115786
       +
            , tasty-hedgehog, tasty-hunit, tasty-quickcheck, tasty-th

     

       115787
       115787
       +
            , template-haskell, text, these, time, transformers

     

       115788
       115788
       +
            , transformers-base, unix, unordered-containers, vector, xml

     

       115399
       115789
        
            }:

     

       115400
       115790
        
            mkDerivation {

     

       115401
       115791
        
              pname = "hnix";

     

       115402
       115402
       -
              version = "0.6.0";

     

       115403
       115403
       -
              sha256 = "1yirs9q2hm7h8zahc053q129s5iab6c24745hin4hik0ghdqw6k7";

     

       115792
       115792
       +
              version = "0.6.1";

     

       115793
       115793
       +
              sha256 = "0q79wdrm3z88mknq6nf7cpg7lwgbx355k95k11rz3iz0sgk9hjwi";

     

       115404
       115794
        
              isLibrary = true;

     

       115405
       115795
        
              isExecutable = true;

     

       115406
       115796
        
              libraryHaskellDepends = [

     

       115407
       115797
        
                aeson array base base16-bytestring binary bytestring comonad

     

       115408
       115408
       -
                containers cryptohash-md5 cryptohash-sha1 cryptohash-sha256

     

       115409
       115409
       -
                cryptohash-sha512 data-fix deepseq dependent-sum deriving-compat

     

       115410
       115410
       -
                directory exceptions filepath free hashable hashing haskeline

     

       115411
       115411
       -
                hnix-store-core http-client http-client-tls http-types interpolate

     

       115412
       115412
       -
                lens-family lens-family-core lens-family-th logict megaparsec

     

       115413
       115413
       -
                monad-control monadlist mtl optparse-applicative parser-combinators

     

       115414
       115414
       -
                pretty-show prettyprinter process ref-tf regex-tdfa regex-tdfa-text

     

       115415
       115415
       -
                scientific semigroups serialise split syb template-haskell text

     

       115416
       115416
       -
                these time transformers transformers-base unix unordered-containers

     

       115417
       115417
       -
                vector xml

     

       115798
       115798
       +
                containers contravariant cryptohash-md5 cryptohash-sha1

     

       115799
       115799
       +
                cryptohash-sha256 cryptohash-sha512 data-fix deepseq dependent-sum

     

       115800
       115800
       +
                deriving-compat directory exceptions filepath free hashable hashing

     

       115801
       115801
       +
                haskeline hnix-store-core http-client http-client-tls http-types

     

       115802
       115802
       +
                interpolate lens-family lens-family-core lens-family-th logict

     

       115803
       115803
       +
                megaparsec monad-control monadlist mtl optparse-applicative

     

       115804
       115804
       +
                parser-combinators pretty-show prettyprinter process ref-tf

     

       115805
       115805
       +
                regex-tdfa regex-tdfa-text scientific semigroups serialise split

     

       115806
       115806
       +
                syb template-haskell text these time transformers transformers-base

     

       115807
       115807
       +
                unix unordered-containers vector xml

     

       115418
       115808
        
              ];

     

       115419
       115809
        
              executableHaskellDepends = [

     

       115420
       115810
        
                aeson base base16-bytestring bytestring comonad containers

     

       115421
       115811
        
                cryptohash-md5 cryptohash-sha1 cryptohash-sha256 cryptohash-sha512

     

       115422
       115422
       -
                data-fix deepseq exceptions filepath hashing haskeline mtl

     

       115812
       115812
       +
                data-fix deepseq exceptions filepath free hashing haskeline mtl

     

       115423
       115813
        
                optparse-applicative pretty-show prettyprinter ref-tf repline

     

       115424
       115814
        
                serialise template-haskell text time transformers

     

       115425
       115815
        
                unordered-containers

     
···

       118180
       118570
        
              ];

     

       118181
       118571
        
              description = "Compression and decompression in the brotli format";

     

       118182
       118572
        
              license = stdenv.lib.licenses.bsd3;

     

       118183
       118183
       -
              hydraPlatforms = stdenv.lib.platforms.none;

     

       118184
       118184
       -
              broken = true;

     

       118185
       118185
       -
            }) {brotli = null; brotlidec = null; brotlienc = null; 

     

       118186
       118186
       -
                libbrotlidec = null; libbrotlienc = null;};

     

       118573
       118573
       +
            }) {brotlidec = null; brotlienc = null; libbrotlidec = null; 

     

       118574
       118574
       +
                libbrotlienc = null;};

     

       118187
       118575
        
       

     

       118188
       118576
        
         "hs-captcha" = callPackage

     

       118189
       118577
        
           ({ mkDerivation, base, bytestring, gd, random }:

     
···

       120376
       120764
        
              pname = "hsini";

     

       120377
       120765
        
              version = "0.5.1.2";

     

       120378
       120766
        
              sha256 = "1r6qksnrmk18ndxs5zaga8b7kvmk34kp0kh5hwqmq797qrlax9pa";

     

       120767
       120767
       +
              revision = "1";

     

       120768
       120768
       +
              editedCabalFile = "0wkvajjgs64l4wlw8s6sn3pbwx3ni41p1260chp67a16innr1qp6";

     

       120379
       120769
        
              libraryHaskellDepends = [ base bytestring containers mtl parsec ];

     

       120380
       120770
        
              testHaskellDepends = [

     

       120381
       120771
        
                base bytestring containers mtl parsec tasty tasty-hunit

     
···

       120483
       120873
        
              license = stdenv.lib.licenses.bsd3;

     

       120484
       120874
        
            }) {};

     

       120485
       120875
        
       

     

       120876
       120876
       +
         "hslogger_1_3_0_0" = callPackage

     

       120877
       120877
       +
           ({ mkDerivation, base, bytestring, containers, HUnit, network

     

       120878
       120878
       +
            , network-bsd, old-locale, time, unix

     

       120879
       120879
       +
            }:

     

       120880
       120880
       +
            mkDerivation {

     

       120881
       120881
       +
              pname = "hslogger";

     

       120882
       120882
       +
              version = "1.3.0.0";

     

       120883
       120883
       +
              sha256 = "1gnnqyd5hr59agqjcbim3kys5zarwsj7b1kfdbhy5qmjjwnpyzs8";

     

       120884
       120884
       +
              libraryHaskellDepends = [

     

       120885
       120885
       +
                base bytestring containers network network-bsd old-locale time unix

     

       120886
       120886
       +
              ];

     

       120887
       120887
       +
              testHaskellDepends = [ base HUnit ];

     

       120888
       120888
       +
              description = "Versatile logging framework";

     

       120889
       120889
       +
              license = stdenv.lib.licenses.bsd3;

     

       120890
       120890
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       120891
       120891
       +
            }) {};

     

       120892
       120892
       +
       

     

       120486
       120893
        
         "hslogger-reader" = callPackage

     

       120487
       120894
        
           ({ mkDerivation, attoparsec, base, hslogger, optparse-applicative

     

       120488
       120895
        
            , text, text-icu, time

     
···

       123895
       124302
        
              license = stdenv.lib.licenses.mit;

     

       123896
       124303
        
            }) {};

     

       123897
       124304
        
       

     

       124305
       124305
       +
         "http-media_0_8_0_0" = callPackage

     

       124306
       124306
       +
           ({ mkDerivation, base, bytestring, case-insensitive, containers

     

       124307
       124307
       +
            , QuickCheck, test-framework, test-framework-quickcheck2

     

       124308
       124308
       +
            , utf8-string

     

       124309
       124309
       +
            }:

     

       124310
       124310
       +
            mkDerivation {

     

       124311
       124311
       +
              pname = "http-media";

     

       124312
       124312
       +
              version = "0.8.0.0";

     

       124313
       124313
       +
              sha256 = "0lww5cxrc9jlvzsysjv99lca33i4rb7cll66p3c0rdpmvz8pk0ir";

     

       124314
       124314
       +
              revision = "1";

     

       124315
       124315
       +
              editedCabalFile = "01kb67m99jl3b8k06bp84sxiwxygz48ci5wkll42688qgsjb3rab";

     

       124316
       124316
       +
              libraryHaskellDepends = [

     

       124317
       124317
       +
                base bytestring case-insensitive containers utf8-string

     

       124318
       124318
       +
              ];

     

       124319
       124319
       +
              testHaskellDepends = [

     

       124320
       124320
       +
                base bytestring case-insensitive containers QuickCheck

     

       124321
       124321
       +
                test-framework test-framework-quickcheck2 utf8-string

     

       124322
       124322
       +
              ];

     

       124323
       124323
       +
              description = "Processing HTTP Content-Type and Accept headers";

     

       124324
       124324
       +
              license = stdenv.lib.licenses.mit;

     

       124325
       124325
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       124326
       124326
       +
            }) {};

     

       124327
       124327
       +
       

     

       123898
       124328
        
         "http-monad" = callPackage

     

       123899
       124329
        
           ({ mkDerivation, base, bytestring, containers, explicit-exception

     

       123900
       124330
        
            , HTTP, lazyio, network, network-uri, parsec, semigroups

     
···

       124248
       124678
        
       

     

       124249
       124679
        
         "http2-client" = callPackage

     

       124250
       124680
        
           ({ mkDerivation, async, base, bytestring, containers, deepseq

     

       124251
       124251
       -
            , http2, network, stm, time, tls

     

       124681
       124681
       +
            , http2, lifted-async, lifted-base, mtl, network, stm, time, tls

     

       124682
       124682
       +
            , transformers-base

     

       124252
       124683
        
            }:

     

       124253
       124684
        
            mkDerivation {

     

       124254
       124685
        
              pname = "http2-client";

     

       124255
       124255
       -
              version = "0.8.0.2";

     

       124256
       124256
       -
              sha256 = "16m4amw7xq7psvxix76z7g1dvllkfs9pzpnig5rfhbgfvbf5pydw";

     

       124686
       124686
       +
              version = "0.9.0.0";

     

       124687
       124687
       +
              sha256 = "1z46an4sign2ashjsj2y07vkf73i2wzx5x10qsdaf4av5ib8ykxq";

     

       124688
       124688
       +
              revision = "1";

     

       124689
       124689
       +
              editedCabalFile = "00fg9a62qkjwp7rb38j7z7yy6dk3mkh6mgwspd79v2ycmn4mr25q";

     

       124257
       124690
        
              libraryHaskellDepends = [

     

       124258
       124258
       -
                async base bytestring containers deepseq http2 network stm time tls

     

       124691
       124691
       +
                async base bytestring containers deepseq http2 lifted-async

     

       124692
       124692
       +
                lifted-base mtl network stm time tls transformers-base

     

       124259
       124693
        
              ];

     

       124260
       124694
        
              testHaskellDepends = [ base ];

     

       124261
       124695
        
              description = "A native HTTP2 client library";

     
···

       124264
       124698
        
       

     

       124265
       124699
        
         "http2-client-exe" = callPackage

     

       124266
       124700
        
           ({ mkDerivation, async, base, bytestring, data-default-class, http2

     

       124267
       124267
       -
            , http2-client, optparse-applicative, time, tls

     

       124701
       124701
       +
            , http2-client, lifted-async, lifted-base, optparse-applicative

     

       124702
       124702
       +
            , time, tls

     

       124268
       124703
        
            }:

     

       124269
       124704
        
            mkDerivation {

     

       124270
       124705
        
              pname = "http2-client-exe";

     

       124271
       124271
       -
              version = "0.1.0.1";

     

       124272
       124272
       -
              sha256 = "1z1y52253dybliwplybwd71a1ssmma34zcylv54aj6x7grrj37hm";

     

       124706
       124706
       +
              version = "0.2.0.0";

     

       124707
       124707
       +
              sha256 = "15yvg3nmsajc7q63c2qsmmckw3v4h37364zdxqi3dk9r0xkpssjy";

     

       124273
       124708
        
              isLibrary = false;

     

       124274
       124709
        
              isExecutable = true;

     

       124275
       124710
        
              executableHaskellDepends = [

     

       124276
       124711
        
                async base bytestring data-default-class http2 http2-client

     

       124277
       124277
       -
                optparse-applicative time tls

     

       124712
       124712
       +
                lifted-async lifted-base optparse-applicative time tls

     

       124278
       124713
        
              ];

     

       124279
       124714
        
              description = "A command-line http2 client";

     

       124280
       124715
        
              license = stdenv.lib.licenses.bsd3;

     
···

       124283
       124718
        
         "http2-client-grpc" = callPackage

     

       124284
       124719
        
           ({ mkDerivation, async, base, binary, bytestring, case-insensitive

     

       124285
       124720
        
            , data-default-class, http2, http2-client, http2-grpc-types, lens

     

       124286
       124286
       -
            , proto-lens, text, tls

     

       124721
       124721
       +
            , lifted-async, lifted-base, proto-lens, text, tls

     

       124287
       124722
        
            }:

     

       124288
       124723
        
            mkDerivation {

     

       124289
       124724
        
              pname = "http2-client-grpc";

     

       124290
       124290
       -
              version = "0.6.0.0";

     

       124291
       124291
       -
              sha256 = "0cf6asfh8wmjh1j0i1ldh557n33q1k1kfj604rz7rrrcarmn0m5h";

     

       124725
       124725
       +
              version = "0.7.0.0";

     

       124726
       124726
       +
              sha256 = "1iy825wrn2ai2qpbkq4p9k2amc5rarr57b9sa2vm8vqdrclcvzn1";

     

       124292
       124727
        
              libraryHaskellDepends = [

     

       124293
       124728
        
                async base binary bytestring case-insensitive data-default-class

     

       124294
       124294
       -
                http2 http2-client http2-grpc-types lens proto-lens text tls

     

       124729
       124729
       +
                http2 http2-client http2-grpc-types lens lifted-async lifted-base

     

       124730
       124730
       +
                proto-lens text tls

     

       124295
       124731
        
              ];

     

       124296
       124732
        
              testHaskellDepends = [ base ];

     

       124297
       124733
        
              description = "Implement gRPC-over-HTTP2 clients";

     
···

       130409
       130845
        
            }:

     

       130410
       130846
        
            mkDerivation {

     

       130411
       130847
        
              sha256 = "0zw591nqgyqy37vj0vmyyd2m7v6cyx8bgwfm1xhf1ppbxhjx38nv";

     

       130412
       130412
       -
              version = "1.0.2.2";

     

       130413
       130413
       -
              sha256 = "0zw591nqgyqy37vj0vmyyd2m7v6cyx8bgwfm1xhf1ppbxhjx38nv";

     

       130414
       130414
       -
              revision = "1";

     

       130415
       130415
       -
              sha256 = "0zw591nqgyqy37vj0vmyyd2m7v6cyx8bgwfm1xhf1ppbxhjx38nv";

     

       130848
       130848
       +
              version = "1.0.3";

     

       130849
       130849
       +
              sha256 = "05pc5hws66csvcvfswlwcr2fplwn1lbssvwifjxkbbwqhq0n5qjs";

     

       130416
       130850
        
              sha256 = "0zw591nqgyqy37vj0vmyyd2m7v6cyx8bgwfm1xhf1ppbxhjx38nv";

     

       130417
       130851
        
              testHaskellDepends = [

     

       130418
       130852
        
              sha256 = "0zw591nqgyqy37vj0vmyyd2m7v6cyx8bgwfm1xhf1ppbxhjx38nv";

     
···

       133143
       133577
        
            }:

     

       133144
       133578
        
            mkDerivation {

     

       133145
       133579
        
              sha256 = "0zw591nqgyqy37vj0vmyyd2m7v6cyx8bgwfm1xhf1ppbxhjx38nv";

     

       133146
       133146
       -
              version = "1.1.0";

     

       133147
       133147
       -
              sha256 = "0zw591nqgyqy37vj0vmyyd2m7v6cyx8bgwfm1xhf1ppbxhjx38nv";

     

       133580
       133580
       +
              version = "1.2.0";

     

       133581
       133581
       +
              sha256 = "1ha7zngxr9nin3gyqwwv6bplvrrc2n3j9sl8fp2dmxpjfwpi9r7f";

     

       133582
       133582
       +
              revision = "1";

     

       133583
       133583
       +
              editedCabalFile = "0xv7828z08rfd1m29ib8vlvigbavx5ksc67vj57293qiq590a3xf";

     

       133148
       133584
        
              isLibrary = false;

     

       133149
       133585
        
              isExecutable = true;

     

       133150
       133586
        
              libraryHaskellDepends = [ base QuickCheck ];

     
···

       137426
       137862
        
              broken = true;

     

       137427
       137863
        
            }) {};

     

       137428
       137864
        
       

     

       137865
       137865
       +
         "knit-haskell" = callPackage

     

       137866
       137866
       +
           ({ mkDerivation, aeson-pretty, base, base64-bytestring

     

       137867
       137867
       +
            , blaze-colonnade, blaze-html, bytestring, case-insensitive

     

       137868
       137868
       +
            , colonnade, containers, directory, Glob, here, http-client

     

       137869
       137869
       +
            , http-client-tls, http-types, hvega, logging-effect, lucid, mtl

     

       137870
       137870
       +
            , network, network-uri, pandoc, polysemy, prettyprinter, random

     

       137871
       137871
       +
            , random-fu, random-source, text, time

     

       137872
       137872
       +
            }:

     

       137873
       137873
       +
            mkDerivation {

     

       137874
       137874
       +
              pname = "knit-haskell";

     

       137875
       137875
       +
              version = "0.1.0.0";

     

       137876
       137876
       +
              sha256 = "11kqv2jxjn3maj53lgbccxcjcjrfqgsi8dd2ys51aalak2pf79bx";

     

       137877
       137877
       +
              isLibrary = true;

     

       137878
       137878
       +
              isExecutable = true;

     

       137879
       137879
       +
              libraryHaskellDepends = [

     

       137880
       137880
       +
                aeson-pretty base base64-bytestring blaze-colonnade blaze-html

     

       137881
       137881
       +
                bytestring case-insensitive colonnade containers directory Glob

     

       137882
       137882
       +
                http-client http-client-tls http-types hvega logging-effect lucid

     

       137883
       137883
       +
                mtl network network-uri pandoc polysemy prettyprinter random

     

       137884
       137884
       +
                random-fu random-source text time

     

       137885
       137885
       +
              ];

     

       137886
       137886
       +
              executableHaskellDepends = [

     

       137887
       137887
       +
                base blaze-html colonnade containers here hvega mtl polysemy

     

       137888
       137888
       +
                random-fu text

     

       137889
       137889
       +
              ];

     

       137890
       137890
       +
              description = "a minimal Rmarkdown sort-of-thing for haskell, by way of Pandoc";

     

       137891
       137891
       +
              license = stdenv.lib.licenses.bsd3;

     

       137892
       137892
       +
            }) {};

     

       137893
       137893
       +
       

     

       137429
       137894
        
         "knob" = callPackage

     

       137430
       137895
        
           ({ mkDerivation, base, bytestring, transformers }:

     

       137431
       137896
        
            mkDerivation {

     
···

       138871
       139336
        
            }:

     

       138872
       139337
        
            mkDerivation {

     

       138873
       139338
        
              pname = "language-ats";

     

       138874
       138874
       -
              version = "1.7.1.1";

     

       138875
       138875
       -
              sha256 = "0zqvr8z0mdjjdd9wx3ghf4aiv61brs52wk04d2vqar8nvv2wpzn4";

     

       139339
       139339
       +
              version = "1.7.1.2";

     

       139340
       139340
       +
              sha256 = "057gskb5y57jvh6z71d35qq228kpvf0wk09wf175mgy9qc78vg9p";

     

       138876
       139341
        
              enableSeparateDataOutput = true;

     

       138877
       139342
        
              libraryHaskellDepends = [

     

       138878
       139343
        
                ansi-wl-pprint array base composition-prelude containers deepseq

     
···

       139744
       140209
        
            }:

     

       139745
       140210
        
            mkDerivation {

     

       139746
       140211
        
              pname = "language-puppet";

     

       139747
       139747
       -
              version = "1.4.3";

     

       139748
       139748
       -
              sha256 = "1sh0i487w7mz5c0scly1s11xzha4dbp2wdiwdks3203c5yrjdfq7";

     

       140212
       140212
       +
              version = "1.4.4";

     

       140213
       140213
       +
              sha256 = "0dgbbyz89q1hhacy2pymhvmp8k5dvnzzsrxq0zc6l865nhha67ch";

     

       139749
       140214
        
              isLibrary = true;

     

       139750
       140215
        
              isExecutable = true;

     

       139751
       140216
        
              enableSeparateDataOutput = true;

     
···

       140334
       140799
        
              pname = "lattices";

     

       140335
       140800
        
              version = "1.7.1.1";

     

       140336
       140801
        
              sha256 = "1byx2hmmh2213afdcsjxf3mvq3h9bwkl5wrvzxv1yqvd9jiqjz3r";

     

       140337
       140337
       -
              revision = "1";

     

       140338
       140338
       -
              editedCabalFile = "18182vlzaz5kzcn2j0k1jmdl8kgqmnpjc3ynsi7v6jdl3vig89dr";

     

       140802
       140802
       +
              revision = "2";

     

       140803
       140803
       +
              editedCabalFile = "0qxz4v5pqwvhb79mz4b7wc66r2c0xc9ixfhss4h56jk3vb1hriys";

     

       140339
       140804
        
              libraryHaskellDepends = [

     

       140340
       140805
        
                base base-compat containers deepseq hashable semigroupoids tagged

     

       140341
       140806
        
                universe-base universe-reverse-instances unordered-containers

     
···

       142134
       142599
        
              license = stdenv.lib.licenses.bsd3;

     

       142135
       142600
        
            }) {ffi = null; inherit (pkgs) libffi;};

     

       142136
       142601
        
       

     

       142602
       142602
       +
         "libffi-dynamic" = callPackage

     

       142603
       142603
       +
           ({ mkDerivation, base, contravariant, ffi, hashable, intern }:

     

       142604
       142604
       +
            mkDerivation {

     

       142605
       142605
       +
              pname = "libffi-dynamic";

     

       142606
       142606
       +
              version = "0.0.0.1";

     

       142607
       142607
       +
              sha256 = "0fh3a07qv6fgxycba2yy02warz2lm2npps9118nkxq0qf8gnvinv";

     

       142608
       142608
       +
              libraryHaskellDepends = [ base contravariant hashable intern ];

     

       142609
       142609
       +
              librarySystemDepends = [ ffi ];

     

       142610
       142610
       +
              description = "LibFFI interface with dynamic bidirectional type-driven binding generation";

     

       142611
       142611
       +
              license = stdenv.lib.licenses.publicDomain;

     

       142612
       142612
       +
            }) {ffi = null;};

     

       142613
       142613
       +
       

     

       142137
       142614
        
         "libgit" = callPackage

     

       142138
       142615
        
           ({ mkDerivation, base, mtl, process }:

     

       142139
       142616
        
            mkDerivation {

     
···

       143409
       143886
        
            }:

     

       143410
       143887
        
            mkDerivation {

     

       143411
       143888
        
              pname = "line-bot-sdk";

     

       143412
       143412
       -
              version = "0.5.0.0";

     

       143413
       143413
       -
              sha256 = "135l32xf28ric12ya9mfis6rixd4cyfp3801dr6q8di4vvfgblm4";

     

       143889
       143889
       +
              version = "0.5.0.1";

     

       143890
       143890
       +
              sha256 = "0d2a540dflyv3zjx9phs85qar1kpyl287f01hh8fxkp550wivfgg";

     

       143414
       143891
        
              isLibrary = true;

     

       143415
       143892
        
              isExecutable = true;

     

       143416
       143893
        
              libraryHaskellDepends = [

     
···

       146949
       147426
        
            }:

     

       146950
       147427
        
            mkDerivation {

     

       146951
       147428
        
              pname = "lsp-test";

     

       146952
       146952
       -
              version = "0.5.1.0";

     

       146953
       146953
       -
              sha256 = "1kmffpfq6cnby3gij5sd1p2fp8hhn7gjk1nm5a4hs2gfhlyik57y";

     

       147429
       147429
       +
              version = "0.5.1.1";

     

       147430
       147430
       +
              sha256 = "03dvkh8i6mkmcv1pvaqlr9pava14qxbd31my4hjvs37xzm6dw22b";

     

       147431
       147431
       +
              libraryHaskellDepends = [

     

       147432
       147432
       +
                aeson aeson-pretty ansi-terminal base bytestring conduit

     

       147433
       147433
       +
                conduit-parse containers data-default Diff directory filepath

     

       147434
       147434
       +
                haskell-lsp lens mtl parser-combinators process text transformers

     

       147435
       147435
       +
                unix unordered-containers yi-rope

     

       147436
       147436
       +
              ];

     

       147437
       147437
       +
              testHaskellDepends = [

     

       147438
       147438
       +
                aeson base data-default haskell-lsp hspec lens text

     

       147439
       147439
       +
                unordered-containers

     

       147440
       147440
       +
              ];

     

       147441
       147441
       +
              description = "Functional test framework for LSP servers";

     

       147442
       147442
       +
              license = stdenv.lib.licenses.bsd3;

     

       147443
       147443
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       147444
       147444
       +
              broken = true;

     

       147445
       147445
       +
            }) {};

     

       147446
       147446
       +
       

     

       147447
       147447
       +
         "lsp-test_0_5_1_3" = callPackage

     

       147448
       147448
       +
           ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, base

     

       147449
       147449
       +
            , bytestring, conduit, conduit-parse, containers, data-default

     

       147450
       147450
       +
            , Diff, directory, filepath, haskell-lsp, hspec, lens, mtl

     

       147451
       147451
       +
            , parser-combinators, process, text, transformers, unix

     

       147452
       147452
       +
            , unordered-containers, yi-rope

     

       147453
       147453
       +
            }:

     

       147454
       147454
       +
            mkDerivation {

     

       147455
       147455
       +
              pname = "lsp-test";

     

       147456
       147456
       +
              version = "0.5.1.3";

     

       147457
       147457
       +
              sha256 = "1ksjsxf5y9jx7j8rbfsvc667p7ikvvvscvjaa97mps8aci5izv48";

     

       147458
       147458
       +
              revision = "1";

     

       147459
       147459
       +
              editedCabalFile = "1aa59vpfa5an1fx3xq92lzg9k7wkwbxncmx04zkwdidwh5i2p4pg";

     

       146954
       147460
        
              libraryHaskellDepends = [

     

       146955
       147461
        
                aeson aeson-pretty ansi-terminal base bytestring conduit

     

       146956
       147462
        
                conduit-parse containers data-default Diff directory filepath

     
···

       149162
       149668
        
              license = stdenv.lib.licenses.bsd3;

     

       149163
       149669
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       149164
       149670
        
              broken = true;

     

       149671
       149671
       +
            }) {};

     

       149672
       149672
       +
       

     

       149673
       149673
       +
         "map-reduce-folds" = callPackage

     

       149674
       149674
       +
           ({ mkDerivation, base, containers, criterion, deepseq

     

       149675
       149675
       +
            , discrimination, foldl, hashable, hashtables, hedgehog, parallel

     

       149676
       149676
       +
            , profunctors, random, split, streaming, streamly, text

     

       149677
       149677
       +
            , unordered-containers, vector

     

       149678
       149678
       +
            }:

     

       149679
       149679
       +
            mkDerivation {

     

       149680
       149680
       +
              pname = "map-reduce-folds";

     

       149681
       149681
       +
              version = "0.1.0.0";

     

       149682
       149682
       +
              sha256 = "03f5jkjsrn5a82g0cvjwm9dq1hn4c9m6a8hsyh035f92vflfk5vc";

     

       149683
       149683
       +
              isLibrary = true;

     

       149684
       149684
       +
              isExecutable = true;

     

       149685
       149685
       +
              libraryHaskellDepends = [

     

       149686
       149686
       +
                base containers discrimination foldl hashable hashtables parallel

     

       149687
       149687
       +
                profunctors split streaming streamly text unordered-containers

     

       149688
       149688
       +
                vector

     

       149689
       149689
       +
              ];

     

       149690
       149690
       +
              executableHaskellDepends = [

     

       149691
       149691
       +
                base containers foldl profunctors text unordered-containers

     

       149692
       149692
       +
              ];

     

       149693
       149693
       +
              testHaskellDepends = [ base containers foldl hedgehog ];

     

       149694
       149694
       +
              benchmarkHaskellDepends = [

     

       149695
       149695
       +
                base containers criterion deepseq foldl profunctors random text

     

       149696
       149696
       +
                unordered-containers

     

       149697
       149697
       +
              ];

     

       149698
       149698
       +
              description = "foldl wrappers for map-reduce";

     

       149699
       149699
       +
              license = stdenv.lib.licenses.bsd3;

     

       149165
       149700
        
            }) {};

     

       149166
       149701
        
       

     

       149167
       149702
        
         "map-syntax" = callPackage

     
···

       152498
       153033
        
            }:

     

       152499
       153034
        
            mkDerivation {

     

       152500
       153035
        
              pname = "midi-util";

     

       152501
       152501
       -
              version = "0.2.0.1";

     

       152502
       152502
       -
              sha256 = "0s37csd1x039q0cb487pd811jz7h0i26chvvbmwffh11bc2icjzc";

     

       152503
       152503
       -
              revision = "1";

     

       152504
       152504
       -
              editedCabalFile = "0a3hasbhvd327m65yqqyjah7y8r48l65bqg1ymcrc0s2zff10gl5";

     

       153036
       153036
       +
              version = "0.2.1";

     

       153037
       153037
       +
              sha256 = "0ajmjwxa2g5fjgb9zhil63mszsalmg4fqdv62zabf774z8k1x1ry";

     

       152505
       153038
        
              libraryHaskellDepends = [

     

       152506
       153039
        
                base containers event-list midi non-negative

     

       152507
       153040
        
              ];

     
···

       152949
       153482
        
            , hashable, linear, microlens, microlens-mtl, mtl, mwc-random

     

       152950
       153483
        
            , scientific, sdl2, sdl2-gfx, sdl2-image, sdl2-ttf, tasty

     

       152951
       153484
        
            , tasty-discover, tasty-hspec, template-haskell, text, trifecta

     

       152952
       152952
       -
            , unordered-containers, vector, yaml

     

       153485
       153485
       +
            , unordered-containers, uuid, vector, yaml

     

       152953
       153486
        
            }:

     

       152954
       153487
        
            mkDerivation {

     

       152955
       153488
        
              pname = "minilight";

     

       152956
       152956
       -
              version = "0.1.1";

     

       152957
       152957
       -
              sha256 = "0wl37m7wz5jdq4hwcbrnd0m5lhz9mgfk6p8ysinjwfc1458g8v91";

     

       153489
       153489
       +
              version = "0.2.0";

     

       153490
       153490
       +
              sha256 = "18kjzmqpm967z0560z09n7s61s21f13mkr6iwb5dp7a5vnwq8lxm";

     

       152958
       153491
        
              isLibrary = true;

     

       152959
       153492
        
              isExecutable = true;

     

       152960
       153493
        
              libraryHaskellDepends = [

     

       152961
       153494
        
                aeson base containers exceptions FontyFruity hashable linear

     

       152962
       153495
        
                microlens microlens-mtl mtl mwc-random scientific sdl2 sdl2-gfx

     

       152963
       153496
        
                sdl2-image sdl2-ttf template-haskell text trifecta

     

       152964
       152964
       -
                unordered-containers vector yaml

     

       153497
       153497
       +
                unordered-containers uuid vector yaml

     

       152965
       153498
        
              ];

     

       152966
       153499
        
              executableHaskellDepends = [

     

       152967
       153500
        
                base linear microlens mtl mwc-random sdl2 sdl2-ttf text vector

     
···

       152972
       153505
        
              testToolDepends = [ tasty-discover ];

     

       152973
       153506
        
              description = "A SDL2-based graphics library, batteries-included";

     

       152974
       153507
        
              license = stdenv.lib.licenses.mit;

     

       153508
       153508
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       153509
       153509
       +
              broken = true;

     

       152975
       153510
        
            }) {};

     

       152976
       153511
        
       

     

       152977
       153512
        
         "minimal-configuration" = callPackage

     
···

       153181
       153716
        
              ];

     

       153182
       153717
        
              description = "Layout and render text with TrueType fonts using OpenGL";

     

       153183
       153718
        
              license = stdenv.lib.licenses.bsd3;

     

       153719
       153719
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       153720
       153720
       +
              broken = true;

     

       153184
       153721
        
            }) {};

     

       153185
       153722
        
       

     

       153186
       153723
        
         "miniutter" = callPackage

     
···

       161783
       162320
        
              pname = "network-simple";

     

       161784
       162321
        
              version = "0.4.3";

     

       161785
       162322
        
              sha256 = "0a4hag26ry6lg90q4ppchvrm5xaij50jd4633mhfkfq8scgczm8d";

     

       161786
       161786
       -
              revision = "1";

     

       161787
       161787
       -
              editedCabalFile = "1xyz4b24vgnidvd43cfmf0k6090dayhfcp6n8x894ibd2mq3vash";

     

       162323
       162323
       +
              revision = "2";

     

       162324
       162324
       +
              editedCabalFile = "073g0agplvgan62s638w5hcq25biq8f811xhha6drfyxybs6cspn";

     

       161788
       162325
        
              libraryHaskellDepends = [

     

       161789
       162326
        
                base bytestring network safe-exceptions socks transformers

     

       161790
       162327
        
              ];

     
···

       161816
       162353
        
            }:

     

       161817
       162354
        
            mkDerivation {

     

       161818
       162355
        
              pname = "network-simple-tls";

     

       161819
       161819
       -
              version = "0.3.1";

     

       161820
       161820
       -
              sha256 = "12kwi2jc8g310wrw7ynq2hfhkxhh95qn0fy205g7a48xrw75npyj";

     

       162356
       162356
       +
              version = "0.3.2";

     

       162357
       162357
       +
              sha256 = "09fw7ynvry0wjc2nip6kwncl662f7glzq1akiwgh09bwnpbswxsh";

     

       161821
       162358
        
              libraryHaskellDepends = [

     

       161822
       162359
        
                base bytestring data-default network network-simple safe-exceptions

     

       161823
       162360
        
                tls transformers x509 x509-store x509-system x509-validation

     

       161824
       162361
        
              ];

     

       161825
       162362
        
              description = "Simple interface to TLS secured network sockets";

     

       161826
       162363
        
              license = stdenv.lib.licenses.bsd3;

     

       162364
       162364
       +
            }) {};

     

       162365
       162365
       +
       

     

       162366
       162366
       +
         "network-simple-ws" = callPackage

     

       162367
       162367
       +
           ({ mkDerivation, base, bytestring, case-insensitive, network-simple

     

       162368
       162368
       +
            , safe-exceptions, websockets

     

       162369
       162369
       +
            }:

     

       162370
       162370
       +
            mkDerivation {

     

       162371
       162371
       +
              pname = "network-simple-ws";

     

       162372
       162372
       +
              version = "0.1";

     

       162373
       162373
       +
              sha256 = "04a0q4q7idah834dvgkl4j1a8fjgrw9qkxppmk5jnvdphq6sxxzd";

     

       162374
       162374
       +
              libraryHaskellDepends = [

     

       162375
       162375
       +
                base bytestring case-insensitive network-simple safe-exceptions

     

       162376
       162376
       +
                websockets

     

       162377
       162377
       +
              ];

     

       162378
       162378
       +
              description = "Simple interface to WebSockets";

     

       162379
       162379
       +
              license = stdenv.lib.licenses.bsd3;

     

       162380
       162380
       +
            }) {};

     

       162381
       162381
       +
       

     

       162382
       162382
       +
         "network-simple-wss" = callPackage

     

       162383
       162383
       +
           ({ mkDerivation, base, bytestring, network-simple-tls

     

       162384
       162384
       +
            , network-simple-ws, safe-exceptions, websockets

     

       162385
       162385
       +
            }:

     

       162386
       162386
       +
            mkDerivation {

     

       162387
       162387
       +
              pname = "network-simple-wss";

     

       162388
       162388
       +
              version = "0.1";

     

       162389
       162389
       +
              sha256 = "1wmicn9zyf4308spf1s7dd4xbi8hfwksdigf62jdm87ywv8jd6rj";

     

       162390
       162390
       +
              libraryHaskellDepends = [

     

       162391
       162391
       +
                base bytestring network-simple-tls network-simple-ws

     

       162392
       162392
       +
                safe-exceptions websockets

     

       162393
       162393
       +
              ];

     

       162394
       162394
       +
              description = "Simple interface to TLS secured WebSockets";

     

       162395
       162395
       +
              license = stdenv.lib.licenses.bsd3;

     

       162396
       162396
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       162397
       162397
       +
              broken = true;

     

       161827
       162398
        
            }) {};

     

       161828
       162399
        
       

     

       161829
       162400
        
         "network-socket-options" = callPackage

     
···

       162509
       163080
        
            }:

     

       162510
       163081
        
            mkDerivation {

     

       162511
       163082
        
              pname = "ngx-export";

     

       162512
       162512
       -
              version = "1.7.0.1";

     

       162513
       162513
       -
              sha256 = "0gaj4v8hzjjljr5v3l1by6rhin2k8a2wsaff61s5g77gdkcmi2i5";

     

       163083
       163083
       +
              version = "1.7.1";

     

       163084
       163084
       +
              sha256 = "0dylj1i6370r1yz2rgjpjs5ynsvaqshgvz71200r0q2hqqznax6d";

     

       162514
       163085
        
              libraryHaskellDepends = [

     

       162515
       163086
        
                async base binary bytestring deepseq monad-loops template-haskell

     

       162516
       163087
        
                unix

     
···

       162525
       163096
        
            }:

     

       162526
       163097
        
            mkDerivation {

     

       162527
       163098
        
              pname = "ngx-export-tools";

     

       162528
       162528
       -
              version = "0.4.4.0";

     

       162529
       162529
       -
              sha256 = "19x6qzryjdac1alq4wsmy0as6258ga9b3ga3iszqwvqjdpc89a6n";

     

       163099
       163099
       +
              version = "0.4.5.0";

     

       163100
       163100
       +
              sha256 = "1775syhp5pgm6sdn3x8y3zqzvqrwypl07xm6rkv34sbw5x84mmmv";

     

       162530
       163101
        
              libraryHaskellDepends = [

     

       162531
       163102
        
                aeson base binary bytestring ngx-export safe template-haskell

     

       162532
       163103
        
              ];

     
···

       162534
       163105
        
              license = stdenv.lib.licenses.bsd3;

     

       162535
       163106
        
            }) {};

     

       162536
       163107
        
       

     

       163108
       163108
       +
         "ngx-export-tools-extra" = callPackage

     

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

     

       163110
       163110
       +
            , enclosed-exceptions, http-client, ngx-export-tools, snap-core

     

       163111
       163111
       +
            , snap-server, template-haskell, text, time

     

       163112
       163112
       +
            }:

     

       163113
       163113
       +
            mkDerivation {

     

       163114
       163114
       +
              pname = "ngx-export-tools-extra";

     

       163115
       163115
       +
              version = "0.1.0.0";

     

       163116
       163116
       +
              sha256 = "0j3bfrmic9zrivsnaf4kzf5bf0inianmnn7v0c21s5ip775k5jy8";

     

       163117
       163117
       +
              libraryHaskellDepends = [

     

       163118
       163118
       +
                aeson base bytestring containers enclosed-exceptions http-client

     

       163119
       163119
       +
                ngx-export-tools snap-core snap-server template-haskell text time

     

       163120
       163120
       +
              ];

     

       163121
       163121
       +
              description = "More extra tools for Nginx haskell module";

     

       163122
       163122
       +
              license = stdenv.lib.licenses.bsd3;

     

       163123
       163123
       +
            }) {};

     

       163124
       163124
       +
       

     

       162537
       163125
        
         "niagra" = callPackage

     

       162538
       163126
        
           ({ mkDerivation, base, ghc-prim, HUnit, mtl, primitive, QuickCheck

     

       162539
       163127
        
            , text, transformers

     
···

       164493
       165081
        
            }:

     

       164494
       165082
        
            mkDerivation {

     

       164495
       165083
        
              pname = "nvim-hs";

     

       164496
       164496
       -
              version = "2.0.0.0";

     

       164497
       164497
       -
              sha256 = "0wnvvzd1ry8a3863dyj6ylsh075px7ppd1wrv3cbf9694dc5zfih";

     

       165084
       165084
       +
              version = "2.1.0.0";

     

       165085
       165085
       +
              sha256 = "02i6nvdk99vjy98r666sb3ik79zq8ssri0nhnfn9r60nfcpsrini";

     

       164498
       165086
        
              libraryHaskellDepends = [

     

       164499
       165087
        
                base bytestring cereal cereal-conduit conduit containers

     

       164500
       165088
        
                data-default deepseq foreign-store hslogger megaparsec messagepack

     
···

       165147
       165735
        
       

     

       165148
       165736
        
         "odpic-raw" = callPackage

     

       165149
       165737
        
           ({ mkDerivation, base, binary, bytestring, c2hs, conduit, hspec

     

       165150
       165150
       -
            , odpic, resourcet, scientific, time

     

       165738
       165738
       +
            , resourcet, scientific, time

     

       165151
       165739
        
            }:

     

       165152
       165740
        
            mkDerivation {

     

       165153
       165741
        
              pname = "odpic-raw";

     

       165154
       165154
       -
              version = "0.4.0";

     

       165155
       165155
       -
              sha256 = "0kdsmjksy2dcsc1dgwx8r8fcv1czap06fy8n3wlg29759md1bchm";

     

       165742
       165742
       +
              version = "0.5.0";

     

       165743
       165743
       +
              sha256 = "1cgg4yvcdysh1l1h8nv9jcn26hfcyx5hxqaqpvfd292c0spylary";

     

       165156
       165744
        
              libraryHaskellDepends = [

     

       165157
       165745
        
                base binary bytestring conduit resourcet scientific time

     

       165158
       165746
        
              ];

     

       165159
       165159
       -
              librarySystemDepends = [ odpic ];

     

       165160
       165747
        
              libraryToolDepends = [ c2hs ];

     

       165161
       165748
        
              testHaskellDepends = [

     

       165162
       165749
        
                base binary bytestring conduit hspec resourcet scientific time

     

       165163
       165750
        
              ];

     

       165751
       165751
       +
              testToolDepends = [ c2hs ];

     

       165164
       165752
        
              description = "Oracle Database Bindings";

     

       165165
       165753
        
              license = stdenv.lib.licenses.mit;

     

       165166
       165754
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       165167
       165167
       -
            }) {inherit (pkgs) odpic;};

     

       165755
       165755
       +
            }) {};

     

       165168
       165756
        
       

     

       165169
       165757
        
         "oeis" = callPackage

     

       165170
       165758
        
           ({ mkDerivation, base, HTTP, HUnit, network, network-uri

     
···

       167149
       167737
        
              license = stdenv.lib.licenses.bsd3;

     

       167150
       167738
        
            }) {};

     

       167151
       167739
        
       

     

       167740
       167740
       +
         "optparse-simple_0_1_1_2" = callPackage

     

       167741
       167741
       +
           ({ mkDerivation, base, bytestring, directory, githash

     

       167742
       167742
       +
            , optparse-applicative, template-haskell, transformers

     

       167743
       167743
       +
            }:

     

       167744
       167744
       +
            mkDerivation {

     

       167745
       167745
       +
              pname = "optparse-simple";

     

       167746
       167746
       +
              version = "0.1.1.2";

     

       167747
       167747
       +
              sha256 = "1r00hkri42vyx552l8hcd1779fxiyl9w4k0pql915zsprirn8w82";

     

       167748
       167748
       +
              isLibrary = true;

     

       167749
       167749
       +
              isExecutable = true;

     

       167750
       167750
       +
              libraryHaskellDepends = [

     

       167751
       167751
       +
                base githash optparse-applicative template-haskell transformers

     

       167752
       167752
       +
              ];

     

       167753
       167753
       +
              testHaskellDepends = [ base bytestring directory ];

     

       167754
       167754
       +
              description = "Simple interface to optparse-applicative";

     

       167755
       167755
       +
              license = stdenv.lib.licenses.bsd3;

     

       167756
       167756
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       167757
       167757
       +
            }) {};

     

       167758
       167758
       +
       

     

       167152
       167759
        
         "optparse-text" = callPackage

     

       167153
       167760
        
           ({ mkDerivation, base, hspec, optparse-applicative, text }:

     

       167154
       167761
        
            mkDerivation {

     
···

       168459
       169066
        
              pname = "pandoc";

     

       168460
       169067
        
              version = "2.7.2";

     

       168461
       169068
        
              sha256 = "1qjla7zk8whx17qapmv3zji6b98qdpd464gwhi4zv8g4hfzv7010";

     

       168462
       168462
       -
              revision = "1";

     

       168463
       168463
       -
              editedCabalFile = "0xxnb1arycrlxjqnnka4gsz7nff70ahvr6zbrladhigian4mpk9z";

     

       169069
       169069
       +
              revision = "3";

     

       169070
       169070
       +
              editedCabalFile = "17m7pd1d1q7blavh5vv9m9ll2v9z4pj48k7cn3x6k884c9haicwc";

     

       168464
       169071
        
              configureFlags = [ "-fhttps" "-f-trypandoc" ];

     

       168465
       169072
        
              isLibrary = true;

     

       168466
       169073
        
              isExecutable = true;

     
···

       168530
       169137
        
              license = stdenv.lib.licenses.bsd3;

     

       168531
       169138
        
            }) {};

     

       168532
       169139
        
       

     

       168533
       168533
       -
         "pandoc-citeproc_0_16_1_3" = callPackage

     

       169140
       169140
       +
         "pandoc-citeproc_0_16_2" = callPackage

     

       168534
       169141
        
           ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring

     

       168535
       169142
        
            , Cabal, containers, data-default, directory, filepath, hs-bibutils

     

       168536
       169143
        
            , libyaml, mtl, network, old-locale, pandoc, pandoc-types, parsec

     
···

       168539
       169146
        
            }:

     

       168540
       169147
        
            mkDerivation {

     

       168541
       169148
        
              pname = "pandoc-citeproc";

     

       168542
       168542
       -
              version = "0.16.1.3";

     

       168543
       168543
       -
              sha256 = "13pd7rfpzpc7a4dn2sasc30icrihv5kgmngyx70s4v42scgsfndg";

     

       169149
       169149
       +
              version = "0.16.2";

     

       169150
       169150
       +
              sha256 = "15mm17awgi1b5yazwhr5nh8b59qml1qk6pz6gpyijks70fq2arsv";

     

       168544
       169151
        
              isLibrary = true;

     

       168545
       169152
        
              isExecutable = true;

     

       168546
       169153
        
              enableSeparateDataOutput = true;

     
···

       168837
       169444
        
              license = stdenv.lib.licenses.mit;

     

       168838
       169445
        
            }) {};

     

       168839
       169446
        
       

     

       168840
       168840
       -
         "pandoc-pyplot_2_1_0_1" = callPackage

     

       168841
       168841
       -
           ({ mkDerivation, base, containers, data-default-class, directory

     

       168842
       168842
       -
            , filepath, hashable, hspec, hspec-expectations, pandoc

     

       168843
       168843
       -
            , pandoc-types, tasty, tasty-hspec, tasty-hunit, temporary, text

     

       168844
       168844
       -
            , typed-process, yaml

     

       169447
       169447
       +
         "pandoc-pyplot_2_1_1_0" = callPackage

     

       169448
       169448
       +
           ({ mkDerivation, base, containers, data-default-class, deepseq

     

       169449
       169449
       +
            , directory, filepath, hashable, hspec, hspec-expectations

     

       169450
       169450
       +
            , open-browser, pandoc, pandoc-types, tasty, tasty-hspec

     

       169451
       169451
       +
            , tasty-hunit, template-haskell, temporary, text, typed-process

     

       169452
       169452
       +
            , yaml

     

       168845
       169453
        
            }:

     

       168846
       169454
        
            mkDerivation {

     

       168847
       169455
        
              pname = "pandoc-pyplot";

     

       168848
       168848
       -
              version = "2.1.0.1";

     

       168849
       168849
       -
              sha256 = "0hhsy90chq3ap54816qhpplxg4c8iwdvx8xrcrn2n0p3yi2ma0yi";

     

       169456
       169456
       +
              version = "2.1.1.0";

     

       169457
       169457
       +
              sha256 = "0s66m591v6x91qqdkyxl40zwlv6nan86zfq5z4cx73yz9xf3gjsx";

     

       168850
       169458
        
              isLibrary = true;

     

       168851
       169459
        
              isExecutable = true;

     

       168852
       169460
        
              libraryHaskellDepends = [

     
···

       168854
       169462
        
                pandoc pandoc-types temporary text typed-process yaml

     

       168855
       169463
        
              ];

     

       168856
       169464
        
              executableHaskellDepends = [

     

       168857
       168857
       -
                base data-default-class directory pandoc-types

     

       169465
       169465
       +
                base data-default-class deepseq directory filepath open-browser

     

       169466
       169466
       +
                pandoc pandoc-types template-haskell temporary text

     

       168858
       169467
        
              ];

     

       168859
       169468
        
              testHaskellDepends = [

     

       168860
       169469
        
                base data-default-class directory filepath hspec hspec-expectations

     

       168861
       169470
        
                pandoc-types tasty tasty-hspec tasty-hunit temporary text

     

       168862
       169471
        
              ];

     

       168863
       168863
       -
              description = "A Pandoc filter for including figures generated from Matplotlib";

     

       169472
       169472
       +
              description = "A Pandoc filter to include figures generated from Python code blocks";

     

       168864
       169473
        
              license = stdenv.lib.licenses.mit;

     

       168865
       169474
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       168866
       169475
        
            }) {};

     
···

       170321
       170930
        
            }:

     

       170322
       170931
        
            mkDerivation {

     

       170323
       170932
        
              pname = "parsix";

     

       170324
       170324
       -
              version = "0.2.0.0";

     

       170325
       170325
       -
              sha256 = "07azgir8gkjbr2if8cvcmlqf3v9bi27w4xh922j0r9q1c3ry7k5i";

     

       170933
       170933
       +
              version = "0.2.1.0";

     

       170934
       170934
       +
              sha256 = "1282mzlriyl4gi0l2ds4a3prjh6q0vl5cv14ms03999hmygpnr3l";

     

       170326
       170935
        
              libraryHaskellDepends = [

     

       170327
       170936
        
                base containers fingertree mtl parsers prettyprinter

     

       170328
       170937
        
                prettyprinter-ansi-terminal text transformers

     
···

       172269
       172878
        
            }:

     

       172270
       172879
        
            mkDerivation {

     

       172271
       172880
        
              pname = "persist";

     

       172272
       172272
       -
              version = "0.1.1.2";

     

       172273
       172273
       -
              sha256 = "08l59z7jc1ij7y497yjvv0q9bcd100l3bkdj4zwjl3dx6fhz2gq2";

     

       172881
       172881
       +
              version = "0.1.1.3";

     

       172882
       172882
       +
              sha256 = "0lcjk2q9x0qclc3znwv9xrqqwbczw2ryvamfqa6hvabr618lmi4p";

     

       172274
       172883
        
              libraryHaskellDepends = [ base bytestring containers text ];

     

       172275
       172884
        
              testHaskellDepends = [

     

       172276
       172885
        
                base bytestring QuickCheck test-framework

     
···

       172399
       173008
        
              ];

     

       172400
       173009
        
              description = "Type-safe, multi-backend data serialization";

     

       172401
       173010
        
              license = stdenv.lib.licenses.mit;

     

       173011
       173011
       +
              maintainers = with stdenv.lib.maintainers; [ psibi ];

     

       173012
       173012
       +
            }) {};

     

       173013
       173013
       +
       

     

       173014
       173014
       +
         "persistent_2_10_0" = callPackage

     

       173015
       173015
       +
           ({ mkDerivation, aeson, attoparsec, base, base64-bytestring

     

       173016
       173016
       +
            , blaze-html, bytestring, conduit, containers, fast-logger, hspec

     

       173017
       173017
       +
            , http-api-data, monad-logger, mtl, path-pieces, resource-pool

     

       173018
       173018
       +
            , resourcet, scientific, silently, template-haskell, text, time

     

       173019
       173019
       +
            , transformers, unliftio-core, unordered-containers, vector

     

       173020
       173020
       +
            }:

     

       173021
       173021
       +
            mkDerivation {

     

       173022
       173022
       +
              pname = "persistent";

     

       173023
       173023
       +
              version = "2.10.0";

     

       173024
       173024
       +
              sha256 = "1ja34gdwf72rxnz3v5d9wjri11285fpzxn8sh9ws7ldrx3kfqy1g";

     

       173025
       173025
       +
              libraryHaskellDepends = [

     

       173026
       173026
       +
                aeson attoparsec base base64-bytestring blaze-html bytestring

     

       173027
       173027
       +
                conduit containers fast-logger http-api-data monad-logger mtl

     

       173028
       173028
       +
                path-pieces resource-pool resourcet scientific silently

     

       173029
       173029
       +
                template-haskell text time transformers unliftio-core

     

       173030
       173030
       +
                unordered-containers vector

     

       173031
       173031
       +
              ];

     

       173032
       173032
       +
              testHaskellDepends = [

     

       173033
       173033
       +
                aeson attoparsec base base64-bytestring blaze-html bytestring

     

       173034
       173034
       +
                containers hspec http-api-data path-pieces scientific text time

     

       173035
       173035
       +
                transformers unordered-containers vector

     

       173036
       173036
       +
              ];

     

       173037
       173037
       +
              description = "Type-safe, multi-backend data serialization";

     

       173038
       173038
       +
              license = stdenv.lib.licenses.mit;

     

       173039
       173039
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       172402
       173040
        
              maintainers = with stdenv.lib.maintainers; [ psibi ];

     

       172403
       173041
        
            }) {};

     

       172404
       173042
        
       

     
···

       172599
       173237
        
              pname = "persistent-mysql";

     

       172600
       173238
        
              version = "2.9.0";

     

       172601
       173239
        
              sha256 = "0aa1ia4r49vy5hfg59rbrfmfwdyaix0l32drdjnj9xxqbayifjzf";

     

       173240
       173240
       +
              revision = "1";

     

       173241
       173241
       +
              editedCabalFile = "0xvis08x4ajayp73f6j0czpksn309f3anv5kklxa9r6j8j5qkhvz";

     

       172602
       173242
        
              libraryHaskellDepends = [

     

       172603
       173243
        
                aeson base blaze-builder bytestring conduit containers monad-logger

     

       172604
       173244
        
                mysql mysql-simple persistent resource-pool resourcet text

     
···

       172608
       173248
        
              license = stdenv.lib.licenses.mit;

     

       172609
       173249
        
            }) {};

     

       172610
       173250
        
       

     

       173251
       173251
       +
         "persistent-mysql_2_10_0" = callPackage

     

       173252
       173252
       +
           ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit

     

       173253
       173253
       +
            , containers, fast-logger, hspec, HUnit, monad-logger, mysql

     

       173254
       173254
       +
            , mysql-simple, persistent, persistent-qq, persistent-template

     

       173255
       173255
       +
            , persistent-test, QuickCheck, quickcheck-instances, resource-pool

     

       173256
       173256
       +
            , resourcet, text, time, transformers, unliftio-core

     

       173257
       173257
       +
            }:

     

       173258
       173258
       +
            mkDerivation {

     

       173259
       173259
       +
              pname = "persistent-mysql";

     

       173260
       173260
       +
              version = "2.10.0";

     

       173261
       173261
       +
              sha256 = "13y65l0vaiczxndah2djh28j4jhslymb53gnfz3av24kg5vb2y4n";

     

       173262
       173262
       +
              libraryHaskellDepends = [

     

       173263
       173263
       +
                aeson base blaze-builder bytestring conduit containers monad-logger

     

       173264
       173264
       +
                mysql mysql-simple persistent resource-pool resourcet text

     

       173265
       173265
       +
                transformers unliftio-core

     

       173266
       173266
       +
              ];

     

       173267
       173267
       +
              testHaskellDepends = [

     

       173268
       173268
       +
                base bytestring containers fast-logger hspec HUnit monad-logger

     

       173269
       173269
       +
                mysql persistent persistent-qq persistent-template persistent-test

     

       173270
       173270
       +
                QuickCheck quickcheck-instances resourcet text time transformers

     

       173271
       173271
       +
                unliftio-core

     

       173272
       173272
       +
              ];

     

       173273
       173273
       +
              description = "Backend for the persistent library using MySQL database server";

     

       173274
       173274
       +
              license = stdenv.lib.licenses.mit;

     

       173275
       173275
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       173276
       173276
       +
            }) {};

     

       173277
       173277
       +
       

     

       172611
       173278
        
         "persistent-mysql-haskell" = callPackage

     

       172612
       173279
        
           ({ mkDerivation, aeson, base, bytestring, conduit, containers

     

       172613
       173280
        
            , io-streams, monad-logger, mysql-haskell, network, persistent

     
···

       172684
       173351
        
              ];

     

       172685
       173352
        
              description = "Backend for the persistent library using postgresql";

     

       172686
       173353
        
              license = stdenv.lib.licenses.mit;

     

       173354
       173354
       +
              maintainers = with stdenv.lib.maintainers; [ psibi ];

     

       173355
       173355
       +
            }) {};

     

       173356
       173356
       +
       

     

       173357
       173357
       +
         "persistent-postgresql_2_10_0" = callPackage

     

       173358
       173358
       +
           ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit

     

       173359
       173359
       +
            , containers, fast-logger, hspec, hspec-expectations, HUnit

     

       173360
       173360
       +
            , monad-logger, persistent, persistent-qq, persistent-template

     

       173361
       173361
       +
            , persistent-test, postgresql-libpq, postgresql-simple, QuickCheck

     

       173362
       173362
       +
            , quickcheck-instances, resource-pool, resourcet, text, time

     

       173363
       173363
       +
            , transformers, unliftio-core, unordered-containers, vector

     

       173364
       173364
       +
            }:

     

       173365
       173365
       +
            mkDerivation {

     

       173366
       173366
       +
              pname = "persistent-postgresql";

     

       173367
       173367
       +
              version = "2.10.0";

     

       173368
       173368
       +
              sha256 = "00kc14zf6ggblyps68qvg7d0s4wbsz0iv96sdvjv5rsqwblrav18";

     

       173369
       173369
       +
              libraryHaskellDepends = [

     

       173370
       173370
       +
                aeson base blaze-builder bytestring conduit containers monad-logger

     

       173371
       173371
       +
                persistent postgresql-libpq postgresql-simple resource-pool

     

       173372
       173372
       +
                resourcet text time transformers unliftio-core

     

       173373
       173373
       +
              ];

     

       173374
       173374
       +
              testHaskellDepends = [

     

       173375
       173375
       +
                aeson base bytestring containers fast-logger hspec

     

       173376
       173376
       +
                hspec-expectations HUnit monad-logger persistent persistent-qq

     

       173377
       173377
       +
                persistent-template persistent-test QuickCheck quickcheck-instances

     

       173378
       173378
       +
                resourcet text time transformers unliftio-core unordered-containers

     

       173379
       173379
       +
                vector

     

       173380
       173380
       +
              ];

     

       173381
       173381
       +
              description = "Backend for the persistent library using postgresql";

     

       173382
       173382
       +
              license = stdenv.lib.licenses.mit;

     

       173383
       173383
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       172687
       173384
        
              maintainers = with stdenv.lib.maintainers; [ psibi ];

     

       172688
       173385
        
            }) {};

     

       172689
       173386
        
       

     
···

       172876
       173573
        
              maintainers = with stdenv.lib.maintainers; [ psibi ];

     

       172877
       173574
        
            }) {inherit (pkgs) sqlite;};

     

       172878
       173575
        
       

     

       173576
       173576
       +
         "persistent-sqlite_2_10_0" = callPackage

     

       173577
       173577
       +
           ({ mkDerivation, aeson, base, bytestring, conduit, containers

     

       173578
       173578
       +
            , exceptions, fast-logger, hspec, HUnit, microlens-th, monad-logger

     

       173579
       173579
       +
            , persistent, persistent-template, persistent-test, QuickCheck

     

       173580
       173580
       +
            , resource-pool, resourcet, sqlite, system-fileio, system-filepath

     

       173581
       173581
       +
            , temporary, text, time, transformers, unliftio-core

     

       173582
       173582
       +
            , unordered-containers

     

       173583
       173583
       +
            }:

     

       173584
       173584
       +
            mkDerivation {

     

       173585
       173585
       +
              pname = "persistent-sqlite";

     

       173586
       173586
       +
              version = "2.10.0";

     

       173587
       173587
       +
              sha256 = "1h3ls1wg02q7336zqfrpggx64f1wm3x701dvkwvci6yn4hqvkpn2";

     

       173588
       173588
       +
              revision = "1";

     

       173589
       173589
       +
              editedCabalFile = "1kxqz47h2gxinck114ip75brbm0wsimff5fdzldv72mqv7id66nl";

     

       173590
       173590
       +
              configureFlags = [ "-fsystemlib" ];

     

       173591
       173591
       +
              isLibrary = true;

     

       173592
       173592
       +
              isExecutable = true;

     

       173593
       173593
       +
              libraryHaskellDepends = [

     

       173594
       173594
       +
                aeson base bytestring conduit containers microlens-th monad-logger

     

       173595
       173595
       +
                persistent resource-pool resourcet text time transformers

     

       173596
       173596
       +
                unliftio-core unordered-containers

     

       173597
       173597
       +
              ];

     

       173598
       173598
       +
              librarySystemDepends = [ sqlite ];

     

       173599
       173599
       +
              testHaskellDepends = [

     

       173600
       173600
       +
                base bytestring containers exceptions fast-logger hspec HUnit

     

       173601
       173601
       +
                monad-logger persistent persistent-template persistent-test

     

       173602
       173602
       +
                QuickCheck resourcet system-fileio system-filepath temporary text

     

       173603
       173603
       +
                time transformers unliftio-core

     

       173604
       173604
       +
              ];

     

       173605
       173605
       +
              description = "Backend for the persistent library using sqlite3";

     

       173606
       173606
       +
              license = stdenv.lib.licenses.mit;

     

       173607
       173607
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       173608
       173608
       +
              maintainers = with stdenv.lib.maintainers; [ psibi ];

     

       173609
       173609
       +
            }) {inherit (pkgs) sqlite;};

     

       173610
       173610
       +
       

     

       172879
       173611
        
         "persistent-template" = callPackage

     

       172880
       173612
        
           ({ mkDerivation, aeson, aeson-compat, base, bytestring, containers

     

       172881
       173613
        
            , ghc-prim, hspec, http-api-data, monad-control, monad-logger

     
···

       172901
       173633
        
              maintainers = with stdenv.lib.maintainers; [ psibi ];

     

       172902
       173634
        
            }) {};

     

       172903
       173635
        
       

     

       172904
       172904
       -
         "persistent-template_2_6_0" = callPackage

     

       172905
       172905
       -
           ({ mkDerivation, aeson, aeson-compat, base, bytestring, containers

     

       172906
       172906
       -
            , ghc-prim, hspec, http-api-data, monad-control, monad-logger

     

       172907
       172907
       -
            , path-pieces, persistent, QuickCheck, tagged, template-haskell

     

       172908
       172908
       -
            , text, transformers, unordered-containers

     

       173636
       173636
       +
         "persistent-template_2_7_0" = callPackage

     

       173637
       173637
       +
           ({ mkDerivation, aeson, base, bytestring, containers, criterion

     

       173638
       173638
       +
            , deepseq, deepseq-generics, file-embed, hspec, http-api-data

     

       173639
       173639
       +
            , monad-control, monad-logger, path-pieces, persistent, QuickCheck

     

       173640
       173640
       +
            , template-haskell, text, transformers, unordered-containers

     

       172909
       173641
        
            }:

     

       172910
       173642
        
            mkDerivation {

     

       172911
       173643
        
              pname = "persistent-template";

     

       172912
       172912
       -
              version = "2.6.0";

     

       172913
       172913
       -
              sha256 = "0wr1z2nfrl6jv1lprxb0d2jw4izqfcbcwvkdrhryzg95gjz8ryjv";

     

       173644
       173644
       +
              version = "2.7.0";

     

       173645
       173645
       +
              sha256 = "0pz750b7ybg27nl9b7hiw25vg0dwjy8196c6kpj1xwfgcxkdizq5";

     

       172914
       173646
        
              libraryHaskellDepends = [

     

       172915
       172915
       -
                aeson aeson-compat base bytestring containers ghc-prim

     

       172916
       172916
       -
                http-api-data monad-control monad-logger path-pieces persistent

     

       172917
       172917
       -
                tagged template-haskell text transformers unordered-containers

     

       173647
       173647
       +
                aeson base bytestring containers http-api-data monad-control

     

       173648
       173648
       +
                monad-logger path-pieces persistent template-haskell text

     

       173649
       173649
       +
                transformers unordered-containers

     

       172918
       173650
        
              ];

     

       172919
       173651
        
              testHaskellDepends = [

     

       172920
       172920
       -
                aeson base bytestring hspec persistent QuickCheck text transformers

     

       173652
       173652
       +
                aeson base bytestring hspec persistent QuickCheck text

     

       173653
       173653
       +
              ];

     

       173654
       173654
       +
              benchmarkHaskellDepends = [

     

       173655
       173655
       +
                base criterion deepseq deepseq-generics file-embed persistent

     

       173656
       173656
       +
                template-haskell text

     

       172921
       173657
        
              ];

     

       172922
       173658
        
              description = "Type-safe, non-relational, multi-backend persistence";

     

       172923
       173659
        
              license = stdenv.lib.licenses.mit;

     
···

       174421
       175157
        
              license = stdenv.lib.licenses.bsd3;

     

       174422
       175158
        
            }) {};

     

       174423
       175159
        
       

     

       175160
       175160
       +
         "pipes-brotli" = callPackage

     

       175161
       175161
       +
           ({ mkDerivation, base, brotli, bytestring, pipes, pipes-bytestring

     

       175162
       175162
       +
            , QuickCheck

     

       175163
       175163
       +
            }:

     

       175164
       175164
       +
            mkDerivation {

     

       175165
       175165
       +
              pname = "pipes-brotli";

     

       175166
       175166
       +
              version = "0.0.0.0";

     

       175167
       175167
       +
              sha256 = "0qld1j404sddw850pdm5y65n8rld5vqzpr38kq9xcnlxmfs29zhp";

     

       175168
       175168
       +
              libraryHaskellDepends = [ base brotli bytestring pipes ];

     

       175169
       175169
       +
              testHaskellDepends = [

     

       175170
       175170
       +
                base bytestring pipes pipes-bytestring QuickCheck

     

       175171
       175171
       +
              ];

     

       175172
       175172
       +
              description = "Brotli (RFC7932) compressors and decompressors for the Pipes package";

     

       175173
       175173
       +
              license = stdenv.lib.licenses.bsd3;

     

       175174
       175174
       +
            }) {};

     

       175175
       175175
       +
       

     

       174424
       175176
        
         "pipes-bytestring" = callPackage

     

       174425
       175177
        
           ({ mkDerivation, base, bytestring, pipes, pipes-group, pipes-parse

     

       174426
       175178
        
            , stringsearch, transformers

     
···

       174994
       175746
        
              license = stdenv.lib.licenses.bsd3;

     

       174995
       175747
        
            }) {};

     

       174996
       175748
        
       

     

       175749
       175749
       +
         "pipes-network-ws" = callPackage

     

       175750
       175750
       +
           ({ mkDerivation, base, bytestring, network-simple-ws, pipes }:

     

       175751
       175751
       +
            mkDerivation {

     

       175752
       175752
       +
              pname = "pipes-network-ws";

     

       175753
       175753
       +
              version = "0.1";

     

       175754
       175754
       +
              sha256 = "1jb59wl3xh0jkp4njj7xhybhnanwrx6h0zzj647lgxg6wpf8f704";

     

       175755
       175755
       +
              libraryHaskellDepends = [

     

       175756
       175756
       +
                base bytestring network-simple-ws pipes

     

       175757
       175757
       +
              ];

     

       175758
       175758
       +
              description = "WebSockets support for pipes";

     

       175759
       175759
       +
              license = stdenv.lib.licenses.bsd3;

     

       175760
       175760
       +
            }) {};

     

       175761
       175761
       +
       

     

       174997
       175762
        
         "pipes-ordered-zip" = callPackage

     

       174998
       175763
        
           ({ mkDerivation, base, foldl, pipes }:

     

       174999
       175764
        
            mkDerivation {

     
···

       175838
       176603
        
            }:

     

       175839
       176604
        
            mkDerivation {

     

       175840
       176605
        
              pname = "playlists-http";

     

       175841
       175841
       -
              version = "0.2.1.0";

     

       175842
       175842
       -
              sha256 = "1kzc1awfqk979h2hmpqh2pjiy33v140pibbp703hqbq0fkrynj2k";

     

       176606
       176606
       +
              version = "0.2.1.1";

     

       176607
       176607
       +
              sha256 = "1smshj9ib0fp9kd7bsj15nq6vglzrdy8wzs3l6pi1rf6sjhjhb3l";

     

       175843
       176608
        
              isLibrary = true;

     

       175844
       176609
        
              isExecutable = true;

     

       175845
       176610
        
              libraryHaskellDepends = [

     
···

       176697
       177462
        
              license = stdenv.lib.licenses.bsd3;

     

       176698
       177463
        
            }) {};

     

       176699
       177464
        
       

     

       177465
       177465
       +
         "poly" = callPackage

     

       177466
       177466
       +
           ({ mkDerivation, base, QuickCheck, quickcheck-classes, semirings

     

       177467
       177467
       +
            , tasty, tasty-quickcheck, vector

     

       177468
       177468
       +
            }:

     

       177469
       177469
       +
            mkDerivation {

     

       177470
       177470
       +
              pname = "poly";

     

       177471
       177471
       +
              version = "0.1.0.0";

     

       177472
       177472
       +
              sha256 = "1aipcajm5vg7ircpds2sg7ryvhid77hc56hsk146i5hyblnb4wbw";

     

       177473
       177473
       +
              libraryHaskellDepends = [ base semirings vector ];

     

       177474
       177474
       +
              testHaskellDepends = [

     

       177475
       177475
       +
                base QuickCheck quickcheck-classes semirings tasty tasty-quickcheck

     

       177476
       177476
       +
                vector

     

       177477
       177477
       +
              ];

     

       177478
       177478
       +
              description = "Polynomials";

     

       177479
       177479
       +
              license = stdenv.lib.licenses.bsd3;

     

       177480
       177480
       +
            }) {};

     

       177481
       177481
       +
       

     

       176700
       177482
        
         "poly-arity" = callPackage

     

       176701
       177483
        
           ({ mkDerivation, base, constraints }:

     

       176702
       177484
        
            mkDerivation {

     
···

       179354
       180136
        
            }:

     

       179355
       180137
        
            mkDerivation {

     

       179356
       180138
        
              pname = "pretty-ghci";

     

       179357
       179357
       -
              version = "0.1.0.0";

     

       179358
       179358
       -
              sha256 = "0g3vssp09n77p05z7y36iddq05gymzlaar6k3k3si49il0cl56v7";

     

       180139
       180139
       +
              version = "0.2.0.0";

     

       180140
       180140
       +
              sha256 = "1ng4ypjz3yq2f536pd89bkwsdc2icfkw54ys5j5kzm75khgkhqg1";

     

       179359
       180141
        
              isLibrary = true;

     

       179360
       180142
        
              isExecutable = true;

     

       179361
       180143
        
              libraryHaskellDepends = [

     
···

       181483
       182265
        
            }:

     

       181484
       182266
        
            mkDerivation {

     

       181485
       182267
        
              pname = "proto-lens-arbitrary";

     

       181486
       181486
       -
              version = "0.1.2.6";

     

       181487
       181487
       -
              sha256 = "1ij221zy2m7g9wp05ksk7labminvp6zynylfh4bc7z50qmhbwgr3";

     

       182268
       182268
       +
              version = "0.1.2.7";

     

       182269
       182269
       +
              sha256 = "092gdxw1jbhp0pxzgyg8jmcwiimyhzvhxh29h7c7vmvb6m956d0f";

     

       181488
       182270
        
              libraryHaskellDepends = [

     

       181489
       182271
        
                base bytestring containers lens-family proto-lens QuickCheck text

     

       181490
       182272
        
              ];

     
···

       182773
       183555
        
            }:

     

       182774
       183556
        
            mkDerivation {

     

       182775
       183557
        
              pname = "purescript";

     

       182776
       182776
       -
              version = "0.12.4";

     

       182777
       182777
       -
              sha256 = "1lkicclh9gm3lwgi2vl7qqa2vzf763rw06m79mr1j291z4h2ym76";

     

       183558
       183558
       +
              version = "0.12.5";

     

       183559
       183559
       +
              sha256 = "0dpn0v510lgzd9zqglqan4m8l7bf891psqmih147pnrmigmiaa39";

     

       182778
       183560
        
              isLibrary = true;

     

       182779
       183561
        
              isExecutable = true;

     

       182780
       183562
        
              libraryHaskellDepends = [

     
···

       186159
       186941
        
              broken = true;

     

       186160
       186942
        
            }) {};

     

       186161
       186943
        
       

     

       186944
       186944
       +
         "rank2classes_1_3" = callPackage

     

       186945
       186945
       +
           ({ mkDerivation, base, distributive, doctest, tasty, tasty-hunit

     

       186946
       186946
       +
            , template-haskell, transformers

     

       186947
       186947
       +
            }:

     

       186948
       186948
       +
            mkDerivation {

     

       186949
       186949
       +
              pname = "rank2classes";

     

       186950
       186950
       +
              version = "1.3";

     

       186951
       186951
       +
              sha256 = "1mwwismxafz43qjqh74gjd8d1hiflkilkxkwfvwhq0gx4h4i0rq1";

     

       186952
       186952
       +
              libraryHaskellDepends = [

     

       186953
       186953
       +
                base distributive template-haskell transformers

     

       186954
       186954
       +
              ];

     

       186955
       186955
       +
              testHaskellDepends = [

     

       186956
       186956
       +
                base distributive doctest tasty tasty-hunit

     

       186957
       186957
       +
              ];

     

       186958
       186958
       +
              description = "standard type constructor class hierarchy, only with methods of rank 2 types";

     

       186959
       186959
       +
              license = stdenv.lib.licenses.bsd3;

     

       186960
       186960
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       186961
       186961
       +
              broken = true;

     

       186962
       186962
       +
            }) {};

     

       186963
       186963
       +
       

     

       186162
       186964
        
         "rapid" = callPackage

     

       186163
       186965
        
           ({ mkDerivation, async, base, containers, foreign-store, stm }:

     

       186164
       186966
        
            mkDerivation {

     
···

       186558
       187360
        
              license = stdenv.lib.licenses.bsd3;

     

       186559
       187361
        
            }) {};

     

       186560
       187362
        
       

     

       187363
       187363
       +
         "rattle" = callPackage

     

       187364
       187364
       +
           ({ mkDerivation, base, bytestring, cryptohash-sha256, deepseq

     

       187365
       187365
       +
            , directory, extra, filepath, filepattern, hashable, shake, time

     

       187366
       187366
       +
            , transformers, unordered-containers

     

       187367
       187367
       +
            }:

     

       187368
       187368
       +
            mkDerivation {

     

       187369
       187369
       +
              pname = "rattle";

     

       187370
       187370
       +
              version = "0.1";

     

       187371
       187371
       +
              sha256 = "10ra58lqhi9pn92rgyv6lkz7036kbq9gr6ly5w1lqdayla10fqhr";

     

       187372
       187372
       +
              revision = "1";

     

       187373
       187373
       +
              editedCabalFile = "1ppli9l28b4pg6h57kx7vvy0wqacn4vx86bvrgjcwwlvlir49scw";

     

       187374
       187374
       +
              libraryHaskellDepends = [

     

       187375
       187375
       +
                base bytestring cryptohash-sha256 deepseq directory extra filepath

     

       187376
       187376
       +
                hashable shake time transformers unordered-containers

     

       187377
       187377
       +
              ];

     

       187378
       187378
       +
              testHaskellDepends = [ base directory extra filepattern shake ];

     

       187379
       187379
       +
              description = "Forward build system, with caching and speculation";

     

       187380
       187380
       +
              license = stdenv.lib.licenses.bsd3;

     

       187381
       187381
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       187382
       187382
       +
              broken = true;

     

       187383
       187383
       +
            }) {};

     

       187384
       187384
       +
       

     

       186561
       187385
        
         "rattletrap" = callPackage

     

       186562
       187386
        
           ({ mkDerivation, aeson, aeson-pretty, base, binary, binary-bits

     

       186563
       187387
        
            , bytestring, clock, containers, filepath, http-client

     
···

       186591
       187415
        
              broken = true;

     

       186592
       187416
        
            }) {};

     

       186593
       187417
        
       

     

       186594
       186594
       -
         "rattletrap_6_2_3" = callPackage

     

       187418
       187418
       +
         "rattletrap_6_3_0" = callPackage

     

       186595
       187419
        
           ({ mkDerivation, aeson, aeson-pretty, base, binary, binary-bits

     

       186596
       187420
        
            , bytestring, clock, containers, filepath, http-client

     

       186597
       187421
        
            , http-client-tls, HUnit, template-haskell, temporary, text

     
···

       186599
       187423
        
            }:

     

       186600
       187424
        
            mkDerivation {

     

       186601
       187425
        
              pname = "rattletrap";

     

       186602
       186602
       -
              version = "6.2.3";

     

       186603
       186603
       -
              sha256 = "0h542a6i1rc1zh2xy4fc9cdaq424hka77mxndg2ka8a0c0mj0jfp";

     

       187426
       187426
       +
              version = "6.3.0";

     

       187427
       187427
       +
              sha256 = "0b20ih5b1g74zpdyhlpi9j98zjimad1b6lwmxqqdcviw2wwih28p";

     

       186604
       187428
        
              isLibrary = true;

     

       186605
       187429
        
              isExecutable = true;

     

       186606
       187430
        
              libraryHaskellDepends = [

     
···

       186890
       187714
        
            }:

     

       186891
       187715
        
            mkDerivation {

     

       186892
       187716
        
              pname = "rdf";

     

       186893
       186893
       -
              version = "0.1.0.2";

     

       186894
       186894
       -
              sha256 = "0vqznprx5r7lqyj8b850pfyy7mvin55l1v4krmi1wyacynv977c8";

     

       187717
       187717
       +
              version = "0.1.0.3";

     

       187718
       187718
       +
              sha256 = "0bypvzr4xj3nvq839slhjcl6lzs4zp34yg6q3hdkwa5vgall6x2s";

     

       187719
       187719
       +
              revision = "1";

     

       187720
       187720
       +
              editedCabalFile = "0x5zdjbyrpap5qs40yl0m96fcgy11f6s5r3v0n8n5904cxa5sqy3";

     

       186895
       187721
        
              libraryHaskellDepends = [

     

       186896
       187722
        
                attoparsec base bytestring deepseq dlist fgl text transformers

     

       186897
       187723
        
              ];

     
···

       189704
       190530
        
            }:

     

       189705
       190531
        
            mkDerivation {

     

       189706
       190532
        
              pname = "registry";

     

       189707
       189707
       -
              version = "0.1.3.4";

     

       189708
       189708
       -
              sha256 = "1l26b1isxqfax7c91l23fqx2kyl5cw4j2b6i0jiiz8lcn71qy0ha";

     

       190533
       190533
       +
              version = "0.1.3.5";

     

       190534
       190534
       +
              sha256 = "1nyk32bimkhsbz2597hdy089c7w5025wj9yfj1i3gd0145liaf2h";

     

       189709
       190535
        
              libraryHaskellDepends = [

     

       189710
       190536
        
                base containers exceptions hashable mtl protolude resourcet

     

       189711
       190537
        
                semigroupoids semigroups template-haskell text transformers-base

     
···

       191005
       191831
        
              pname = "req";

     

       191006
       191832
        
              version = "2.0.1";

     

       191007
       191833
        
              sha256 = "1mfm6yy23l64kqbxvp1yn3yqf7fl46as87rz4yazg7f5x13bas3r";

     

       191834
       191834
       +
              revision = "1";

     

       191835
       191835
       +
              editedCabalFile = "1ghz63gcgkfd7hqx3ff97fg6m3cw1ariqk06ck2x75cn4y42myvn";

     

       191008
       191836
        
              enableSeparateDataOutput = true;

     

       191009
       191837
        
              libraryHaskellDepends = [

     

       191010
       191838
        
                aeson authenticate-oauth base blaze-builder bytestring

     
···

       194864
       195692
        
              broken = true;

     

       194865
       195693
        
            }) {};

     

       194866
       195694
        
       

     

       195695
       195695
       +
         "safe-json" = callPackage

     

       195696
       195696
       +
           ({ mkDerivation, aeson, base, bytestring, containers, dlist

     

       195697
       195697
       +
            , generic-arbitrary, hashable, quickcheck-instances, scientific

     

       195698
       195698
       +
            , tasty, tasty-hunit, tasty-quickcheck, temporary, text, time

     

       195699
       195699
       +
            , unordered-containers, uuid, uuid-types, vector

     

       195700
       195700
       +
            }:

     

       195701
       195701
       +
            mkDerivation {

     

       195702
       195702
       +
              pname = "safe-json";

     

       195703
       195703
       +
              version = "0.1.0";

     

       195704
       195704
       +
              sha256 = "17h5z20fcqp6gsmml1zqhckxgvc7jrx4mzdcqbsjlmpy52hb0lxq";

     

       195705
       195705
       +
              libraryHaskellDepends = [

     

       195706
       195706
       +
                aeson base bytestring containers dlist hashable scientific tasty

     

       195707
       195707
       +
                tasty-hunit tasty-quickcheck text time unordered-containers

     

       195708
       195708
       +
                uuid-types vector

     

       195709
       195709
       +
              ];

     

       195710
       195710
       +
              testHaskellDepends = [

     

       195711
       195711
       +
                aeson base bytestring containers dlist generic-arbitrary hashable

     

       195712
       195712
       +
                quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck

     

       195713
       195713
       +
                temporary text time unordered-containers uuid uuid-types vector

     

       195714
       195714
       +
              ];

     

       195715
       195715
       +
              description = "Automatic JSON format versioning";

     

       195716
       195716
       +
              license = stdenv.lib.licenses.mit;

     

       195717
       195717
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       195718
       195718
       +
              broken = true;

     

       195719
       195719
       +
            }) {};

     

       195720
       195720
       +
       

     

       194867
       195721
        
         "safe-lazy-io" = callPackage

     

       194868
       195722
        
           ({ mkDerivation, base, extensible-exceptions, parallel, strict-io

     

       194869
       195723
        
            }:

     
···

       195327
       196181
        
              broken = true;

     

       195328
       196182
        
            }) {};

     

       195329
       196183
        
       

     

       195330
       195330
       -
         "salak_0_2_9" = callPackage

     

       195331
       195331
       -
           ({ mkDerivation, attoparsec, base, containers, data-default

     

       195332
       195332
       -
            , directory, filepath, hspec, menshen, mtl, pqueue, QuickCheck

     

       195333
       195333
       -
            , scientific, text, time

     

       196184
       196184
       +
         "salak_0_2_9_3" = callPackage

     

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

     

       196186
       196186
       +
            , data-default, directory, filepath, hspec, menshen, mtl, pqueue

     

       196187
       196187
       +
            , QuickCheck, scientific, text, time, unliftio-core

     

       195334
       196188
        
            }:

     

       195335
       196189
        
            mkDerivation {

     

       195336
       196190
        
              pname = "salak";

     

       195337
       195337
       -
              version = "0.2.9";

     

       195338
       195338
       -
              sha256 = "1zq8sr5m10bkglwiscadprs4rdj5irpkgpd4ya72r4f61waba5fd";

     

       196191
       196191
       +
              version = "0.2.9.3";

     

       196192
       196192
       +
              sha256 = "0y1p2cf8bpglqf20a16d2h5xfknzz6wcdgwv6mamh24mdqv0c3rn";

     

       195339
       196193
        
              libraryHaskellDepends = [

     

       195340
       195340
       -
                attoparsec base containers data-default directory filepath menshen

     

       195341
       195341
       -
                mtl pqueue scientific text time

     

       196194
       196194
       +
                attoparsec base bytestring containers data-default directory

     

       196195
       196195
       +
                filepath menshen mtl pqueue scientific text time unliftio-core

     

       195342
       196196
        
              ];

     

       195343
       196197
        
              testHaskellDepends = [

     

       195344
       195344
       -
                attoparsec base containers data-default directory filepath hspec

     

       195345
       195345
       -
                menshen mtl pqueue QuickCheck scientific text time

     

       196198
       196198
       +
                attoparsec base bytestring containers data-default directory

     

       196199
       196199
       +
                filepath hspec menshen mtl pqueue QuickCheck scientific text time

     

       196200
       196200
       +
                unliftio-core

     

       195346
       196201
        
              ];

     

       195347
       196202
        
              description = "Configuration Loader";

     

       195348
       196203
        
              license = stdenv.lib.licenses.bsd3;

     
···

       195356
       196211
        
            }:

     

       195357
       196212
        
            mkDerivation {

     

       195358
       196213
        
              pname = "salak-toml";

     

       195359
       195359
       -
              version = "0.2.9";

     

       195360
       195360
       -
              sha256 = "1v5lc98dva6y2d6pqbwipnan2hyrhisx6c57r1rbw0lsalh7vpqx";

     

       196214
       196214
       +
              version = "0.2.9.3";

     

       196215
       196215
       +
              sha256 = "1hb5ddm7a9acwri730w50p14vyk6z8q1wnx2b87386d80am5mbpy";

     

       195361
       196216
        
              libraryHaskellDepends = [

     

       195362
       196217
        
                base mtl salak text time tomland unordered-containers

     

       195363
       196218
        
              ];

     
···

       195377
       196232
        
            }:

     

       195378
       196233
        
            mkDerivation {

     

       195379
       196234
        
              pname = "salak-yaml";

     

       195380
       195380
       -
              version = "0.2.9";

     

       195381
       195381
       -
              sha256 = "162gz0rs73ls1r3y9dfg3pz47nnc7mk5hmvxms814jspac27c1h5";

     

       195382
       195382
       -
              libraryHaskellDepends = [ base conduit libyaml mtl salak text ];

     

       196235
       196235
       +
              version = "0.2.9.3";

     

       196236
       196236
       +
              sha256 = "0jjmw923zvm349q318iw7y5lfqhbr85xgp6ai3xx5w5d4mcb2f32";

     

       196237
       196237
       +
              libraryHaskellDepends = [ base conduit libyaml salak text ];

     

       195383
       196238
        
              testHaskellDepends = [

     

       195384
       196239
        
                base conduit hspec libyaml mtl QuickCheck salak text

     

       195385
       196240
        
              ];

     
···

       199135
       199990
        
              pname = "serialize-instances";

     

       199136
       199991
        
              version = "0.1.0.0";

     

       199137
       199992
        
              sha256 = "1m88jd5w68vpk7z2x2fffd5ljrzr93y20246dkkzn1md9ky0fclw";

     

       199138
       199138
       -
              revision = "2";

     

       199139
       199139
       -
              editedCabalFile = "1jbp16c0zg0g85m4cmn0wd5zm6z13ks93wm3q7qhxcaa1qrm8mgr";

     

       199993
       199993
       +
              revision = "3";

     

       199994
       199994
       +
              editedCabalFile = "1apx6j68l0gyicf8bxh010r1xy6sp2nbw3zj79lfqbw7fm3swv52";

     

       199140
       199995
        
              libraryHaskellDepends = [

     

       199141
       199996
        
                base cereal hashable semigroups unordered-containers

     

       199142
       199997
        
              ];

     
···

       199279
       200134
        
              license = stdenv.lib.licenses.bsd3;

     

       199280
       200135
        
            }) {};

     

       199281
       200136
        
       

     

       199282
       199282
       -
         "servant_0_16" = callPackage

     

       200137
       200137
       +
         "servant_0_16_0_1" = callPackage

     

       199283
       200138
        
           ({ mkDerivation, aeson, attoparsec, base, base-compat, bifunctors

     

       199284
       200139
        
            , bytestring, Cabal, cabal-doctest, case-insensitive, deepseq

     

       199285
       200140
        
            , doctest, hspec, hspec-discover, http-api-data, http-media

     
···

       199289
       200144
        
            }:

     

       199290
       200145
        
            mkDerivation {

     

       199291
       200146
        
              pname = "servant";

     

       199292
       199292
       -
              version = "0.16";

     

       199293
       199293
       -
              sha256 = "0flpk4hd459lglxxyrbcvsk1401lcl5qrcr4ixz87jrs6vx97h37";

     

       200147
       200147
       +
              version = "0.16.0.1";

     

       200148
       200148
       +
              sha256 = "0ial3gvmsbaa26lgqlxk5sigpdqrr982cgkp2amlgniwg85sa2wp";

     

       199294
       200149
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       199295
       200150
        
              libraryHaskellDepends = [

     

       199296
       200151
        
                aeson attoparsec base base-compat bifunctors bytestring

     
···

       199299
       200154
        
                text transformers vault

     

       199300
       200155
        
              ];

     

       199301
       200156
        
              testHaskellDepends = [

     

       199302
       199302
       -
                aeson base base-compat bytestring doctest hspec mtl QuickCheck

     

       199303
       199303
       -
                quickcheck-instances string-conversions text transformers

     

       200157
       200157
       +
                aeson base base-compat bytestring doctest hspec http-media mtl

     

       200158
       200158
       +
                QuickCheck quickcheck-instances string-conversions text

     

       200159
       200159
       +
                transformers

     

       199304
       200160
        
              ];

     

       199305
       200161
        
              testToolDepends = [ hspec-discover ];

     

       199306
       200162
        
              description = "A family of combinators for defining webservices APIs";

     
···

       199408
       200264
        
              pname = "servant-auth-client";

     

       199409
       200265
        
              version = "0.4.0.0";

     

       199410
       200266
        
              sha256 = "1kh4kq3cc9fn49vmh304zyzn7idb4k1j0803yp7a6qc733panf9g";

     

       200267
       200267
       +
              revision = "1";

     

       200268
       200268
       +
              editedCabalFile = "0cynalya2y5bfnhkc49vwf0ldxg4km6nklk77nlxjcrvwas21g7z";

     

       199411
       200269
        
              libraryHaskellDepends = [

     

       199412
       200270
        
                base bytestring containers servant servant-auth servant-client-core

     

       199413
       200271
        
              ];

     
···

       199463
       200321
        
              pname = "servant-auth-docs";

     

       199464
       200322
        
              version = "0.2.10.0";

     

       199465
       200323
        
              sha256 = "0j1ynnrb6plrhpb2vzs2p7a9jb41llp0j1jwgap7hjhkwhyc7wxd";

     

       199466
       199466
       -
              revision = "2";

     

       199467
       199467
       -
              editedCabalFile = "0309a6pc8jj24xwqmzj1yslgij9g212hnaqh2qkcvlm6k6riffil";

     

       200324
       200324
       +
              revision = "3";

     

       200325
       200325
       +
              editedCabalFile = "0in6rhgwn5idc2rsl4zbh6kkhxq471iczjd3i6ap60xg46ciymga";

     

       199468
       200326
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       199469
       200327
        
              libraryHaskellDepends = [

     

       199470
       200328
        
                base lens servant servant-auth servant-docs text

     
···

       199527
       200385
        
              pname = "servant-auth-server";

     

       199528
       200386
        
              version = "0.4.4.0";

     

       199529
       200387
        
              sha256 = "13196aknmb125ri3szqx8z5hdkk8lglv4795ck5glpn953vgq51c";

     

       200388
       200388
       +
              revision = "1";

     

       200389
       200389
       +
              editedCabalFile = "1wxiakkcx7d0j6zasjd84y7k98j94sy5nkj0vngjpd2jzlv79bb0";

     

       199530
       200390
        
              libraryHaskellDepends = [

     

       199531
       200391
        
                aeson base base64-bytestring blaze-builder bytestring

     

       199532
       200392
        
                case-insensitive cookie data-default-class entropy http-types jose

     
···

       199551
       200411
        
              pname = "servant-auth-swagger";

     

       199552
       200412
        
              version = "0.2.10.0";

     

       199553
       200413
        
              sha256 = "04ndbbhdmpgb8yshki6q2j46a5q8fzvlb4nn8x8gv0mqkriq79sh";

     

       199554
       199554
       -
              revision = "1";

     

       199555
       199555
       -
              editedCabalFile = "105rniz4cmmwr0ynyv75s4ap1fgfwxy2k5mvvj66gwpvzmj55cnx";

     

       200414
       200414
       +
              revision = "2";

     

       200415
       200415
       +
              editedCabalFile = "1vr0qss87gi6r9z876v9vnmfhr4m58n5x44fgzpmjkn7wlh1i6m7";

     

       199556
       200416
        
              libraryHaskellDepends = [

     

       199557
       200417
        
                base lens servant servant-auth servant-swagger swagger2 text

     

       199558
       200418
        
              ];

     
···

       199751
       200611
        
              pname = "servant-blaze";

     

       199752
       200612
        
              version = "0.9";

     

       199753
       200613
        
              sha256 = "1pfnpc6m7i8knndc1734fbzpfgmvdcpkd8cj0jyw139b70siz63r";

     

       199754
       199754
       -
              revision = "1";

     

       199755
       199755
       -
              editedCabalFile = "06lq9lyli0pnmpw9489vzindjs0s9f982v6y9zk1lwc043nzg3ax";

     

       200614
       200614
       +
              revision = "2";

     

       200615
       200615
       +
              editedCabalFile = "0icqk00h03d6slfha8ylb07jj69y4chnhczxk8zskvgc89f6jl97";

     

       199756
       200616
        
              libraryHaskellDepends = [ base blaze-html http-media servant ];

     

       199757
       200617
        
              testHaskellDepends = [ base blaze-html servant-server wai warp ];

     

       199758
       200618
        
              description = "Blaze-html support for servant";

     
···

       199924
       200784
        
              pname = "servant-client";

     

       199925
       200785
        
              version = "0.16";

     

       199926
       200786
        
              sha256 = "0641fqlvqkm5075pcgcg5q81j7jil79sjpifg1snagfisrsxifxj";

     

       200787
       200787
       +
              revision = "1";

     

       200788
       200788
       +
              editedCabalFile = "0grjsgdmyr9mp7mnmf5qw6wkciigpzxsyzsj6l8fbb7mq5rsid78";

     

       199927
       200789
        
              libraryHaskellDepends = [

     

       199928
       200790
        
                base base-compat bytestring containers deepseq exceptions

     

       199929
       200791
        
                http-client http-media http-types kan-extensions monad-control mtl

     
···

       199973
       200835
        
              pname = "servant-client-core";

     

       199974
       200836
        
              version = "0.16";

     

       199975
       200837
        
              sha256 = "0cvv9a7z6ahwjp433c4sxa9i1ifabbih63bx71r9gvqzl85pb3dz";

     

       200838
       200838
       +
              revision = "1";

     

       200839
       200839
       +
              editedCabalFile = "1hanl8sz14z11441ng8vkzpxrl6igk3xzp6fcm6wg59fsb30fh29";

     

       199976
       200840
        
              libraryHaskellDepends = [

     

       199977
       200841
        
                aeson base base-compat base64-bytestring bytestring containers

     

       199978
       200842
        
                deepseq exceptions free http-media http-types network-uri safe

     
···

       200100
       200964
        
              pname = "servant-dhall";

     

       200101
       200965
        
              version = "0.1.0.2";

     

       200102
       200966
        
              sha256 = "09fvyhkqpypg73cxs7y2asvlch83i4sqzh2w0d5ix0zl5i7f6rz3";

     

       200967
       200967
       +
              revision = "1";

     

       200968
       200968
       +
              editedCabalFile = "19jdp0xj1nl21wzfnk2y3qrzi7cag1m3wk0zqvqayc2czq9h0k08";

     

       200103
       200969
        
              libraryHaskellDepends = [

     

       200104
       200970
        
                base base-compat bytestring dhall http-media megaparsec

     

       200105
       200971
        
                prettyprinter servant text

     
···

       200125
       200991
        
              pname = "servant-docs";

     

       200126
       200992
        
              version = "0.11.3";

     

       200127
       200993
        
              sha256 = "0cys1h3m0aq77aw0szj7k6p7zqcr8074zrxzsjp58lss1daqisq7";

     

       200128
       200128
       -
              revision = "1";

     

       200129
       200129
       -
              editedCabalFile = "1f5vdd096yrb0fsnzy709xw3x1r5q1pymscqaaarz3h2sky385lv";

     

       200994
       200994
       +
              revision = "2";

     

       200995
       200995
       +
              editedCabalFile = "1zzv3mbfyvpqddhz8a7z8wfwy4w4y21rwpi7k15xzm9647sdgga5";

     

       200130
       200996
        
              isLibrary = true;

     

       200131
       200997
        
              isExecutable = true;

     

       200132
       200998
        
              libraryHaskellDepends = [

     
···

       200452
       201318
        
              pname = "servant-http-streams";

     

       200453
       201319
        
              version = "0.16";

     

       200454
       201320
        
              sha256 = "1gkgk13zxi8y071i9dx0i1kbs14rgp8cfnfcd7rpg86pffxkx6cp";

     

       201321
       201321
       +
              revision = "1";

     

       201322
       201322
       +
              editedCabalFile = "0i3668fw4h503hig1vd9d7k0mxlsis81cs7a5fh2k5yja5sj81ik";

     

       200455
       201323
        
              libraryHaskellDepends = [

     

       200456
       201324
        
                base base-compat bytestring case-insensitive containers deepseq

     

       200457
       201325
        
                exceptions http-common http-media http-streams http-types

     
···

       200611
       201479
        
              pname = "servant-lucid";

     

       200612
       201480
        
              version = "0.9";

     

       200613
       201481
        
              sha256 = "1xamwcijd03cynml5c2hr577qairybyrqd90ixyb1a94lql6agbf";

     

       200614
       200614
       -
              revision = "1";

     

       200615
       200615
       -
              editedCabalFile = "0fgik3s4vqyx5f8r777x82baj42qqgnxwi8gfp8iz3wfifvpc43k";

     

       201482
       201482
       +
              revision = "2";

     

       201483
       201483
       +
              editedCabalFile = "17p1xxzmr3ya0k4cy9n5mqf356gm35jdcm8mw1cxg2v80sd6nr4j";

     

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

     

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

     

       200618
       201486
        
              description = "Servant support for lucid";

     
···

       200718
       201586
        
              pname = "servant-multipart";

     

       200719
       201587
        
              version = "0.11.4";

     

       200720
       201588
        
              sha256 = "0vcwrdzj1xyjg11yvfcds9rql3gcwgdcdq4z085g44fpabjxj50s";

     

       201589
       201589
       +
              revision = "1";

     

       201590
       201590
       +
              editedCabalFile = "0sf5vmzdcfzy01d65dd2f5l4k67znmjvp86d4xgkrmqsqmgxcgpg";

     

       200721
       201591
        
              libraryHaskellDepends = [

     

       200722
       201592
        
                base bytestring directory http-media lens resourcet servant

     

       200723
       201593
        
                servant-docs servant-foreign servant-server text transformers wai

     
···

       200995
       201865
        
            }:

     

       200996
       201866
        
            mkDerivation {

     

       200997
       201867
        
              pname = "servant-quickcheck";

     

       200998
       200998
       -
              version = "0.0.7.3";

     

       200999
       200999
       -
              sha256 = "0d904xfw5q7qcwkp5n7v18drc1idssvfwic2ksfmqlxisnxmyp5r";

     

       201868
       201868
       +
              version = "0.0.7.4";

     

       201869
       201869
       +
              sha256 = "1z47fgzdwfqb0byr8wa0s9n3g8hcbf112nbgaifm0zmxx6w4jlcf";

     

       201000
       201870
        
              libraryHaskellDepends = [

     

       201001
       201871
        
                aeson base base-compat-batteries bytestring case-insensitive clock

     

       201002
       201872
        
                data-default-class hspec http-client http-media http-types mtl

     
···

       201215
       202085
        
              pname = "servant-server";

     

       201216
       202086
        
              version = "0.16";

     

       201217
       202087
        
              sha256 = "18rv99hyb448mcv1cjvs0p6cqrkw9f3zpdh18nsd29fskcybsv3b";

     

       202088
       202088
       +
              revision = "1";

     

       202089
       202089
       +
              editedCabalFile = "1v0zr3mqzjhiqrgyqgbnixa9zjvgknis3rjwyi2a3ig5l36y6ifh";

     

       201218
       202090
        
              isLibrary = true;

     

       201219
       202091
        
              isExecutable = true;

     

       201220
       202092
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       201497
       202369
        
              pname = "servant-swagger";

     

       201498
       202370
        
              version = "1.1.7";

     

       201499
       202371
        
              sha256 = "0dnyh4g55x70cb6xwksm0rk23v5lawdws5bxgq27ja1walh106p3";

     

       201500
       201500
       -
              revision = "1";

     

       201501
       201501
       -
              editedCabalFile = "0maasfw086a2iy4dyfaap4f1ncq1cg3p2mw6ypqhfr3dipgj5d3v";

     

       202372
       202372
       +
              revision = "2";

     

       202373
       202373
       +
              editedCabalFile = "1crl8c71ns8mnp056ba1zph57cf1l4dajbgw07gpcw2cvni6x560";

     

       201502
       202374
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       201503
       202375
        
              libraryHaskellDepends = [

     

       201504
       202376
        
                aeson aeson-pretty base base-compat bytestring hspec http-media

     
···

       201541
       202413
        
              pname = "servant-swagger-ui-core";

     

       201542
       202414
        
              version = "0.3.2";

     

       201543
       202415
        
              sha256 = "1a1wk90vm6mq8byxz4syr03l1rf6qj8zhda7lnp23pn5d270xkd2";

     

       201544
       201544
       -
              revision = "3";

     

       201545
       201545
       -
              editedCabalFile = "1di8fz3kcyp395yvjx3i48p68kx3qg83vbjc81c5jdp1i8w0kmww";

     

       202416
       202416
       +
              revision = "4";

     

       202417
       202417
       +
              editedCabalFile = "0vvfqf9zh8a5sgd4sn4mkay803lqc5zd9dz175gxs3wmca0gr3fk";

     

       201546
       202418
        
              libraryHaskellDepends = [

     

       201547
       202419
        
                base blaze-markup bytestring http-media servant servant-blaze

     

       201548
       202420
        
                servant-server swagger2 text transformers transformers-compat

     
···

       201687
       202559
        
              pname = "servant-yaml";

     

       201688
       202560
        
              version = "0.1.0.1";

     

       201689
       202561
        
              sha256 = "00gnbdlcq6cvmhsga8h0csd35pnfib038rqlhm445l4wa0cp8m01";

     

       201690
       201690
       -
              revision = "1";

     

       201691
       201691
       -
              editedCabalFile = "05j3hqvqiq8wa45jsdx72xa5phbhvn2lxbkbhh1g0j13ky8x2waw";

     

       202562
       202562
       +
              revision = "2";

     

       202563
       202563
       +
              editedCabalFile = "0scpm5dshnb7izn1xx8q3xm1m5f52y1s7nzgp7sa7zcv3pp6n7lw";

     

       201692
       202564
        
              libraryHaskellDepends = [

     

       201693
       202565
        
                base bytestring http-media servant yaml

     

       201694
       202566
        
              ];

     
···

       201814
       202686
        
              pname = "serverless-haskell";

     

       201815
       202687
        
              version = "0.8.6";

     

       201816
       202688
        
              sha256 = "1ji1rkgrygsmrvgpirvc1pr2rw2xq15ff1v86ckwn7gcb9q8z7jy";

     

       202689
       202689
       +
              libraryHaskellDepends = [

     

       202690
       202690
       +
                aeson aeson-casing aeson-extra amazonka-core amazonka-kinesis

     

       202691
       202691
       +
                amazonka-s3 base bytestring case-insensitive http-types iproute

     

       202692
       202692
       +
                lens network network-simple text time unix unordered-containers

     

       202693
       202693
       +
              ];

     

       202694
       202694
       +
              testHaskellDepends = [

     

       202695
       202695
       +
                aeson aeson-casing aeson-extra amazonka-core amazonka-kinesis

     

       202696
       202696
       +
                amazonka-s3 base bytestring case-insensitive hspec hspec-discover

     

       202697
       202697
       +
                http-types iproute lens network network-simple raw-strings-qq text

     

       202698
       202698
       +
                time unix unordered-containers

     

       202699
       202699
       +
              ];

     

       202700
       202700
       +
              testToolDepends = [ hspec-discover ];

     

       202701
       202701
       +
              description = "Deploying Haskell code onto AWS Lambda using Serverless";

     

       202702
       202702
       +
              license = stdenv.lib.licenses.mit;

     

       202703
       202703
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       202704
       202704
       +
              broken = true;

     

       202705
       202705
       +
            }) {};

     

       202706
       202706
       +
       

     

       202707
       202707
       +
         "serverless-haskell_0_8_7" = callPackage

     

       202708
       202708
       +
           ({ mkDerivation, aeson, aeson-casing, aeson-extra, amazonka-core

     

       202709
       202709
       +
            , amazonka-kinesis, amazonka-s3, base, bytestring, case-insensitive

     

       202710
       202710
       +
            , hspec, hspec-discover, http-types, iproute, lens, network

     

       202711
       202711
       +
            , network-simple, raw-strings-qq, text, time, unix

     

       202712
       202712
       +
            , unordered-containers

     

       202713
       202713
       +
            }:

     

       202714
       202714
       +
            mkDerivation {

     

       202715
       202715
       +
              pname = "serverless-haskell";

     

       202716
       202716
       +
              version = "0.8.7";

     

       202717
       202717
       +
              sha256 = "0q73j6n6552ajv5sm52rbcj4kk86wjmvrh6khci1nbln4wxgbwq2";

     

       201817
       202718
        
              libraryHaskellDepends = [

     

       201818
       202719
        
                aeson aeson-casing aeson-extra amazonka-core amazonka-kinesis

     

       201819
       202720
        
                amazonka-s3 base bytestring case-insensitive http-types iproute

     
···

       203667
       204568
        
       

     

       203668
       204569
        
         "shh" = callPackage

     

       203669
       204570
        
           ({ mkDerivation, async, base, containers, deepseq, directory

     

       203670
       203670
       -
            , filepath, hashable, mtl, process, split, tasty, tasty-hunit

     

       204571
       204571
       +
            , doctest, filepath, mtl, process, split, tasty, tasty-hunit

     

       203671
       204572
        
            , tasty-quickcheck, template-haskell, temporary, unix

     

       203672
       204573
        
            }:

     

       203673
       204574
        
            mkDerivation {

     

       203674
       204575
        
              pname = "shh";

     

       203675
       203675
       -
              version = "0.3.1.3";

     

       203676
       203676
       -
              sha256 = "0dsb4q83zsxx78xa4cx5vgkkyrbj50567vlvxk8g10pwah0lkr4c";

     

       204576
       204576
       +
              version = "0.4.0.0";

     

       204577
       204577
       +
              sha256 = "0ghkiz720g4p8gs5h3h43pkdsgcl7iffnqdis122qhvfliwqcmpr";

     

       203677
       204578
        
              isLibrary = true;

     

       203678
       204579
        
              isExecutable = true;

     

       203679
       204580
        
              libraryHaskellDepends = [

     
···

       203681
       204582
        
                template-haskell unix

     

       203682
       204583
        
              ];

     

       203683
       204584
        
              executableHaskellDepends = [

     

       203684
       203684
       -
                async base directory hashable split temporary

     

       204585
       204585
       +
                async base deepseq directory temporary unix

     

       203685
       204586
        
              ];

     

       203686
       203686
       -
              testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];

     

       204587
       204587
       +
              testHaskellDepends = [

     

       204588
       204588
       +
                async base directory doctest tasty tasty-hunit tasty-quickcheck

     

       204589
       204589
       +
              ];

     

       203687
       204590
        
              description = "Simple shell scripting from Haskell";

     

       203688
       204591
        
              license = stdenv.lib.licenses.bsd3;

     

       204592
       204592
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       204593
       204593
       +
              broken = true;

     

       203689
       204594
        
            }) {};

     

       203690
       204595
        
       

     

       203691
       204596
        
         "shh-extras" = callPackage

     
···

       203698
       204603
        
              testHaskellDepends = [ base tasty ];

     

       203699
       204604
        
              description = "Utility functions for using shh";

     

       203700
       204605
        
              license = stdenv.lib.licenses.bsd3;

     

       204606
       204606
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       204607
       204607
       +
              broken = true;

     

       203701
       204608
        
            }) {};

     

       203702
       204609
        
       

     

       203703
       204610
        
         "shift" = callPackage

     
···

       204803
       205710
        
              broken = true;

     

       204804
       205711
        
            }) {};

     

       204805
       205712
        
       

     

       205713
       205713
       +
         "simple-ltl" = callPackage

     

       205714
       205714
       +
           ({ mkDerivation, base, criterion, deepseq, tasty, tasty-hunit }:

     

       205715
       205715
       +
            mkDerivation {

     

       205716
       205716
       +
              pname = "simple-ltl";

     

       205717
       205717
       +
              version = "2.1.0";

     

       205718
       205718
       +
              sha256 = "1hq9s9s9rslsq0ccdi92mjcxvvv3ficdfbfbbplgclzmlwbmwqzw";

     

       205719
       205719
       +
              libraryHaskellDepends = [ base deepseq ];

     

       205720
       205720
       +
              testHaskellDepends = [ base tasty tasty-hunit ];

     

       205721
       205721
       +
              benchmarkHaskellDepends = [ base criterion ];

     

       205722
       205722
       +
              description = "A simple LTL checker";

     

       205723
       205723
       +
              license = stdenv.lib.licenses.bsd3;

     

       205724
       205724
       +
            }) {};

     

       205725
       205725
       +
       

     

       204806
       205726
        
         "simple-money" = callPackage

     

       204807
       205727
        
           ({ mkDerivation, base, containers }:

     

       204808
       205728
        
            mkDerivation {

     
···

       205164
       206084
        
              broken = true;

     

       205165
       206085
        
            }) {};

     

       205166
       206086
        
       

     

       206087
       206087
       +
         "simple-units" = callPackage

     

       206088
       206088
       +
           ({ mkDerivation, base, first-class-families }:

     

       206089
       206089
       +
            mkDerivation {

     

       206090
       206090
       +
              pname = "simple-units";

     

       206091
       206091
       +
              version = "1.0.1.1";

     

       206092
       206092
       +
              sha256 = "1dzsr15lq32dqsbhb639vzlx2d6m2kx0qax75ik2z765r5h9f9sa";

     

       206093
       206093
       +
              libraryHaskellDepends = [ base first-class-families ];

     

       206094
       206094
       +
              description = "Simple arithmetic with SI units using type-checked dimensional analysis";

     

       206095
       206095
       +
              license = stdenv.lib.licenses.mit;

     

       206096
       206096
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       206097
       206097
       +
              broken = true;

     

       206098
       206098
       +
            }) {};

     

       206099
       206099
       +
       

     

       205167
       206100
        
         "simple-vec3" = callPackage

     

       205168
       206101
        
           ({ mkDerivation, base, criterion, doctest, doctest-driver-gen

     

       205169
       206102
        
            , QuickCheck, tasty, tasty-quickcheck, vector

     
···

       205340
       206273
        
            }:

     

       205341
       206274
        
            mkDerivation {

     

       205342
       206275
        
              pname = "simplest-sqlite";

     

       205343
       205343
       -
              version = "0.1.0.0";

     

       205344
       205344
       -
              sha256 = "0vjx01bls2z99hmynqhxm4j2cq17334wz3pz0gm5saxslkldw2sz";

     

       206276
       206276
       +
              version = "0.1.0.1";

     

       206277
       206277
       +
              sha256 = "06ccads286air3m6xys60aap5dckjimp6rvchk3v6927z9vgrn0v";

     

       205345
       206278
        
              libraryHaskellDepends = [

     

       205346
       206279
        
                base bytestring exception-hierarchy template-haskell text

     

       205347
       206280
        
              ];

     
···

       208101
       209034
        
            }:

     

       208102
       209035
        
            mkDerivation {

     

       208103
       209036
        
              pname = "snaplet-postgresql-simple";

     

       208104
       208104
       -
              version = "1.1.0.0";

     

       208105
       208105
       -
              sha256 = "0k82g3540jx7bddg0x6764c8xr955y8v5rc69kagi01nvhh7n2z5";

     

       209037
       209037
       +
              version = "1.2.0.0";

     

       209038
       209038
       +
              sha256 = "0an9b72vfnb562k49bz5wh72s637r3vrbm4x9brwf483rrmlmvrf";

     

       208106
       209039
        
              isLibrary = true;

     

       208107
       209040
        
              isExecutable = true;

     

       208108
       209041
        
              enableSeparateDataOutput = true;

     
···

       209072
       210005
        
              license = stdenv.lib.licenses.bsd3;

     

       209073
       210006
        
            }) {};

     

       209074
       210007
        
       

     

       210008
       210008
       +
         "socks_0_6_0" = callPackage

     

       210009
       210009
       +
           ({ mkDerivation, base, basement, bytestring, cereal, network }:

     

       210010
       210010
       +
            mkDerivation {

     

       210011
       210011
       +
              pname = "socks";

     

       210012
       210012
       +
              version = "0.6.0";

     

       210013
       210013
       +
              sha256 = "10bkf2gw5l48j6g1i2slndcg4nzdqj8syrnbj21gjz6sms3zlqlp";

     

       210014
       210014
       +
              libraryHaskellDepends = [

     

       210015
       210015
       +
                base basement bytestring cereal network

     

       210016
       210016
       +
              ];

     

       210017
       210017
       +
              description = "Socks proxy (ver 5)";

     

       210018
       210018
       +
              license = stdenv.lib.licenses.bsd3;

     

       210019
       210019
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       210020
       210020
       +
            }) {};

     

       210021
       210021
       +
       

     

       209075
       210022
        
         "sodium" = callPackage

     

       209076
       210023
        
           ({ mkDerivation, base, containers, mtl }:

     

       209077
       210024
        
            mkDerivation {

     
···

       211516
       212463
        
            }:

     

       211517
       212464
        
            mkDerivation {

     

       211518
       212465
        
              pname = "stack";

     

       211519
       211519
       -
              version = "1.9.3";

     

       211520
       211520
       -
              sha256 = "01lbr9gp3djr5bzlchzb2rdw20855aganmczvq76fzzjyway64cf";

     

       211521
       211521
       -
              revision = "7";

     

       211522
       211522
       -
              editedCabalFile = "0gc09yfhrphzn6r2g1ifx6l5k3g78q38myg83f2djjmy9vp047bl";

     

       212466
       212466
       +
              version = "1.9.3.1";

     

       212467
       212467
       +
              sha256 = "0lxx2gwwh4kjhy9d67ykdnhm5z9zsflv515jgsf97nkf6b8db8lj";

     

       212468
       212468
       +
              revision = "2";

     

       212469
       212469
       +
              editedCabalFile = "1fypvcvjlhyxnr81gll1w0l4nw6zvsr1vhb1y5g1jnyzy8f278zj";

     

       211523
       212470
        
              configureFlags = [

     

       211524
       212471
        
                "-fdisable-git-info" "-fhide-dependency-versions"

     

       211525
       212472
        
                "-fsupported-build"

     
···

       212944
       213891
        
            }:

     

       212945
       213892
        
            mkDerivation {

     

       212946
       213893
        
              pname = "staversion";

     

       212947
       212947
       -
              version = "0.2.3.0";

     

       212948
       212948
       -
              sha256 = "012j2gcmcyjqsmfcpll2y61j7n191y8wipdki49p7i0d2n4ak88v";

     

       213894
       213894
       +
              version = "0.2.3.1";

     

       213895
       213895
       +
              sha256 = "0y3x0bylpiad1l87gzdwbgbaizqas6r9l83cngg3anqsg1gpd7a6";

     

       212949
       213896
        
              isLibrary = true;

     

       212950
       213897
        
              isExecutable = true;

     

       212951
       213898
        
              libraryHaskellDepends = [

     
···

       213344
       214291
        
            }:

     

       213345
       214292
        
            mkDerivation {

     

       213346
       214293
        
              pname = "stm-containers";

     

       213347
       213347
       -
              version = "1.1.0.2";

     

       213348
       213348
       -
              sha256 = "1yhivblfxycr2vk09gwg904n6fqkzn5g5rvg3whm40fnabdfa9av";

     

       213349
       213349
       -
              revision = "1";

     

       213350
       213350
       -
              editedCabalFile = "14dy3rxa009bgx534583g11i8986pjcgygzh8l15fk3rv9q1iwb8";

     

       214294
       214294
       +
              version = "1.1.0.4";

     

       214295
       214295
       +
              sha256 = "0mcn4v9gjkqp27xcwvqphiqnaj4grvxpsflhq0rwqp5ymnzlccyl";

     

       213351
       214296
        
              libraryHaskellDepends = [

     

       213352
       214297
        
                base deferred-folds focus hashable list-t stm-hamt transformers

     

       213353
       214298
        
              ];

     

       213354
       214299
        
              testHaskellDepends = [

     

       213355
       213355
       -
                deferred-folds focus foldl free HTF QuickCheck quickcheck-text

     

       213356
       213356
       -
                rerebase

     

       214300
       214300
       +
                deferred-folds focus foldl free HTF list-t QuickCheck

     

       214301
       214301
       +
                quickcheck-text rerebase

     

       213357
       214302
        
              ];

     

       213358
       214303
        
              description = "Containers for STM";

     

       213359
       214304
        
              license = stdenv.lib.licenses.mit;

     
···

       213869
       214814
        
              license = stdenv.lib.licenses.mit;

     

       213870
       214815
        
            }) {};

     

       213871
       214816
        
       

     

       214817
       214817
       +
         "store_0_5_1_0" = callPackage

     

       214818
       214818
       +
           ({ mkDerivation, array, async, base, base-orphans

     

       214819
       214819
       +
            , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector

     

       214820
       214820
       +
            , clock, containers, contravariant, criterion, cryptohash, deepseq

     

       214821
       214821
       +
            , directory, filepath, free, ghc-prim, hashable, hspec

     

       214822
       214822
       +
            , hspec-smallcheck, integer-gmp, lifted-base, monad-control

     

       214823
       214823
       +
            , mono-traversable, network, primitive, resourcet, safe, semigroups

     

       214824
       214824
       +
            , smallcheck, store-core, syb, template-haskell, text, th-lift

     

       214825
       214825
       +
            , th-lift-instances, th-orphans, th-reify-many, th-utilities, time

     

       214826
       214826
       +
            , transformers, unordered-containers, vector

     

       214827
       214827
       +
            , vector-binary-instances, void, weigh

     

       214828
       214828
       +
            }:

     

       214829
       214829
       +
            mkDerivation {

     

       214830
       214830
       +
              pname = "store";

     

       214831
       214831
       +
              version = "0.5.1.0";

     

       214832
       214832
       +
              sha256 = "0r15b04vxfca45a0rv1n4lcd6zpxhlhc9gmg9if17r1bm63x59hr";

     

       214833
       214833
       +
              revision = "1";

     

       214834
       214834
       +
              editedCabalFile = "0nfy8lrvj9kzhmbx8nkg8vlvlha8hkr4k23vs9xasvrw2wp5rfhj";

     

       214835
       214835
       +
              libraryHaskellDepends = [

     

       214836
       214836
       +
                array async base base-orphans base64-bytestring bifunctors

     

       214837
       214837
       +
                bytestring containers contravariant cryptohash deepseq directory

     

       214838
       214838
       +
                filepath free ghc-prim hashable hspec hspec-smallcheck integer-gmp

     

       214839
       214839
       +
                lifted-base monad-control mono-traversable network primitive

     

       214840
       214840
       +
                resourcet safe semigroups smallcheck store-core syb

     

       214841
       214841
       +
                template-haskell text th-lift th-lift-instances th-orphans

     

       214842
       214842
       +
                th-reify-many th-utilities time transformers unordered-containers

     

       214843
       214843
       +
                vector void

     

       214844
       214844
       +
              ];

     

       214845
       214845
       +
              testHaskellDepends = [

     

       214846
       214846
       +
                array async base base-orphans base64-bytestring bifunctors

     

       214847
       214847
       +
                bytestring clock containers contravariant cryptohash deepseq

     

       214848
       214848
       +
                directory filepath free ghc-prim hashable hspec hspec-smallcheck

     

       214849
       214849
       +
                integer-gmp lifted-base monad-control mono-traversable network

     

       214850
       214850
       +
                primitive resourcet safe semigroups smallcheck store-core syb

     

       214851
       214851
       +
                template-haskell text th-lift th-lift-instances th-orphans

     

       214852
       214852
       +
                th-reify-many th-utilities time transformers unordered-containers

     

       214853
       214853
       +
                vector void

     

       214854
       214854
       +
              ];

     

       214855
       214855
       +
              benchmarkHaskellDepends = [

     

       214856
       214856
       +
                array async base base-orphans base64-bytestring bifunctors

     

       214857
       214857
       +
                bytestring cereal cereal-vector containers contravariant criterion

     

       214858
       214858
       +
                cryptohash deepseq directory filepath free ghc-prim hashable hspec

     

       214859
       214859
       +
                hspec-smallcheck integer-gmp lifted-base monad-control

     

       214860
       214860
       +
                mono-traversable network primitive resourcet safe semigroups

     

       214861
       214861
       +
                smallcheck store-core syb template-haskell text th-lift

     

       214862
       214862
       +
                th-lift-instances th-orphans th-reify-many th-utilities time

     

       214863
       214863
       +
                transformers unordered-containers vector vector-binary-instances

     

       214864
       214864
       +
                void weigh

     

       214865
       214865
       +
              ];

     

       214866
       214866
       +
              description = "Fast binary serialization";

     

       214867
       214867
       +
              license = stdenv.lib.licenses.mit;

     

       214868
       214868
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       214869
       214869
       +
            }) {};

     

       214870
       214870
       +
       

     

       213872
       214871
        
         "store-core" = callPackage

     

       213873
       214872
        
           ({ mkDerivation, base, bytestring, ghc-prim, primitive, text

     

       213874
       214873
        
            , transformers

     
···

       214301
       215300
        
              ];

     

       214302
       215301
        
              description = "A resource management decorator for \"streaming\"";

     

       214303
       215302
        
              license = stdenv.lib.licenses.mit;

     

       215303
       215303
       +
            }) {};

     

       215304
       215304
       +
       

     

       215305
       215305
       +
         "streaming-brotli" = callPackage

     

       215306
       215306
       +
           ({ mkDerivation, base, brotli, bytestring, HUnit, QuickCheck

     

       215307
       215307
       +
            , streaming, streaming-bytestring, test-framework

     

       215308
       215308
       +
            , test-framework-hunit, test-framework-quickcheck2

     

       215309
       215309
       +
            }:

     

       215310
       215310
       +
            mkDerivation {

     

       215311
       215311
       +
              pname = "streaming-brotli";

     

       215312
       215312
       +
              version = "0.0.0.0";

     

       215313
       215313
       +
              sha256 = "12bp033sjcjf3l16ihg2xa69yl7ai0886jriqpipsddfkcjnx7mr";

     

       215314
       215314
       +
              libraryHaskellDepends = [

     

       215315
       215315
       +
                base brotli bytestring streaming streaming-bytestring

     

       215316
       215316
       +
              ];

     

       215317
       215317
       +
              testHaskellDepends = [

     

       215318
       215318
       +
                base bytestring HUnit QuickCheck streaming streaming-bytestring

     

       215319
       215319
       +
                test-framework test-framework-hunit test-framework-quickcheck2

     

       215320
       215320
       +
              ];

     

       215321
       215321
       +
              description = "Streaming interface for Brotli (RFC7932) compression";

     

       215322
       215322
       +
              license = stdenv.lib.licenses.bsd3;

     

       214304
       215323
        
            }) {};

     

       214305
       215324
        
       

     

       214306
       215325
        
         "streaming-bytestring" = callPackage

     
···

       214466
       215485
        
              license = stdenv.lib.licenses.asl20;

     

       214467
       215486
        
            }) {};

     

       214468
       215487
        
       

     

       215488
       215488
       +
         "streaming-lzma" = callPackage

     

       215489
       215489
       +
           ({ mkDerivation, base, bytestring, HUnit, lzma, QuickCheck

     

       215490
       215490
       +
            , streaming, streaming-bytestring, test-framework

     

       215491
       215491
       +
            , test-framework-hunit, test-framework-quickcheck2

     

       215492
       215492
       +
            }:

     

       215493
       215493
       +
            mkDerivation {

     

       215494
       215494
       +
              pname = "streaming-lzma";

     

       215495
       215495
       +
              version = "0.0.0.0";

     

       215496
       215496
       +
              sha256 = "0nqy6400fzr7mrl70wshcdfzz531wxy5x1mqg8zixg128xc0cnfb";

     

       215497
       215497
       +
              libraryHaskellDepends = [

     

       215498
       215498
       +
                base bytestring lzma streaming streaming-bytestring

     

       215499
       215499
       +
              ];

     

       215500
       215500
       +
              testHaskellDepends = [

     

       215501
       215501
       +
                base bytestring HUnit QuickCheck streaming streaming-bytestring

     

       215502
       215502
       +
                test-framework test-framework-hunit test-framework-quickcheck2

     

       215503
       215503
       +
              ];

     

       215504
       215504
       +
              description = "Streaming interface for LZMA/XZ compression";

     

       215505
       215505
       +
              license = stdenv.lib.licenses.bsd3;

     

       215506
       215506
       +
            }) {};

     

       215507
       215507
       +
       

     

       214469
       215508
        
         "streaming-osm" = callPackage

     

       214470
       215509
        
           ({ mkDerivation, attoparsec, base, bytestring, containers

     

       214471
       215510
        
            , criterion, streaming, streaming-bytestring, streaming-utils

     
···

       214747
       215786
        
            , base64-bytestring, bifunctors, bytestring

     

       214748
       215787
        
            , bytestring-tree-builder, hashable, http-media, mtl, scientific

     

       214749
       215788
        
            , semigroups, strelka-core, text, text-builder, time, transformers

     

       214750
       214750
       -
            , unordered-containers, url-decoders

     

       215789
       215789
       +
            , unordered-containers, url-decoders, uuid

     

       214751
       215790
        
            }:

     

       214752
       215791
        
            mkDerivation {

     

       214753
       215792
        
              pname = "strelka";

     

       214754
       214754
       -
              version = "2.0.2.2";

     

       214755
       214755
       -
              sha256 = "14n4wk7xzqrl795flxvks7kzf9mm93b626r2x657xjsy7rwkw7y3";

     

       215793
       215793
       +
              version = "2.0.5";

     

       215794
       215794
       +
              sha256 = "04z2ibka7gzgkcwqjg6xi0cj42hmix1pm4r8kmfqbb68a39hqbp6";

     

       214756
       215795
        
              libraryHaskellDepends = [

     

       214757
       215796
        
                attoparsec attoparsec-data base base-prelude base64-bytestring

     

       214758
       215797
        
                bifunctors bytestring bytestring-tree-builder hashable http-media

     

       214759
       215798
        
                mtl scientific semigroups strelka-core text text-builder time

     

       214760
       214760
       -
                transformers unordered-containers url-decoders

     

       215799
       215799
       +
                transformers unordered-containers url-decoders uuid

     

       214761
       215800
        
              ];

     

       214762
       215801
        
              description = "A simple, flexible and composable web-router";

     

       214763
       215802
        
              license = stdenv.lib.licenses.mit;

     
···

       217123
       218162
        
              pname = "swagger2";

     

       217124
       218163
        
              version = "2.3.1.1";

     

       217125
       218164
        
              sha256 = "19fslhjqcnk0da1c8sdflnnxjzbbzqb0nbknpgyd45q0psxr6xs7";

     

       218165
       218165
       +
              revision = "1";

     

       218166
       218166
       +
              editedCabalFile = "1g6jiadrvglrbf0857nzfbnjxmb3lwqamgs47j3qv9k6kfwilzyk";

     

       217126
       218167
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       217127
       218168
        
              libraryHaskellDepends = [

     

       217128
       218169
        
                aeson base base-compat-batteries bytestring containers cookie

     
···

       218746
       219787
        
            }:

     

       218747
       219788
        
            mkDerivation {

     

       218748
       219789
        
              pname = "table-layout";

     

       218749
       218749
       -
              version = "0.8.0.3";

     

       218750
       218750
       -
              sha256 = "03q3icqgxiwbyl9bhqzhdwsdirr9r40k20k1j8z1barg2309r2aa";

     

       219790
       219790
       +
              version = "0.8.0.4";

     

       219791
       219791
       +
              sha256 = "160ns7fd3xivlfirir7lk0ghv1f63b6cyfvnk8p2cn3jjfdp9xb3";

     

       218751
       219792
        
              isLibrary = true;

     

       218752
       219793
        
              isExecutable = true;

     

       218753
       219794
        
              libraryHaskellDepends = [

     
···

       220126
       221167
        
              pname = "tasty-hspec";

     

       220127
       221168
        
              version = "1.1.5.1";

     

       220128
       221169
        
              sha256 = "0i9kdzjpk750sa078jj3iyhp72k0177zk7vxl131r6dkyz09x27y";

     

       220129
       220129
       -
              revision = "2";

     

       220130
       220130
       -
              editedCabalFile = "1xrb7gyidbgbd1c94c1wa5dazsllp23xi4w7flsws09r267q8qpc";

     

       221170
       221170
       +
              revision = "3";

     

       221171
       221171
       +
              editedCabalFile = "1wgz3z5bnq5qml8d0i18gvz30dmmax3686lmqz3vf4hxd3vqfkpj";

     

       220131
       221172
        
              libraryHaskellDepends = [

     

       220132
       221173
        
                base hspec hspec-core QuickCheck tasty tasty-quickcheck

     

       220133
       221174
        
                tasty-smallcheck

     
···

       220840
       221881
        
              broken = true;

     

       220841
       221882
        
            }) {};

     

       220842
       221883
        
       

     

       220843
       220843
       -
         "telega" = callPackage

     

       220844
       220844
       -
           ({ mkDerivation, aeson, base, http-client, lens, tagged, text, time

     

       220845
       220845
       -
            , transformers, wreq

     

       220846
       220846
       -
            }:

     

       220847
       220847
       -
            mkDerivation {

     

       220848
       220848
       -
              pname = "telega";

     

       220849
       220849
       -
              version = "0.2.0";

     

       220850
       220850
       -
              sha256 = "1q2prviwbnwhi0xfwwblhncnpz2l0829i3zp2v573w9h91qc5yjn";

     

       220851
       220851
       -
              libraryHaskellDepends = [

     

       220852
       220852
       -
                aeson base http-client lens tagged text time transformers wreq

     

       220853
       220853
       -
              ];

     

       220854
       220854
       -
              description = "Telegram Bot API binding";

     

       220855
       220855
       -
              license = stdenv.lib.licenses.mit;

     

       220856
       220856
       -
            }) {};

     

       220857
       220857
       -
       

     

       220858
       221884
        
         "telegram" = callPackage

     

       220859
       221885
        
              sha256 = "0zw591nqgyqy37vj0vmyyd2m7v6cyx8bgwfm1xhf1ppbxhjx38nv";

     

       220860
       221886
        
            , http-conduit, url, utf8-string

     
···

       221423
       222449
        
              broken = true;

     

       221424
       222450
        
            }) {};

     

       221425
       222451
        
       

     

       222452
       222452
       +
         "tensor-safe" = callPackage

     

       222453
       222453
       +
           ({ mkDerivation, base, casing, cmdargs, containers, extra

     

       222454
       222454
       +
            , formatting, ghc-typelits-extra, hint, singletons, text, vector

     

       222455
       222455
       +
            , vector-sized

     

       222456
       222456
       +
            }:

     

       222457
       222457
       +
            mkDerivation {

     

       222458
       222458
       +
              pname = "tensor-safe";

     

       222459
       222459
       +
              version = "0.1.0.0";

     

       222460
       222460
       +
              sha256 = "077jy3k47aw182nsdi3352lq9h6zssc9dpm7vwv999ksysaymhpw";

     

       222461
       222461
       +
              isLibrary = true;

     

       222462
       222462
       +
              isExecutable = true;

     

       222463
       222463
       +
              libraryHaskellDepends = [

     

       222464
       222464
       +
                base casing cmdargs containers extra formatting ghc-typelits-extra

     

       222465
       222465
       +
                hint singletons text vector vector-sized

     

       222466
       222466
       +
              ];

     

       222467
       222467
       +
              executableHaskellDepends = [

     

       222468
       222468
       +
                base casing cmdargs containers extra formatting ghc-typelits-extra

     

       222469
       222469
       +
                hint singletons text vector vector-sized

     

       222470
       222470
       +
              ];

     

       222471
       222471
       +
              description = "Create valid deep neural network architectures";

     

       222472
       222472
       +
              license = stdenv.lib.licenses.bsd3;

     

       222473
       222473
       +
            }) {};

     

       222474
       222474
       +
       

     

       221426
       222475
        
         "tensorflow" = callPackage

     

       221427
       222476
        
           ({ mkDerivation, async, attoparsec, base, bytestring, c2hs

     

       221428
       222477
        
            , containers, data-default, exceptions, fgl, HUnit, lens-family

     
···

       221704
       222753
        
            }) {};

     

       221705
       222754
        
       

     

       221706
       222755
        
         "termbox-banana" = callPackage

     

       221707
       221707
       -
           ({ mkDerivation, base, reactive-banana, stm, termbox }:

     

       222756
       222756
       +
           ({ mkDerivation, base, reactive-banana, termbox }:

     

       221708
       222757
        
            mkDerivation {

     

       221709
       222758
        
              pname = "termbox-banana";

     

       221710
       221710
       -
              version = "0.1.0";

     

       221711
       221711
       -
              sha256 = "0qyr2zykplxdg2x7k4xcg0cnv7lxx60lr55k8fs29556zalkgcgz";

     

       221712
       221712
       -
              libraryHaskellDepends = [ base reactive-banana stm termbox ];

     

       222759
       222759
       +
              version = "0.1.1";

     

       222760
       222760
       +
              sha256 = "0584n8fq3rdq4rw20sglqwm76w8qmg8akhrkvda8scrvmgi5xbck";

     

       222761
       222761
       +
              libraryHaskellDepends = [ base reactive-banana termbox ];

     

       221713
       222762
        
              description = "reactive-banana + termbox";

     

       221714
       222763
        
              license = stdenv.lib.licenses.bsd3;

     

       221715
       222764
        
              hydraPlatforms = stdenv.lib.platforms.none;

     
···

       224192
       225241
        
              license = stdenv.lib.licenses.bsd3;

     

       224193
       225242
        
            }) {};

     

       224194
       225243
        
       

     

       225244
       225244
       +
         "th-reify-many_0_1_9" = callPackage

     

       225245
       225245
       +
           ({ mkDerivation, base, containers, mtl, safe, template-haskell

     

       225246
       225246
       +
            , th-expand-syns

     

       225247
       225247
       +
            }:

     

       225248
       225248
       +
            mkDerivation {

     

       225249
       225249
       +
              pname = "th-reify-many";

     

       225250
       225250
       +
              version = "0.1.9";

     

       225251
       225251
       +
              sha256 = "0hxf56filzqnyrc8q7766vai80y6cgrrbrczx6n93caskl1dv2gq";

     

       225252
       225252
       +
              libraryHaskellDepends = [

     

       225253
       225253
       +
                base containers mtl safe template-haskell th-expand-syns

     

       225254
       225254
       +
              ];

     

       225255
       225255
       +
              testHaskellDepends = [ base template-haskell ];

     

       225256
       225256
       +
              description = "Recurseively reify template haskell datatype info";

     

       225257
       225257
       +
              license = stdenv.lib.licenses.bsd3;

     

       225258
       225258
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       225259
       225259
       +
            }) {};

     

       225260
       225260
       +
       

     

       224195
       225261
        
         "th-sccs" = callPackage

     

       224196
       225262
        
           ({ mkDerivation, base, containers, template-haskell }:

     

       224197
       225263
        
            mkDerivation {

     
···

       224338
       225404
        
            }:

     

       224339
       225405
        
            mkDerivation {

     

       224340
       225406
        
              pname = "themoviedb";

     

       224341
       224341
       -
              version = "1.1.5.0";

     

       224342
       224342
       -
              sha256 = "05za904yimkf9vpkksyxw6j488xyd0wigjdkj25hf2xx4nw36j0v";

     

       225407
       225407
       +
              version = "1.1.5.2";

     

       225408
       225408
       +
              sha256 = "0pp603wvq03m56w0y12abjqbfv712aj3k6ki69jq60l9pxj4nni4";

     

       224343
       225409
        
              isLibrary = true;

     

       224344
       225410
        
              isExecutable = true;

     

       224345
       225411
        
              libraryHaskellDepends = [

     
···

       225124
       226190
        
            }) {};

     

       225125
       226191
        
       

     

       225126
       226192
        
         "tidal" = callPackage

     

       225127
       225127
       -
           ({ mkDerivation, base, bifunctors, colour, containers, hosc

     

       225128
       225128
       -
            , microspec, mwc-random, network, parsec, template-haskell, text

     

       225129
       225129
       -
            , transformers, vector

     

       226193
       226193
       +
           ({ mkDerivation, base, bifunctors, bytestring, clock, colour

     

       226194
       226194
       +
            , containers, hosc, microspec, mwc-random, network, parsec

     

       226195
       226195
       +
            , template-haskell, text, transformers, vector

     

       226196
       226196
       +
            }:

     

       226197
       226197
       +
            mkDerivation {

     

       226198
       226198
       +
              pname = "tidal";

     

       226199
       226199
       +
              version = "1.0.11";

     

       226200
       226200
       +
              sha256 = "1lpb5233s48hfb9qjwm18c7mv31i8fw0vxqqia8kxlqdhmfcz5ri";

     

       226201
       226201
       +
              enableSeparateDataOutput = true;

     

       226202
       226202
       +
              libraryHaskellDepends = [

     

       226203
       226203
       +
                base bifunctors bytestring clock colour containers hosc mwc-random

     

       226204
       226204
       +
                network parsec template-haskell text transformers vector

     

       226205
       226205
       +
              ];

     

       226206
       226206
       +
              testHaskellDepends = [ base containers microspec parsec ];

     

       226207
       226207
       +
              description = "Pattern language for improvised music";

     

       226208
       226208
       +
              license = stdenv.lib.licenses.gpl3;

     

       226209
       226209
       +
            }) {};

     

       226210
       226210
       +
       

     

       226211
       226211
       +
         "tidal_1_0_13" = callPackage

     

       226212
       226212
       +
           ({ mkDerivation, base, bifunctors, bytestring, clock, colour

     

       226213
       226213
       +
            , containers, hosc, microspec, mwc-random, network, parsec

     

       226214
       226214
       +
            , template-haskell, text, transformers, vector

     

       225130
       226215
        
            }:

     

       225131
       226216
        
            mkDerivation {

     

       225132
       226217
        
              pname = "tidal";

     

       225133
       225133
       -
              version = "1.0.10";

     

       225134
       225134
       -
              sha256 = "1pays7hjsv7rpc0ldmzhavxkyp3avcwz912zfm9y80fyhhyyf4jp";

     

       226218
       226218
       +
              version = "1.0.13";

     

       226219
       226219
       +
              sha256 = "0m28z3mlp6q51znzjgw1hsfy8g4npsxl8bydm8hm9dslqc7gdi7j";

     

       226220
       226220
       +
              enableSeparateDataOutput = true;

     

       225135
       226221
        
              libraryHaskellDepends = [

     

       225136
       225136
       -
                base bifunctors colour containers hosc mwc-random network parsec

     

       225137
       225137
       -
                template-haskell text transformers vector

     

       226222
       226222
       +
                base bifunctors bytestring clock colour containers hosc mwc-random

     

       226223
       226223
       +
                network parsec template-haskell text transformers vector

     

       225138
       226224
        
              ];

     

       225139
       226225
        
              testHaskellDepends = [ base containers microspec parsec ];

     

       225140
       226226
        
              description = "Pattern language for improvised music";

     

       225141
       226227
        
              license = stdenv.lib.licenses.gpl3;

     

       226228
       226228
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       225142
       226229
        
            }) {};

     

       225143
       226230
        
       

     

       225144
       226231
        
         "tidal-midi" = callPackage

     
···

       229721
       230808
        
            }:

     

       229722
       230809
        
            mkDerivation {

     

       229723
       230810
        
              pname = "turtle";

     

       229724
       229724
       -
              version = "1.5.13";

     

       229725
       229725
       -
              sha256 = "1124yhw0l8924cwkmap1qn2z0hf4vn3r73h4pmi9icahg8zpc1hg";

     

       230811
       230811
       +
              version = "1.5.14";

     

       230812
       230812
       +
              sha256 = "10sxbmis82z5r2ksfkik5kryz5i0xwihz9drc1dzz4fb76kkb67z";

     

       229726
       230813
        
              libraryHaskellDepends = [

     

       229727
       230814
        
                ansi-wl-pprint async base bytestring clock containers directory

     

       229728
       230815
        
                exceptions foldl hostname managed optional-args

     
···

       232874
       233961
        
              pname = "uniprot-kb";

     

       232875
       233962
        
              version = "0.1.2.0";

     

       232876
       233963
        
              sha256 = "0hh6fnnmr6i4mgli07hgaagswdipa0p3ckr3jzzfcw4y5x98036l";

     

       232877
       232877
       -
              revision = "3";

     

       232878
       232878
       -
              editedCabalFile = "1a532yhvgs7n096f6mjwm7811d2c6xbgr45gscg7d4ys042c0586";

     

       233964
       233964
       +
              revision = "4";

     

       233965
       233965
       +
              editedCabalFile = "1g4qds20lwsbn5hqrgbhb4yd5w5vx2gkw47mjvxr8z8nj20g2pii";

     

       232879
       233966
        
              libraryHaskellDepends = [ attoparsec base text ];

     

       232880
       233967
        
              testHaskellDepends = [

     

       232881
       233968
        
                attoparsec base hspec neat-interpolation QuickCheck text

     
···

       233173
       234260
        
            }) {};

     

       233174
       234261
        
       

     

       233175
       234262
        
         "universe" = callPackage

     

       233176
       233176
       -
           ({ mkDerivation, universe-instances-base

     

       233177
       233177
       -
            , universe-instances-extended, universe-instances-trans

     

       233178
       233178
       -
            , universe-reverse-instances

     

       234263
       234263
       +
           ({ mkDerivation, universe-base, universe-dependent-sum

     

       234264
       234264
       +
            , universe-instances-extended, universe-reverse-instances

     

       233179
       234265
        
            }:

     

       233180
       234266
        
            mkDerivation {

     

       233181
       234267
        
              pname = "universe";

     

       233182
       233182
       -
              version = "1.0";

     

       233183
       233183
       -
              sha256 = "19zr9zcqc5sfp5qfn8slkk2732j1814m3j1jkbim739limwf900z";

     

       234268
       234268
       +
              version = "1.1";

     

       234269
       234269
       +
              sha256 = "0zghqcv6jyl9x3qfmbnqyfvr4pkf3m6lil0vg66m16xlrgz68hds";

     

       233184
       234270
        
              libraryHaskellDepends = [

     

       233185
       233185
       -
                universe-instances-base universe-instances-extended

     

       233186
       233186
       -
                universe-instances-trans universe-reverse-instances

     

       234271
       234271
       +
                universe-base universe-dependent-sum universe-instances-extended

     

       234272
       234272
       +
                universe-reverse-instances

     

       233187
       234273
        
              ];

     

       233188
       233188
       -
              description = "Classes for types where we know all the values";

     

       234274
       234274
       +
              description = "A class for finite and recursively enumerable types";

     

       233189
       234275
        
              license = stdenv.lib.licenses.bsd3;

     

       233190
       234276
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       233191
       234277
        
              broken = true;

     
···

       233202
       234288
        
              license = stdenv.lib.licenses.bsd3;

     

       233203
       234289
        
            }) {};

     

       233204
       234290
        
       

     

       234291
       234291
       +
         "universe-base_1_1" = callPackage

     

       234292
       234292
       +
           ({ mkDerivation, base, containers, QuickCheck, tagged, transformers

     

       234293
       234293
       +
            }:

     

       234294
       234294
       +
            mkDerivation {

     

       234295
       234295
       +
              pname = "universe-base";

     

       234296
       234296
       +
              version = "1.1";

     

       234297
       234297
       +
              sha256 = "1alr2gbmdp9lsarnhfl72zkcqrfwxwvmlq3nyb9ilmwinahlzf0n";

     

       234298
       234298
       +
              libraryHaskellDepends = [ base containers tagged transformers ];

     

       234299
       234299
       +
              testHaskellDepends = [ base containers QuickCheck ];

     

       234300
       234300
       +
              description = "A class for finite and recursively enumerable types";

     

       234301
       234301
       +
              license = stdenv.lib.licenses.bsd3;

     

       234302
       234302
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       234303
       234303
       +
            }) {};

     

       234304
       234304
       +
       

     

       234305
       234305
       +
         "universe-dependent-sum" = callPackage

     

       234306
       234306
       +
           ({ mkDerivation, base, dependent-sum, template-haskell

     

       234307
       234307
       +
            , th-abstraction, transformers, universe-base

     

       234308
       234308
       +
            }:

     

       234309
       234309
       +
            mkDerivation {

     

       234310
       234310
       +
              pname = "universe-dependent-sum";

     

       234311
       234311
       +
              version = "1.1";

     

       234312
       234312
       +
              sha256 = "1psnj7xk5ig7ghvxr6awz60117y6xdwxd8i4jbxivgfrp5ixp85f";

     

       234313
       234313
       +
              libraryHaskellDepends = [

     

       234314
       234314
       +
                base dependent-sum template-haskell th-abstraction transformers

     

       234315
       234315
       +
                universe-base

     

       234316
       234316
       +
              ];

     

       234317
       234317
       +
              testHaskellDepends = [

     

       234318
       234318
       +
                base dependent-sum template-haskell universe-base

     

       234319
       234319
       +
              ];

     

       234320
       234320
       +
              description = "Universe instances for types from dependent-sum";

     

       234321
       234321
       +
              license = stdenv.lib.licenses.bsd3;

     

       234322
       234322
       +
            }) {};

     

       234323
       234323
       +
       

     

       233205
       234324
        
         "universe-instances-base" = callPackage

     

       233206
       234325
        
           ({ mkDerivation, base, containers, universe-base }:

     

       233207
       234326
        
            mkDerivation {

     
···

       233215
       234334
        
              license = stdenv.lib.licenses.bsd3;

     

       233216
       234335
        
            }) {};

     

       233217
       234336
        
       

     

       234337
       234337
       +
         "universe-instances-base_1_1" = callPackage

     

       234338
       234338
       +
           ({ mkDerivation, base, universe-base }:

     

       234339
       234339
       +
            mkDerivation {

     

       234340
       234340
       +
              pname = "universe-instances-base";

     

       234341
       234341
       +
              version = "1.1";

     

       234342
       234342
       +
              sha256 = "17g4xf7zcxd9a2am0p401b0l87ynxwpm3c2lqc4vmw4sz071kccb";

     

       234343
       234343
       +
              libraryHaskellDepends = [ base universe-base ];

     

       234344
       234344
       +
              description = "Universe instances for types from the base package";

     

       234345
       234345
       +
              license = stdenv.lib.licenses.bsd3;

     

       234346
       234346
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       234347
       234347
       +
            }) {};

     

       234348
       234348
       +
       

     

       233218
       234349
        
         "universe-instances-extended" = callPackage

     

       233219
       233219
       -
           ({ mkDerivation, adjunctions, base, comonad

     

       233220
       233220
       -
            , universe-instances-base, void

     

       233221
       233221
       -
            }:

     

       234350
       234350
       +
           ({ mkDerivation, adjunctions, base, comonad, universe-base }:

     

       233222
       234351
        
            mkDerivation {

     

       233223
       234352
        
              pname = "universe-instances-extended";

     

       233224
       233224
       -
              version = "1.0.0.1";

     

       233225
       233225
       -
              sha256 = "15y9f0hbxqsksclxrssj4h08y0yb3nm9clqasjw6nsmi04kjfnv6";

     

       233226
       233226
       -
              revision = "3";

     

       233227
       233227
       -
              editedCabalFile = "1f7mzwn97kmnm1p1hscz5mzly700q2pw5awwdzzsxfkxv3law7xn";

     

       233228
       233228
       -
              libraryHaskellDepends = [

     

       233229
       233229
       -
                adjunctions base comonad universe-instances-base void

     

       233230
       233230
       -
              ];

     

       233231
       233231
       -
              description = "Universe instances for types from select extra packages";

     

       234353
       234353
       +
              version = "1.1";

     

       234354
       234354
       +
              sha256 = "12ads0n5md27wznrv7ah668ip2pp3gryn8d6my74kyhsz6g2fn5q";

     

       234355
       234355
       +
              libraryHaskellDepends = [ adjunctions base comonad universe-base ];

     

       234356
       234356
       +
              description = "Universe instances for types from selected extra packages";

     

       233232
       234357
        
              license = stdenv.lib.licenses.bsd3;

     

       233233
       234358
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       233234
       234359
        
              broken = true;

     
···

       233251
       234376
        
              license = stdenv.lib.licenses.bsd3;

     

       233252
       234377
        
            }) {};

     

       233253
       234378
        
       

     

       234379
       234379
       +
         "universe-instances-trans_1_1" = callPackage

     

       234380
       234380
       +
           ({ mkDerivation, base, universe-base }:

     

       234381
       234381
       +
            mkDerivation {

     

       234382
       234382
       +
              pname = "universe-instances-trans";

     

       234383
       234383
       +
              version = "1.1";

     

       234384
       234384
       +
              sha256 = "0dp37rb61g5mqj4kfkgi6zxcjhrm9npz197sksqwg1skgjdgbbn6";

     

       234385
       234385
       +
              libraryHaskellDepends = [ base universe-base ];

     

       234386
       234386
       +
              description = "Universe instances for types from the transformers and mtl packages";

     

       234387
       234387
       +
              license = stdenv.lib.licenses.bsd3;

     

       234388
       234388
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       234389
       234389
       +
            }) {};

     

       234390
       234390
       +
       

     

       233254
       234391
        
         "universe-reverse-instances" = callPackage

     

       233255
       234392
        
           ({ mkDerivation, base, containers, universe-instances-base }:

     

       233256
       234393
        
            mkDerivation {

     
···

       233264
       234401
        
              ];

     

       233265
       234402
        
              description = "instances of standard classes that are made possible by enumerations";

     

       233266
       234403
        
              license = stdenv.lib.licenses.bsd3;

     

       234404
       234404
       +
            }) {};

     

       234405
       234405
       +
       

     

       234406
       234406
       +
         "universe-reverse-instances_1_1" = callPackage

     

       234407
       234407
       +
           ({ mkDerivation, base, containers, universe-base }:

     

       234408
       234408
       +
            mkDerivation {

     

       234409
       234409
       +
              pname = "universe-reverse-instances";

     

       234410
       234410
       +
              version = "1.1";

     

       234411
       234411
       +
              sha256 = "0pdmv146ap0dh38mxhjf11jx3fbr9im7mc0zxb3bsnwpfrv1kfqd";

     

       234412
       234412
       +
              libraryHaskellDepends = [ base containers universe-base ];

     

       234413
       234413
       +
              description = "Instances of standard classes that are made possible by enumerations";

     

       234414
       234414
       +
              license = stdenv.lib.licenses.bsd3;

     

       234415
       234415
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       233267
       234416
        
            }) {};

     

       233268
       234417
        
       

     

       233269
       234418
        
         "universe-th" = callPackage

     
···

       236505
       237654
        
              broken = true;

     

       236506
       237655
        
            }) {};

     

       236507
       237656
        
       

     

       237657
       237657
       +
         "vector-endian" = callPackage

     

       237658
       237658
       +
           ({ mkDerivation, base, cpu, deepseq, vector, zenhack-prelude }:

     

       237659
       237659
       +
            mkDerivation {

     

       237660
       237660
       +
              pname = "vector-endian";

     

       237661
       237661
       +
              version = "0.1.0.0";

     

       237662
       237662
       +
              sha256 = "0qfs19l2d56w6jl8niiq8vsjldb8mabf56xfsj45ai7ipi92cx13";

     

       237663
       237663
       +
              libraryHaskellDepends = [

     

       237664
       237664
       +
                base cpu deepseq vector zenhack-prelude

     

       237665
       237665
       +
              ];

     

       237666
       237666
       +
              doHaddock = false;

     

       237667
       237667
       +
              description = "Storable vectors with cpu-independent representation";

     

       237668
       237668
       +
              license = stdenv.lib.licenses.mit;

     

       237669
       237669
       +
            }) {};

     

       237670
       237670
       +
       

     

       236508
       237671
        
         "vector-extras" = callPackage

     

       236509
       237672
        
           ({ mkDerivation, base, containers, deferred-folds, foldl, hashable

     

       236510
       237673
        
            , unordered-containers, vector

     
···

       237014
       238177
        
            }:

     

       237015
       238178
        
            mkDerivation {

     

       237016
       238179
        
              pname = "versions";

     

       237017
       237017
       -
              version = "3.5.0";

     

       237018
       237018
       -
              sha256 = "1g6db0ah78yk1m5wyxp0az7bzlbxsfkychqjcj423wzx90z7ww4w";

     

       237019
       237019
       -
              revision = "1";

     

       237020
       237020
       -
              editedCabalFile = "13gb4n3bdkbgf199q3px7ihaqycbx76cb8isrs3qn16n67mx5b2f";

     

       238180
       238180
       +
              version = "3.5.1";

     

       238181
       238181
       +
              sha256 = "1qbihyqw99wkdmslvxqkj6h8x0ih9w86h4s7k51maaicmgijm94w";

     

       237021
       238182
        
              libraryHaskellDepends = [ base deepseq hashable megaparsec text ];

     

       237022
       238183
        
              testHaskellDepends = [

     

       237023
       238184
        
                base base-prelude checkers megaparsec microlens QuickCheck tasty

     
···

       237220
       238381
        
            }:

     

       237221
       238382
        
            mkDerivation {

     

       237222
       238383
        
              pname = "vimeta";

     

       237223
       237223
       -
              version = "0.2.5.0";

     

       237224
       237224
       -
              sha256 = "03ykd8pz7wn9dcj78zgq15ip04g8b4b7945g6fj5a7bfz0y9asbf";

     

       238384
       238384
       +
              version = "0.2.5.1";

     

       238385
       238385
       +
              sha256 = "1v46b0215mcyhxma3ascg3paz683j8xqsf4czs8syx4amyls36qg";

     

       237225
       238386
        
              isLibrary = true;

     

       237226
       238387
        
              isExecutable = true;

     

       237227
       238388
        
              libraryHaskellDepends = [

     
···

       239567
       240728
        
            }:

     

       239568
       240729
        
            mkDerivation {

     

       239569
       240730
        
              pname = "wai-secure-cookies";

     

       239570
       239570
       -
              version = "0.1.0.3";

     

       239571
       239571
       -
              sha256 = "01jqwl9z7p3vkh7jvlxzvqcq2bgkcfx559pnc87qgp7ldh018z7f";

     

       240731
       240731
       +
              version = "0.1.0.4";

     

       240732
       240732
       +
              sha256 = "0m77h2xnm3h3axchvmbylrhm4s7d31zxsv0bgqvmh9zhydr90d2v";

     

       239572
       240733
        
              isLibrary = true;

     

       239573
       240734
        
              isExecutable = true;

     

       239574
       240735
        
              libraryHaskellDepends = [

     
···

       240115
       241276
        
              license = stdenv.lib.licenses.bsd3;

     

       240116
       241277
        
            }) {};

     

       240117
       241278
        
       

     

       241279
       241279
       +
         "warp-tls-uid_0_2_0_6" = callPackage

     

       241280
       241280
       +
           ({ mkDerivation, base, bytestring, data-default, network

     

       241281
       241281
       +
            , streaming-commons, tls, unix, wai, warp, warp-tls, x509

     

       241282
       241282
       +
            }:

     

       241283
       241283
       +
            mkDerivation {

     

       241284
       241284
       +
              pname = "warp-tls-uid";

     

       241285
       241285
       +
              version = "0.2.0.6";

     

       241286
       241286
       +
              sha256 = "09xvwvb6nc6ymp6x389dxbllisrj24srcdli6d19h05cwlqbay4w";

     

       241287
       241287
       +
              libraryHaskellDepends = [

     

       241288
       241288
       +
                base bytestring data-default network streaming-commons tls unix wai

     

       241289
       241289
       +
                warp warp-tls x509

     

       241290
       241290
       +
              ];

     

       241291
       241291
       +
              testHaskellDepends = [

     

       241292
       241292
       +
                base bytestring data-default network streaming-commons tls unix wai

     

       241293
       241293
       +
                warp warp-tls x509

     

       241294
       241294
       +
              ];

     

       241295
       241295
       +
              description = "set group and user id before running server";

     

       241296
       241296
       +
              license = stdenv.lib.licenses.bsd3;

     

       241297
       241297
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       241298
       241298
       +
            }) {};

     

       241299
       241299
       +
       

     

       240118
       241300
        
         "warped" = callPackage

     

       240119
       241301
        
           ({ mkDerivation, aeson, base, blaze-builder, conduit, http-types

     

       240120
       241302
        
            , lifted-async, monad-control, preamble, uuid, wai, wai-conduit

     
···

       241850
       243032
        
            }:

     

       241851
       243033
        
            mkDerivation {

     

       241852
       243034
        
              pname = "wikicfp-scraper";

     

       241853
       241853
       -
              version = "0.1.0.10";

     

       241854
       241854
       -
              sha256 = "1j6aizgsf387pm6ajr6zjj1l4nnaq8mryq4vr09jji91ix9zhnw7";

     

       243035
       243035
       +
              version = "0.1.0.11";

     

       243036
       243036
       +
              sha256 = "1f6zrgjhid1fps02hbd6lmaxpi635bdzcxbsfkfk8xd7wmj0x91b";

     

       241855
       243037
        
              libraryHaskellDepends = [

     

       241856
       243038
        
                attoparsec base bytestring scalpel-core text time

     

       241857
       243039
        
              ];

     
···

       242063
       243245
        
              license = stdenv.lib.licenses.bsd3;

     

       242064
       243246
        
            }) {};

     

       242065
       243247
        
       

     

       242066
       242066
       -
         "winery_1_0_1" = callPackage

     

       243248
       243248
       +
         "winery_1_1_1" = callPackage

     

       242067
       243249
        
           ({ mkDerivation, aeson, base, binary, bytestring, cereal

     

       242068
       243250
        
            , containers, cpu, deepseq, directory, fast-builder, gauge

     

       242069
       243251
        
            , hashable, HUnit, megaparsec, mtl, prettyprinter

     
···

       242073
       243255
        
            }:

     

       242074
       243256
        
            mkDerivation {

     

       242075
       243257
        
              pname = "winery";

     

       242076
       242076
       -
              version = "1.0.1";

     

       242077
       242077
       -
              sha256 = "03g397c7s13brm5jsdzrwg5vyanvj6yznhn95aax7a8dwvhphk2n";

     

       243258
       243258
       +
              version = "1.1.1";

     

       243259
       243259
       +
              sha256 = "0jyr5vwz55rjwqvvh2ys3aq426i6jhfrykz0mx4kidr9l9yd0yls";

     

       242078
       243260
        
              isLibrary = true;

     

       242079
       243261
        
              isExecutable = true;

     

       242080
       243262
        
              libraryHaskellDepends = [

     
···

       242096
       243278
        
                aeson base binary bytestring cereal deepseq directory gauge

     

       242097
       243279
        
                serialise text

     

       242098
       243280
        
              ];

     

       242099
       242099
       -
              description = "Sustainable serialisation library";

     

       243281
       243281
       +
              description = "A compact, well-typed seralisation format for Haskell values";

     

       242100
       243282
        
              license = stdenv.lib.licenses.bsd3;

     

       242101
       243283
        
              hydraPlatforms = stdenv.lib.platforms.none;

     

       242102
       243284
        
            }) {};

     
···

       242192
       243374
        
              libraryHaskellDepends = [ base ];

     

       242193
       243375
        
              executableHaskellDepends = [ base ];

     

       242194
       243376
        
              description = "Access GPIO pins on Raspberry Pi via wiringPi library";

     

       242195
       242195
       -
              license = stdenv.lib.licenses.bsd3;

     

       242196
       242196
       -
            }) {};

     

       242197
       242197
       -
       

     

       242198
       242198
       -
         "with" = callPackage

     

       242199
       242199
       -
           ({ mkDerivation }:

     

       242200
       242200
       -
            mkDerivation {

     

       242201
       242201
       -
              pname = "with";

     

       242202
       242202
       -
              version = "0.1.0";

     

       242203
       242203
       -
              sha256 = "0jgm6w1xisyww81ak9rrrqmhgaiwdgk5rgvzax72rknzg9rb6701";

     

       242204
       242204
       -
              description = "Simple open product type";

     

       242205
       243377
        
              license = stdenv.lib.licenses.bsd3;

     

       242206
       243378
        
            }) {};

     

       242207
       243379
        
       

     
···

       246406
       247578
        
              broken = true;

     

       246407
       247579
        
            }) {};

     

       246408
       247580
        
       

     

       247581
       247581
       +
         "yam_0_6_1" = callPackage

     

       247582
       247582
       +
           ({ mkDerivation, aeson, base, base16-bytestring, binary, bytestring

     

       247583
       247583
       +
            , data-default, exceptions, fast-logger, hspec, http-client

     

       247584
       247584
       +
            , http-types, lens, menshen, monad-logger, mtl, mwc-random

     

       247585
       247585
       +
            , QuickCheck, reflection, salak, scientific, servant-client

     

       247586
       247586
       +
            , servant-server, servant-swagger, servant-swagger-ui, swagger2

     

       247587
       247587
       +
            , text, transformers, unliftio-core, unordered-containers, vault

     

       247588
       247588
       +
            , vector, wai, warp

     

       247589
       247589
       +
            }:

     

       247590
       247590
       +
            mkDerivation {

     

       247591
       247591
       +
              pname = "yam";

     

       247592
       247592
       +
              version = "0.6.1";

     

       247593
       247593
       +
              sha256 = "1llgyx9giibm1yzgk61c47jnr0ppgj5q4sq0ml9bz99j5c16id70";

     

       247594
       247594
       +
              libraryHaskellDepends = [

     

       247595
       247595
       +
                aeson base base16-bytestring binary bytestring data-default

     

       247596
       247596
       +
                exceptions fast-logger http-client http-types lens menshen

     

       247597
       247597
       +
                monad-logger mtl mwc-random reflection salak scientific

     

       247598
       247598
       +
                servant-client servant-server servant-swagger servant-swagger-ui

     

       247599
       247599
       +
                swagger2 text transformers unliftio-core unordered-containers vault

     

       247600
       247600
       +
                vector wai warp

     

       247601
       247601
       +
              ];

     

       247602
       247602
       +
              testHaskellDepends = [

     

       247603
       247603
       +
                aeson base base16-bytestring binary bytestring data-default

     

       247604
       247604
       +
                exceptions fast-logger hspec http-client http-types lens menshen

     

       247605
       247605
       +
                monad-logger mtl mwc-random QuickCheck reflection salak scientific

     

       247606
       247606
       +
                servant-client servant-server servant-swagger servant-swagger-ui

     

       247607
       247607
       +
                swagger2 text transformers unliftio-core unordered-containers vault

     

       247608
       247608
       +
                vector wai warp

     

       247609
       247609
       +
              ];

     

       247610
       247610
       +
              description = "A wrapper of servant";

     

       247611
       247611
       +
              license = stdenv.lib.licenses.bsd3;

     

       247612
       247612
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       247613
       247613
       +
              broken = true;

     

       247614
       247614
       +
            }) {};

     

       247615
       247615
       +
       

     

       246409
       247616
        
         "yam-app" = callPackage

     

       246410
       247617
        
           ({ mkDerivation, aeson, base, conduit, containers, ctrie

     

       246411
       247618
        
            , data-default, directory, exceptions, fast-logger, monad-control

     
···

       246462
       247669
        
              broken = true;

     

       246463
       247670
        
            }) {};

     

       246464
       247671
        
       

     

       247672
       247672
       +
         "yam-datasource_0_6_1" = callPackage

     

       247673
       247673
       +
           ({ mkDerivation, base, conduit, data-default, monad-logger

     

       247674
       247674
       +
            , persistent, resource-pool, resourcet, salak, servant-server, text

     

       247675
       247675
       +
            , unliftio-core, yam

     

       247676
       247676
       +
            }:

     

       247677
       247677
       +
            mkDerivation {

     

       247678
       247678
       +
              pname = "yam-datasource";

     

       247679
       247679
       +
              version = "0.6.1";

     

       247680
       247680
       +
              sha256 = "1k373bhh7pyb6i021a0akvsjfkpw7h3vw33a2ag57f97yalfwha4";

     

       247681
       247681
       +
              libraryHaskellDepends = [

     

       247682
       247682
       +
                base conduit data-default monad-logger persistent resource-pool

     

       247683
       247683
       +
                resourcet salak servant-server text unliftio-core yam

     

       247684
       247684
       +
              ];

     

       247685
       247685
       +
              description = "Yam DataSource Middleware";

     

       247686
       247686
       +
              license = stdenv.lib.licenses.bsd3;

     

       247687
       247687
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       247688
       247688
       +
              broken = true;

     

       247689
       247689
       +
            }) {};

     

       247690
       247690
       +
       

     

       246465
       247691
        
         "yam-job" = callPackage

     

       246466
       247692
        
           ({ mkDerivation, base, cron, yam-app }:

     

       246467
       247693
        
            mkDerivation {

     
···

       246487
       247713
        
              ];

     

       246488
       247714
        
              description = "Yam Logger";

     

       246489
       247715
        
              license = stdenv.lib.licenses.mit;

     

       247716
       247716
       +
            }) {};

     

       247717
       247717
       +
       

     

       247718
       247718
       +
         "yam-redis" = callPackage

     

       247719
       247719
       +
           ({ mkDerivation, base, bytestring, data-default, hedis, menshen

     

       247720
       247720
       +
            , monad-logger, mtl, salak, servant-server, text, yam

     

       247721
       247721
       +
            }:

     

       247722
       247722
       +
            mkDerivation {

     

       247723
       247723
       +
              pname = "yam-redis";

     

       247724
       247724
       +
              version = "0.6.1";

     

       247725
       247725
       +
              sha256 = "07qswsac1ygsfm97njry4ar1j9hb6ghkzmna7hw7f7a1y77x9m9p";

     

       247726
       247726
       +
              libraryHaskellDepends = [

     

       247727
       247727
       +
                base bytestring data-default hedis menshen monad-logger mtl salak

     

       247728
       247728
       +
                servant-server text yam

     

       247729
       247729
       +
              ];

     

       247730
       247730
       +
              description = "Yam Redis Middleware";

     

       247731
       247731
       +
              license = stdenv.lib.licenses.bsd3;

     

       247732
       247732
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       247733
       247733
       +
              broken = true;

     

       246490
       247734
        
            }) {};

     

       246491
       247735
        
       

     

       246492
       247736
        
         "yam-servant" = callPackage

     
···

       247479
       248723
        
              pname = "yesod-auth";

     

       247480
       248724
        
              version = "1.6.6";

     

       247481
       248725
        
              sha256 = "0ibmv3ghxrrjjjqb9jg4wnwr7w4hl4lsvwic13ys8fihg40ln6ka";

     

       248726
       248726
       +
              revision = "1";

     

       248727
       248727
       +
              editedCabalFile = "14l8v1znq9y628vc6vj7dlgbryjkhf09kk2l2f5spr697lygh3qp";

     

       247482
       248728
        
              libraryHaskellDepends = [

     

       247483
       248729
        
                aeson authenticate base base16-bytestring base64-bytestring binary

     

       247484
       248730
        
                blaze-builder blaze-html blaze-markup bytestring conduit

     
···

       248690
       249936
        
              license = stdenv.lib.licenses.bsd3;

     

       248691
       249937
        
            }) {};

     

       248692
       249938
        
       

     

       249939
       249939
       +
         "yesod-paginator_1_1_0_2" = callPackage

     

       249940
       249940
       +
           ({ mkDerivation, base, blaze-markup, doctest, hspec, path-pieces

     

       249941
       249941
       +
            , persistent, QuickCheck, quickcheck-classes, safe, text

     

       249942
       249942
       +
            , transformers, uri-encode, yesod-core, yesod-test

     

       249943
       249943
       +
            }:

     

       249944
       249944
       +
            mkDerivation {

     

       249945
       249945
       +
              pname = "yesod-paginator";

     

       249946
       249946
       +
              version = "1.1.0.2";

     

       249947
       249947
       +
              sha256 = "0r0qprsr2nkhy2b44xixmys32hp3wwhp5x521jzpcrd1jc5x38s9";

     

       249948
       249948
       +
              isLibrary = true;

     

       249949
       249949
       +
              isExecutable = true;

     

       249950
       249950
       +
              libraryHaskellDepends = [

     

       249951
       249951
       +
                base blaze-markup path-pieces persistent safe text transformers

     

       249952
       249952
       +
                uri-encode yesod-core

     

       249953
       249953
       +
              ];

     

       249954
       249954
       +
              testHaskellDepends = [

     

       249955
       249955
       +
                base doctest hspec QuickCheck quickcheck-classes yesod-core

     

       249956
       249956
       +
                yesod-test

     

       249957
       249957
       +
              ];

     

       249958
       249958
       +
              description = "A pagination approach for yesod";

     

       249959
       249959
       +
              license = stdenv.lib.licenses.bsd3;

     

       249960
       249960
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       249961
       249961
       +
            }) {};

     

       249962
       249962
       +
       

     

       248693
       249963
        
         "yesod-paypal-rest" = callPackage

     

       248694
       249964
        
           ({ mkDerivation, base, paypal-rest-client, time, yesod-core }:

     

       248695
       249965
        
            mkDerivation {

     
···

       248746
       250016
        
              ];

     

       248747
       250017
        
              description = "Some helpers for using Persistent from Yesod";

     

       248748
       250018
        
              license = stdenv.lib.licenses.mit;

     

       250019
       250019
       +
            }) {};

     

       250020
       250020
       +
       

     

       250021
       250021
       +
         "yesod-persistent_1_6_0_2" = callPackage

     

       250022
       250022
       +
           ({ mkDerivation, base, blaze-builder, conduit, hspec, persistent

     

       250023
       250023
       +
            , persistent-sqlite, persistent-template, resource-pool, resourcet

     

       250024
       250024
       +
            , text, transformers, wai-extra, yesod-core

     

       250025
       250025
       +
            }:

     

       250026
       250026
       +
            mkDerivation {

     

       250027
       250027
       +
              pname = "yesod-persistent";

     

       250028
       250028
       +
              version = "1.6.0.2";

     

       250029
       250029
       +
              sha256 = "17adw0aaj29ia7ii3jka301442860b5wvfrms079q973gzahz5fd";

     

       250030
       250030
       +
              libraryHaskellDepends = [

     

       250031
       250031
       +
                base blaze-builder conduit persistent persistent-template

     

       250032
       250032
       +
                resource-pool resourcet transformers yesod-core

     

       250033
       250033
       +
              ];

     

       250034
       250034
       +
              testHaskellDepends = [

     

       250035
       250035
       +
                base blaze-builder conduit hspec persistent persistent-sqlite text

     

       250036
       250036
       +
                wai-extra yesod-core

     

       250037
       250037
       +
              ];

     

       250038
       250038
       +
              description = "Some helpers for using Persistent from Yesod";

     

       250039
       250039
       +
              license = stdenv.lib.licenses.mit;

     

       250040
       250040
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       248749
       250041
        
            }) {};

     

       248750
       250042
        
       

     

       248751
       250043
        
         "yesod-platform" = callPackage

     
···

       251130
       252422
        
              testToolDepends = [ unzip which ];

     

       251131
       252423
        
              description = "Library for creating and modifying zip archives";

     

       251132
       252424
        
              license = stdenv.lib.licenses.bsd3;

     

       252425
       252425
       +
            }) {inherit (pkgs) unzip; inherit (pkgs) which;};

     

       252426
       252426
       +
       

     

       252427
       252427
       +
         "zip-archive_0_4_1" = callPackage

     

       252428
       252428
       +
           ({ mkDerivation, array, base, binary, bytestring, containers

     

       252429
       252429
       +
            , digest, directory, filepath, HUnit, mtl, pretty, process

     

       252430
       252430
       +
            , temporary, text, time, unix, unzip, which, zlib

     

       252431
       252431
       +
            }:

     

       252432
       252432
       +
            mkDerivation {

     

       252433
       252433
       +
              pname = "zip-archive";

     

       252434
       252434
       +
              version = "0.4.1";

     

       252435
       252435
       +
              sha256 = "1cdix5mnxrbs7b2kivhdydhfzgxidd9dqlw71mdw5p21cabwkmf5";

     

       252436
       252436
       +
              revision = "1";

     

       252437
       252437
       +
              editedCabalFile = "1mv6jns7zf0fi7lrhzk007g12v6x7yf5ycbj67rbh83xfkf4nxsi";

     

       252438
       252438
       +
              isLibrary = true;

     

       252439
       252439
       +
              isExecutable = true;

     

       252440
       252440
       +
              libraryHaskellDepends = [

     

       252441
       252441
       +
                array base binary bytestring containers digest directory filepath

     

       252442
       252442
       +
                mtl pretty text time unix zlib

     

       252443
       252443
       +
              ];

     

       252444
       252444
       +
              testHaskellDepends = [

     

       252445
       252445
       +
                base bytestring directory filepath HUnit process temporary time

     

       252446
       252446
       +
                unix

     

       252447
       252447
       +
              ];

     

       252448
       252448
       +
              testToolDepends = [ unzip which ];

     

       252449
       252449
       +
              description = "Library for creating and modifying zip archives";

     

       252450
       252450
       +
              license = stdenv.lib.licenses.bsd3;

     

       252451
       252451
       +
              hydraPlatforms = stdenv.lib.platforms.none;

     

       251133
       252452
        
            }) {inherit (pkgs) unzip; inherit (pkgs) which;};

     

       251134
       252453
        
       

     

       251135
       252454
        
         "zip-conduit" = callPackage

+4 -2

pkgs/development/interpreters/python/mk-python-derivation.nix

···

       33
       33
        
       # DEPRECATED: use propagatedBuildInputs

     

       34
       34
        
       , pythonPath ? []

     

       35
       35
        
       

     

       36
       36
       +
       # Enabled to detect some (native)BuildInputs mistakes

     

       37
       37
       +
       , strictDeps ? true

     

       38
       38
       +
       

     

       36
       39
        
       # used to disable derivation, useful for specific python versions

     

       37
       40
        
       , disabled ? false

     

       38
       41
        
       

     
···

       87
       90
        
         # Propagate python and setuptools. We should stop propagating setuptools.

     

       88
       91
        
         propagatedBuildInputs = propagatedBuildInputs ++ [ python setuptools ];

     

       89
       92
        
       

     

       90
       90
       -
         # Enabled to detect some (native)BuildInputs mistakes

     

       91
       91
       -
         strictDeps = true;

     

       93
       93
       +
         inherit strictDeps;

     

       92
       94
        
       

     

       93
       95
        
         LANG = "${if python.stdenv.isDarwin then "en_US" else "C"}.UTF-8";

     

       94
       96

+2 -2

pkgs/development/libraries/catch2/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "catch2-${version}";

     

       5
       5
       -
         version = "2.7.0";

     

       5
       5
       +
         version = "2.7.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "catchorg";

     

       9
       9
        
           repo = "Catch2";

     

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

     

       11
       11
       -
           sha256="05j01v4hmw0vv5vcj11pbngl200b3j2yvawk08fw9a249jzx6v1a";

     

       11
       11
       +
           sha256="0h4yihf2avaw9awcigdqqlnfk5ak7scfv5lm0j8s6la4hyswc982";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ cmake ];

+2 -2

pkgs/development/libraries/cctz/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "cctz-${version}";

     

       5
       5
       -
         version = "2.2";

     

       5
       5
       +
         version = "2.3";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "google";

     

       9
       9
        
           repo = "cctz";

     

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

     

       11
       11
       -
           sha256 = "0liiqz1swfc019rzfaa9y5kavs2hwabs2vnwbn9jfczhyxy34y89";

     

       11
       11
       +
           sha256 = "0254xfwscfkjc3fbvx6qgifr3pwkc2rb03z8pbvvqy098di9alhr";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         makeFlags = [ "PREFIX=$(out)" ];

+2 -2

pkgs/development/libraries/cmark/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, cmake }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         version = "0.28.3";

     

       4
       4
       +
         version = "0.29.0";

     

       5
       5
        
         name = "cmark-${version}";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "jgm";

     

       9
       9
        
           repo = "cmark";

     

       10
       10
        
           rev = version;

     

       11
       11
       -
           sha256 = "1lal6n6q7l84njgdcq1xbfxan56qlvr8xaw9m2jbd0jk4y2wkczg";

     

       11
       11
       +
           sha256 = "0r7jpqhgnssq444i8pwji2g36058vfzwkl70wbiwj13h4w5rfc8f";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ cmake ];

+2 -2

pkgs/development/libraries/gecode/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "gecode-${version}";

     

       5
       5
       -
         version = "6.1.1";

     

       5
       5
       +
         version = "6.2.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "Gecode";

     

       9
       9
        
           repo = "gecode";

     

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

     

       11
       11
       -
           sha256 = "07jyx17qsfx3wmd2zlcs0rxax8h3cs2g9aapxkdjdcsmfxsldqb7";

     

       11
       11
       +
           sha256 = "0b1cq0c810j1xr2x9y9996p894571sdxng5h74py17c6nr8c6dmk";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         enableParallelBuilding = true;

+7 -2

pkgs/development/libraries/grpc/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, cmake, zlib, c-ares, pkgconfig, openssl, protobuf, gflags }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         version = "1.19.0";

     

       4
       4
       +
         version = "1.19.1";

     

       5
       5
        
         name = "grpc-${version}";

     

       6
       6
        
         src = fetchFromGitHub {

     

       7
       7
        
           owner = "grpc";

     

       8
       8
        
           repo = "grpc";

     

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

     

       10
       10
       -
           sha256 = "105hvpn2z3qiyc01wyzpmfbrpmy20kz1nb9j1c2s0kz1r0v92gqi";

     

       10
       10
       +
           sha256 = "0c0jra4qnd86gyr4rlblic3igb5dpgrldac35myk5i5ia547fdhj";

     

       11
       11
        
         };

     

       12
       12
        
         nativeBuildInputs = [ cmake pkgconfig ];

     

       13
       13
        
         buildInputs = [ zlib c-ares c-ares.cmake-config openssl protobuf gflags ];

     
···

       18
       18
        
             "-DgRPC_SSL_PROVIDER=package"

     

       19
       19
        
             "-DgRPC_PROTOBUF_PROVIDER=package"

     

       20
       20
        
             "-DgRPC_GFLAGS_PROVIDER=package"

     

       21
       21
       +
             "-DBUILD_SHARED_LIBS=ON"

     

       21
       22
        
           ];

     

       22
       23
        
       

     

       23
       24
        
         # CMake creates a build directory by default, this conflicts with the

     

       24
       25
        
         # basel BUILD file on case-insensitive filesystems.

     

       25
       26
        
         preConfigure = ''

     

       26
       27
        
           rm -vf BUILD

     

       28
       28
       +
         '';

     

       29
       29
       +
       

     

       30
       30
       +
         preBuild = ''

     

       31
       31
       +
           export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH

     

       27
       32
        
         '';

     

       28
       33
        
       

     

       29
       34
        
         NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.cc.isClang "-Wno-error=unknown-warning-option";

+2 -2

pkgs/development/libraries/intel-gmmlib/default.nix

···

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         name = "intel-gmmlib-${version}";

     

       7
       7
       -
         version = "18.4.1";

     

       7
       7
       +
         version = "19.1.2";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchFromGitHub {

     

       10
       10
        
           owner  = "intel";

     

       11
       11
        
           repo   = "gmmlib";

     

       12
       12
        
           rev    = name;

     

       13
       13
       -
           sha256 = "1nxbz54a0md9hf0asdbyglvi6kiggksy24ffmk4wzvkai6vinm17";

     

       13
       13
       +
           sha256 = "1nw5qg10dqkchx39vqk9nkqggk0in2kr794dqjp73njpirixgr2b";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = [ cmake ];

+2 -2

pkgs/development/libraries/intel-media-driver/default.nix

···

       5
       5
        
       

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
        
         name = "intel-media-driver-${version}";

     

       8
       8
       -
         version = "18.4.1";

     

       8
       8
       +
         version = "19.1.0";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner  = "intel";

     

       12
       12
        
           repo   = "media-driver";

     

       13
       13
        
           rev    = "intel-media-${version}";

     

       14
       14
       -
           sha256 = "192rfv6dk9jagx0q92jq6n1slc1pllgcc7rm85fgachq9rjl7szh";

     

       14
       14
       +
           sha256 = "072ry87h1lds14fqb2sfz3n2sssvacamaxv2gj4nd8agnzbwizn7";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         cmakeFlags = [

+2 -2

pkgs/development/libraries/intel-media-sdk/default.nix

···

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         name = "intel-media-sdk-${version}";

     

       7
       7
       -
         version = "18.4.1";

     

       7
       7
       +
         version = "19.1.0";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchurl {

     

       10
       10
        
           url = "https://github.com/Intel-Media-SDK/MediaSDK/archive/intel-mediasdk-${version}.tar.gz";

     

       11
       11
       -
           sha256 = "0yqqw6hyjn28zk4f4wznqpyiz9vinnjj8067dim64bz1f4pjhyra";

     

       11
       11
       +
           sha256 = "1gligrg6khzmwcy6miikljj75hhxqy0a95qzc8m61ipx5c8igdpv";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         # patchelf is needed for binaries in $out/share/samples

+2 -2

pkgs/development/libraries/kdb/default.nix

···

       6
       6
        
       

     

       7
       7
        
       mkDerivation rec {

     

       8
       8
        
         pname = "kdb";

     

       9
       9
       -
         version = "3.1.0";

     

       9
       9
       +
         version = "3.2.0";

     

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

     

       11
       11
        
       

     

       12
       12
        
         src = fetchurl {

     

       13
       13
        
           url = "mirror://kde/stable/${pname}/src/${name}.tar.xz";

     

       14
       14
       -
           sha256 = "1wi9z7j0nr9wi6aqqkdcpnr38ixyxbv00sblya7pakdf96hlamhp";

     

       14
       14
       +
           sha256 = "0s909x34a56n3xwhqz27irl2gbzidax0685w2kf34f0liny872cg";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         nativeBuildInputs = [ extra-cmake-modules ];

+9 -3

pkgs/development/libraries/libp11/default.nix

···

       1
       1
       -
       { stdenv, fetchFromGitHub, autoreconfHook, libtool, openssl, pkgconfig }:

     

       1
       1
       +
       { stdenv, fetchFromGitHub, autoreconfHook, libtool, pkgconfig

     

       2
       2
       +
       , openssl }:

     

       2
       3
        
       

     

       3
       4
        
       stdenv.mkDerivation rec {

     

       4
       5
        
         name = "libp11-${version}";

     
···

       11
       12
        
           sha256 = "1m4aw45bqichhx7cn78d8l1r1v0ccvwzlfj09fay2l9rfic5jgfz";

     

       12
       13
        
         };

     

       13
       14
        
       

     

       14
       14
       -
         makeFlags = [ "DESTDIR=$(out)" "PREFIX=" ];

     

       15
       15
       +
         configureFlags = [

     

       16
       16
       +
           "--with-enginesdir=${placeholder "out"}/lib/engines"

     

       17
       17
       +
         ];

     

       15
       18
        
       

     

       16
       19
        
         nativeBuildInputs = [ autoreconfHook pkgconfig libtool ];

     

       20
       20
       +
       

     

       17
       21
        
         buildInputs = [ openssl ];

     

       18
       22
        
       

     

       23
       23
       +
         enableParallelBuilding = true;

     

       24
       24
       +
       

     

       19
       25
        
         meta = with stdenv.lib; {

     

       26
       26
       +
           description = "Small layer on top of PKCS#11 API to make PKCS#11 implementations easier";

     

       20
       27
        
           homepage = https://github.com/OpenSC/libp11;

     

       21
       28
        
           license = licenses.lgpl21Plus;

     

       22
       22
       -
           description = "Small layer on top of PKCS#11 API to make PKCS#11 implementations easier";

     

       23
       29
        
           platforms = platforms.all;

     

       24
       30
        
         };

     

       25
       31
        
       }

+9 -8

pkgs/development/libraries/quazip/default.nix

···

       1
       1
       -
       { fetchurl, stdenv, zlib, qtbase, qmake }:

     

       1
       1
       +
       { fetchFromGitHub, stdenv, zlib, qtbase, qmake }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "quazip-0.7.3";

     

       4
       4
       +
         pname = "quazip";

     

       5
       5
       +
         version = "0.7.6";

     

       5
       6
        
       

     

       6
       6
       -
         src = fetchurl {

     

       7
       7
       -
           url = "mirror://sourceforge/quazip/${name}.tar.gz";

     

       8
       8
       -
           sha256 = "1db9w8ax1ki0p67a47h4cnbwfgi2di4y3k9nc3a610kffiag7m1a";

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "stachenov";

     

       9
       9
       +
           repo = pname;

     

       10
       10
       +
           rev = version;

     

       11
       11
       +
           sha256 = "1p6khy8fn9bwp14l6wd3sniwwm5v216l8xncfb7a6psjzvq5ypy6";

     

       9
       12
        
         };

     

       10
       10
       -
       

     

       11
       11
       -
         preConfigure = "cd quazip";

     

       12
       13
        
       

     

       13
       14
        
         buildInputs = [ zlib qtbase ];

     

       14
       15
        
         nativeBuildInputs = [ qmake ];

     
···

       16
       17
        
         meta = {

     

       17
       18
        
           description = "Provides access to ZIP archives from Qt programs";

     

       18
       19
        
           license = stdenv.lib.licenses.gpl2Plus;

     

       19
       19
       -
           homepage = http://quazip.sourceforge.net/;

     

       20
       20
       +
           homepage = https://stachenov.github.io/quazip/; # Migrated from http://quazip.sourceforge.net/

     

       20
       21
        
           platforms = stdenv.lib.platforms.linux;

     

       21
       22
        
         };

     

       22
       23
        
       }

+3 -3

pkgs/development/libraries/science/math/cudnn/default.nix

···

       59
       59
        
         cudnn_cudatoolkit_9 = cudnn_cudatoolkit_9_2;

     

       60
       60
        
       

     

       61
       61
        
         cudnn_cudatoolkit_10_0 = generic rec {

     

       62
       62
       -
           version = "7.3.1";

     

       62
       62
       +
           version = "7.4.2";

     

       63
       63
        
           cudatoolkit = cudatoolkit_10_0;

     

       64
       64
       -
           srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.3.1.20.tgz";

     

       65
       65
       -
           sha256 = "1yp35mng4ym40g5rqp63dcpa6jg4q1pnjkspnhlakzzdy8is65af";

     

       64
       64
       +
           srcName = "cudnn-${cudatoolkit.majorVersion}-linux-x64-v7.4.2.24.tgz";

     

       65
       65
       +
           sha256 = "18ys0apiz9afid2s6lvy9qbyi8g66aimb2a7ikl1f3dm09mciprf";

     

       66
       66
        
         };

     

       67
       67
        
       

     

       68
       68
        
         cudnn_cudatoolkit_10 = cudnn_cudatoolkit_10_0;

+9 -4

pkgs/development/ocaml-modules/zarith/default.nix

···

       1
       1
       -
       { stdenv, fetchurl

     

       1
       1
       +
       { stdenv, buildOcaml, fetchurl

     

       2
       2
        
       , ocaml, findlib, pkgconfig, perl

     

       3
       3
        
       , gmp

     

       4
       4
        
       }:

     
···

       16
       16
        
         };

     

       17
       17
        
       in

     

       18
       18
        
       

     

       19
       19
       -
       stdenv.mkDerivation rec {

     

       20
       20
       -
         name = "ocaml${ocaml.version}-zarith-${version}";

     

       19
       19
       +
       buildOcaml rec {

     

       20
       20
       +
         name = "zarith";

     

       21
       21
        
         inherit (source) version;

     

       22
       22
        
         src = fetchurl { inherit (source) url sha256; };

     

       23
       23
        
       

     

       24
       24
       +
         minimumSupportedOcamlVersion = "3.12.1";

     

       25
       25
       +
       

     

       24
       26
        
         nativeBuildInputs = [ pkgconfig ];

     

       25
       27
        
         buildInputs = [ ocaml findlib perl ];

     

       26
       28
        
         propagatedBuildInputs = [ gmp ];

     

       27
       29
        
       

     

       30
       30
       +
         # needed so setup-hook.sh sets CAML_LD_LIBRARY_PATH for dllzarith.so

     

       31
       31
       +
         hasSharedObjects = true;

     

       32
       32
       +
       

     

       28
       33
        
         patchPhase = "patchShebangs ./z_pp.pl";

     

       29
       34
        
         configurePhase = ''

     

       30
       35
        
           ./configure -installdir $out/lib/ocaml/${ocaml.version}/site-lib

     

       31
       36
        
         '';

     

       32
       32
       -
         createFindlibDestdir = true;

     

       37
       37
       +
         preInstall = "mkdir -p $out/lib/ocaml/${ocaml.version}/site-lib";

     

       33
       38
        
       

     

       34
       39
        
         meta = with stdenv.lib; {

     

       35
       40
        
           description = "Fast, arbitrary precision OCaml integers";

pkgs/development/python-modules/colanderalchemy/default.nix

···

       30
       30
        
           description = "Autogenerate Colander schemas based on SQLAlchemy models";

     

       31
       31
        
           homepage = https://github.com/stefanofontanelli/ColanderAlchemy;

     

       32
       32
        
           license = licenses.mit;

     

       33
       33
       +
           # ColanderAlchemy's tests currently fail with colander >1.6.0

     

       34
       34
       +
           # (see https://github.com/stefanofontanelli/ColanderAlchemy/issues/107)

     

       35
       35
       +
           broken = versionOlder "1.6.0" colander.version;

     

       33
       36
        
         };

     

       34
       37
        
       

     

       35
       38
        
       }

+2 -2

pkgs/development/python-modules/cysignals/default.nix

···

       9
       9
        
       

     

       10
       10
        
       buildPythonPackage rec {

     

       11
       11
        
         pname = "cysignals";

     

       12
       12
       -
         version = "1.9.0";

     

       12
       12
       +
         version = "1.10.2";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchPypi {

     

       15
       15
        
           inherit pname version;

     

       16
       16
       -
           sha256 = "15ix8crpad26cfl1skyg7qajqqfdrm8q5ahhmlfmqi1aw0jqj2g2";

     

       16
       16
       +
           sha256 = "1ckxzch3wk5cg80mppky5jib5z4fzslny3001r5zg4ar1ixbc1w1";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         # explicit check:

+3 -2

pkgs/development/python-modules/google-auth-oauthlib/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchPypi

     

       4
       4
       +
       , isPy3k

     

       4
       5
        
       , click

     

       5
       6
        
       , mock

     

       6
       7
        
       , pytest

     
···

       19
       20
        
         };

     

       20
       21
        
       

     

       21
       22
        
         checkInputs = [

     

       22
       22
       -
           click mock pytest futures

     

       23
       23
       -
         ];

     

       23
       23
       +
           click mock pytest

     

       24
       24
       +
         ] ++ lib.optionals (!isPy3k) [ futures ];

     

       24
       25
        
       

     

       25
       26
        
         propagatedBuildInputs = [

     

       26
       27
        
           google_auth requests_oauthlib

+3 -1

pkgs/development/python-modules/joblib/default.nix

···

       38
       38
        
         checkInputs = [ sphinx numpydoc pytest ];

     

       39
       39
        
         propagatedBuildInputs = [ python-lz4 ];

     

       40
       40
        
       

     

       41
       41
       +
         # test_disk_used is broken

     

       42
       42
       +
         # https://github.com/joblib/joblib/issues/57

     

       41
       43
        
         checkPhase = ''

     

       42
       42
       -
           py.test joblib

     

       44
       44
       +
           py.test joblib -k "not test_disk_used"

     

       43
       45
        
         '';

     

       44
       46
        
       

     

       45
       47
        
         meta = {

pkgs/development/python-modules/jupyterlab/default.nix

···

       4
       4
        
       , jupyterlab_server

     

       5
       5
        
       , notebook

     

       6
       6
        
       , pythonOlder

     

       7
       7
       +
       , fetchpatch

     

       7
       8
        
       }:

     

       8
       9
        
       

     

       9
       10
        
       buildPythonPackage rec {

     
···

       20
       21
        
       

     

       21
       22
        
         makeWrapperArgs = [

     

       22
       23
        
           "--set" "JUPYTERLAB_DIR" "$out/share/jupyter/lab"

     

       24
       24
       +
         ];

     

       25
       25
       +
       

     

       26
       26
       +
         patches = [

     

       27
       27
       +
           (fetchpatch {

     

       28
       28
       +
             name = "bump-jupyterlab_server-version";

     

       29
       29
       +
             url = https://github.com/jupyterlab/jupyterlab/commit/3b8d451e6f9a4c609e60cde5fbb3cc84aae79951.patch;

     

       30
       30
       +
             sha256 = "08vv6rp1k5fbmvj4v9x1d9zb6ymm9pv8ml80j7p45r9fay34rndf";

     

       31
       31
       +
           })

     

       23
       32
        
         ];

     

       24
       33
        
       

     

       25
       34
        
         # Depends on npm

+2 -2

pkgs/development/python-modules/mysql-connector/default.nix

···

       4
       4
        
       

     

       5
       5
        
       buildPythonPackage rec {

     

       6
       6
        
         pname = "mysql-connector";

     

       7
       7
       -
         version = "8.0.15";

     

       7
       7
       +
         version = "8.0.16";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchFromGitHub {

     

       10
       10
        
           owner = "mysql";

     

       11
       11
        
           repo = "mysql-connector-python";

     

       12
       12
        
           rev = version;

     

       13
       13
       -
           sha256 = "1w4j2sf07aid3453529z8kg1ziycbayxi3g2r4wqn0nb3y1caqz6";

     

       13
       13
       +
           sha256 = "0yl3fkyws24lc2qrbvn42bqy72aqy8q5v8f0j5zy3mkh9a7wlxdp";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         propagatedBuildInputs = [ protobuf ];

+2 -2

pkgs/development/python-modules/pychromecast/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildPythonPackage rec {

     

       4
       4
        
         pname = "PyChromecast";

     

       5
       5
       -
         version = "3.0.0";

     

       5
       5
       +
         version = "3.2.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchPypi {

     

       8
       8
        
           inherit pname version;

     

       9
       9
       -
           sha256 = "15zaka9zjyx5lb78f0qs6w8g1rgz94gjgrgxm6iwih0a2l0pv5h9";

     

       9
       9
       +
           sha256 = "0jksh7rb4880kni8iw3hb5q9dm5gi40zmx4r2fwydnpfhadhq5af";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         disabled = !isPy3k;

+11 -12

pkgs/development/python-modules/pyside/tools.nix

···

       1
       1
       -
       { lib, fetchurl, cmake, pyside, qt4, pysideShiboken, buildPythonPackage }:

     

       1
       1
       +
       { lib, buildPythonPackage, fetchFromGitHub, cmake, qt4, pyside, pysideShiboken }:

     

       2
       2
        
       

     

       3
       3
       -
       # This derivation provides a Python module and should therefore be called via `python-packages.nix`.

     

       4
       3
        
       buildPythonPackage rec {

     

       5
       4
        
         pname = "pyside-tools";

     

       6
       5
        
         version = "0.2.15";

     

       7
       6
        
         format = "other";

     

       8
       7
        
       

     

       9
       9
       -
         src = fetchurl {

     

       10
       10
       -
           url = "https://github.com/PySide/Tools/archive/0.2.15.tar.gz";

     

       11
       11
       -
           sha256 = "0x4z3aq7jgar74gxzwznl3agla9i1dcskw5gh11jnnwwn63ffzwa";

     

       8
       8
       +
         src = fetchFromGitHub {

     

       9
       9
       +
           owner = "PySide";

     

       10
       10
       +
           repo = "Tools";

     

       11
       11
       +
           rev = version;

     

       12
       12
       +
           sha256 = "017i2yxgjrisaifxqnl3ym8ijl63l2yl6a3474dsqhlyqz2nx2ll";

     

       12
       13
        
         };

     

       13
       14
        
       

     

       14
       14
       -
         enableParallelBuilding = true;

     

       15
       15
       -
       

     

       16
       15
        
         nativeBuildInputs = [ cmake ];

     

       17
       16
        
       

     

       18
       17
        
         buildInputs = [ qt4 ];

     

       19
       18
        
       

     

       20
       19
        
         propagatedBuildInputs = [ pyside pysideShiboken ];

     

       21
       20
        
       

     

       22
       22
       -
         meta = {

     

       23
       23
       -
           description = "Tools for pyside, the LGPL-licensed Python bindings for the Qt cross-platform application and UI framework";

     

       24
       24
       -
           license = lib.licenses.gpl2;

     

       25
       25
       -
           homepage = http://www.pyside.org;

     

       21
       21
       +
         meta = with lib; {

     

       22
       22
       +
           description = "Development tools (pyside-uic/rcc/lupdate) for PySide, the LGPL-licensed Python bindings for the Qt framework";

     

       23
       23
       +
           license = licenses.gpl2;

     

       24
       24
       +
           homepage = https://wiki.qt.io/PySide;

     

       26
       25
        
           maintainers = [ ];

     

       27
       27
       -
           platforms = lib.platforms.all;

     

       26
       26
       +
           platforms = platforms.all;

     

       28
       27
        
         };

     

       29
       28
        
       }

pkgs/development/python-modules/serversyncstorage/default.nix

···

       38
       38
        
         ];

     

       39
       39
        
       

     

       40
       40
        
         meta = with stdenv.lib; {

     

       41
       41
       +
           broken = cornice.version != "0.17";

     

       41
       42
        
           description = "The SyncServer server software, as used by Firefox Sync";

     

       42
       43
        
           homepage = https://github.com/mozilla-services/server-syncstorage;

     

       43
       44
        
           license = licenses.mpl20;

+2 -1

pkgs/development/python-modules/spacy/default.nix

···

       31
       31
        
         prePatch = ''

     

       32
       32
        
           substituteInPlace setup.py \

     

       33
       33
        
             --replace "regex==" "regex>=" \

     

       34
       34
       -
             --replace "plac<1.0.0,>=0.9.6" "plac>=0.9.6"

     

       34
       34
       +
             --replace "plac<1.0.0,>=0.9.6" "plac>=0.9.6" \

     

       35
       35
       +
             --replace "wheel>=0.32.0,<0.33.0" "wheel>=0.32.0"

     

       35
       36
        
         '';

     

       36
       37
        
       

     

       37
       38
        
         propagatedBuildInputs = [

+37

pkgs/development/python-modules/wikipedia/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       , beautifulsoup4

     

       5
       5
       +
       , requests

     

       6
       6
       +
       , python

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       buildPythonPackage rec {

     

       10
       10
       +
         pname = "wikipedia";

     

       11
       11
       +
         version = "1.4.0";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchPypi {

     

       14
       14
       +
           inherit pname version;

     

       15
       15
       +
           sha256 = "db0fad1829fdd441b1852306e9856398204dc0786d2996dd2e0c8bb8e26133b2";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         propagatedBuildInputs = [

     

       19
       19
       +
           beautifulsoup4

     

       20
       20
       +
           requests

     

       21
       21
       +
         ];

     

       22
       22
       +
       

     

       23
       23
       +
         checkPhase = ''

     

       24
       24
       +
           runHook preCheck

     

       25
       25
       +
       

     

       26
       26
       +
           ${python.interpreter} -m unittest discover tests/ '*test.py'

     

       27
       27
       +
       

     

       28
       28
       +
           runHook postCheck

     

       29
       29
       +
         '';

     

       30
       30
       +
       

     

       31
       31
       +
         meta = with lib; {

     

       32
       32
       +
           description = "Wikipedia API for Python";

     

       33
       33
       +
           homepage = https://github.com/goldsmith/Wikipedia;

     

       34
       34
       +
           license = licenses.mit;

     

       35
       35
       +
           maintainers = [ maintainers.worldofpeace ];

     

       36
       36
       +
         };

     

       37
       37
       +
       }

+21

pkgs/development/tools/analysis/evmdis/default.nix

···

       1
       1
       +
       { stdenv, buildGoPackage, fetchFromGitHub }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildGoPackage rec {

     

       4
       4
       +
         name = "evmdis-unstable-${version}";

     

       5
       5
       +
         version = "2018-03-23";

     

       6
       6
       +
         goPackagePath = "github.com/Arachnid/evmdis";

     

       7
       7
       +
       

     

       8
       8
       +
         src = fetchFromGitHub {

     

       9
       9
       +
           owner = "Arachnid";

     

       10
       10
       +
           repo = "evmdis";

     

       11
       11
       +
           rev = "0d1406905c5fda6224651fa53260a21c907eb986";

     

       12
       12
       +
           sha256 = "09y4j7ipgv8yd99g3xk3f079w8fqfj7kl1y7ry81ainysn0qlqrg";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         meta = with stdenv.lib; {

     

       16
       16
       +
           homepage = https://github.com/Arachnid/evmdis;

     

       17
       17
       +
           description = "Ethereum EVM disassembler";

     

       18
       18
       +
           license = [ licenses.asl20 ];

     

       19
       19
       +
           maintainers = with maintainers; [ asymmetric ];

     

       20
       20
       +
         };

     

       21
       21
       +
       }

+3 -3

pkgs/development/tools/build-managers/sbt-extras/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, which, curl, makeWrapper, jdk }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         rev = "a9f2e2592d069313329971930d1740943d19ef91";

     

       5
       5
       -
         version = "2019-01-30";

     

       4
       4
       +
         rev = "a47a965e00ecd66793832e2a12a1972d25e6f734";

     

       5
       5
       +
         version = "2019-04-05";

     

       6
       6
        
       in

     

       7
       7
        
       stdenv.mkDerivation {

     

       8
       8
        
         name = "sbt-extras-${version}";

     
···

       12
       12
        
           owner = "paulp";

     

       13
       13
        
           repo = "sbt-extras";

     

       14
       14
        
           inherit rev;

     

       15
       15
       -
           sha256 = "1kkpsd3fb8lm631bwjj41x4i9a5m88y2f3flzs918y12bjkli8ji";

     

       15
       15
       +
           sha256 = "1hrz7kg0k2iqq18bg6ll2bdj487p0987880dz0c0g35ah70ps2hj";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         dontBuild = true;

+4 -4

pkgs/development/tools/database/timescaledb-parallel-copy/default.nix

···

       1
       1
        
       { stdenv, buildGoPackage, fetchFromGitHub }:

     

       2
       2
        
       

     

       3
       3
        
       buildGoPackage rec {

     

       4
       4
       -
         name = "timescaledb-parallel-copy-${version}";

     

       5
       5
       -
         version = "2018-05-14";

     

       4
       4
       +
         name = "timescaledb-parallel-copy";

     

       5
       5
       +
         version = "0.2.0";

     

       6
       6
        
       

     

       7
       7
        
         owner  = "timescale";

     

       8
       8
        
         repo   = "timescaledb-parallel-copy";

     
···

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           inherit owner repo;

     

       15
       15
       -
           rev    = "20d3e8f8219329f2f4b0a5aa985f280dd04d10bb";

     

       16
       16
       -
           sha256 = "0waaccw991cnxaxjdxh9ksb94kiiyx1r7gif6pkd5k58js0kfvdn";

     

       15
       15
       +
           rev    = version;

     

       16
       16
       +
           sha256 = "1z9vf29vrxqs8imbisv681d02p4cfk3hlsrin6hhibxf1h0br9gd";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         meta = with stdenv.lib; {

+5 -5

pkgs/development/tools/database/timescaledb-parallel-copy/deps.nix

···

       1
       1
       -
       # This file was generated by https://github.com/kamilchm/go2nix v1.2.1

     

       1
       1
       +
       # This file was generated by https://github.com/kamilchm/go2nix v1.3.0

     

       2
       2
        
       [

     

       3
       3
        
         {

     

       4
       4
        
           goPackagePath = "github.com/jmoiron/sqlx";

     

       5
       5
        
           fetch = {

     

       6
       6
        
             type = "git";

     

       7
       7
        
             url = "https://github.com/jmoiron/sqlx";

     

       8
       8
       -
             rev = "0dae4fefe7c0e190f7b5a78dac28a1c82cc8d849";

     

       9
       9
       -
             sha256 = "0r8fyj70n0v84byvagw8w8rzz532s94mjr72b9sx018j0b6xglmy";

     

       8
       8
       +
             rev = "82935fac6c1a317907c8f43ed3f7f85ea844a78b";

     

       9
       9
       +
             sha256 = "0cbscnss2ifc3qgmy97i0zbirrp4hix4jlcz853f4bg5n2zzgwh2";

     

       10
       10
        
           };

     

       11
       11
        
         }

     

       12
       12
        
         {

     
···

       14
       14
        
           fetch = {

     

       15
       15
        
             type = "git";

     

       16
       16
        
             url = "https://github.com/lib/pq";

     

       17
       17
       -
             rev = "90697d60dd844d5ef6ff15135d0203f65d2f53b8";

     

       18
       18
       -
             sha256 = "0hb4bfsk8g5473yzbf3lzrb373xicakjznkf0v085xgimz991i9r";

     

       17
       17
       +
             rev = "7aad666537ab32b76f0966145530335f1fed51fd";

     

       18
       18
       +
             sha256 = "12qczn5afbf6203wnbpay1kazzh20jg5qyakrph3j1r13n91nc1r";

     

       19
       19
        
           };

     

       20
       20
        
         }

     

       21
       21
        
       ]

+24

pkgs/development/tools/database/timescaledb-tune/default.nix

···

       1
       1
       +
       { stdenv, buildGoPackage, fetchFromGitHub }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildGoPackage rec {

     

       4
       4
       +
         name = "timescaledb-tune";

     

       5
       5
       +
         version = "0.5.0";

     

       6
       6
       +
       

     

       7
       7
       +
         goPackagePath = "github.com/timescale/timescaledb-tune";

     

       8
       8
       +
       

     

       9
       9
       +
         goDeps = ./deps.nix;

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchFromGitHub {

     

       12
       12
       +
           owner = "timescale";

     

       13
       13
       +
           repo = name;

     

       14
       14
       +
           rev = version;

     

       15
       15
       +
           sha256 = "1fs7ggpdik3qjvjmair1svni2sw9wz54716m2iwngv8x4s9b15nn";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         meta = with stdenv.lib; {

     

       19
       19
       +
           description = "A tool for tuning your TimescaleDB for better performance";

     

       20
       20
       +
           homepage = https://github.com/timescale/timescaledb-tune;

     

       21
       21
       +
           license = licenses.asl20;

     

       22
       22
       +
           maintainers = with maintainers; [ marsam ];

     

       23
       23
       +
         };

     

       24
       24
       +
       }

+21

pkgs/development/tools/database/timescaledb-tune/deps.nix

···

       1
       1
       +
       # This file was generated by https://github.com/kamilchm/go2nix v1.3.0

     

       2
       2
       +
       [

     

       3
       3
       +
         {

     

       4
       4
       +
           goPackagePath = "github.com/fatih/color";

     

       5
       5
       +
           fetch = {

     

       6
       6
       +
             type = "git";

     

       7
       7
       +
             url = "https://github.com/fatih/color";

     

       8
       8
       +
             rev = "3f9d52f7176a6927daacff70a3e8d1dc2025c53e";

     

       9
       9
       +
             sha256 = "165ww24x6ba47ji4j14mp3f006ksnmi53ws9280pgd2zcw91nbn8";

     

       10
       10
       +
           };

     

       11
       11
       +
         }

     

       12
       12
       +
         {

     

       13
       13
       +
           goPackagePath = "github.com/pbnjay/memory";

     

       14
       14
       +
           fetch = {

     

       15
       15
       +
             type = "git";

     

       16
       16
       +
             url = "https://github.com/pbnjay/memory";

     

       17
       17
       +
             rev = "974d429e7ae40c89e7dcd41cfcc22a0bfbe42510";

     

       18
       18
       +
             sha256 = "0kazg5psdn90pqadrzma5chdwh0l2by9z31sspr47gx93fhjmkkq";

     

       19
       19
       +
           };

     

       20
       20
       +
         }

     

       21
       21
       +
       ]

+6 -6

pkgs/development/tools/electron/default.nix

···

       1
       1
        
       { stdenv, libXScrnSaver, makeWrapper, fetchurl, unzip, atomEnv, libuuid, at-spi2-atk }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         version = "4.1.4";

     

       4
       4
       +
         version = "4.1.5";

     

       5
       5
        
         name = "electron-${version}";

     

       6
       6
        
       

     

       7
       7
        
         throwSystem = throw "Unsupported system: ${stdenv.hostPlatform.system}";

     
···

       19
       19
        
           src = {

     

       20
       20
        
             i686-linux = fetchurl {

     

       21
       21
        
               url = "https://github.com/electron/electron/releases/download/v${version}/electron-v${version}-linux-ia32.zip";

     

       22
       22
       -
               sha256 = "0z1pr85mdw8c7vdsvznhixzmqmy3s6rrjaybym76c93hdvkr2ir9";

     

       22
       22
       +
               sha256 = "0rqaydlg7wkccks7crwpylad0bsz8knm82mpb7hnj68p9njxpsbz";

     

       23
       23
        
             };

     

       24
       24
        
             x86_64-linux = fetchurl {

     

       25
       25
        
               url = "https://github.com/electron/electron/releases/download/v${version}/electron-v${version}-linux-x64.zip";

     

       26
       26
       -
               sha256 = "05lyq67paad4h4ng39h8bwkv84bmy6axbxh60fmvl6l1x55dsan6";

     

       26
       26
       +
               sha256 = "0xwvn41pvpsrx54waix8kmg3w1f1f9nmfn08hf9bkgnlgh251shy";

     

       27
       27
        
             };

     

       28
       28
        
             armv7l-linux = fetchurl {

     

       29
       29
        
               url = "https://github.com/electron/electron/releases/download/v${version}/electron-v${version}-linux-armv7l.zip";

     

       30
       30
       -
               sha256 = "1ddc9b6h29qdqxnkc4vd6y5iah9i3f5i7v5zjb5b61rssz78wdbq";

     

       30
       30
       +
               sha256 = "172yq2m4i0pf72xr6w3xgkxfakkx2wrc54aah5j3nr6809bcnzji";

     

       31
       31
        
             };

     

       32
       32
        
             aarch64-linux = fetchurl {

     

       33
       33
        
               url = "https://github.com/electron/electron/releases/download/v${version}/electron-v${version}-linux-arm64.zip";

     

       34
       34
       -
               sha256 = "0qha5klws8l2i0grmwjiz34srr66h93lpx1j0lsgz3pxjxhc33xs";

     

       34
       34
       +
               sha256 = "0gcgvgplg9c2sm53sa4nll4x486c4m190ma9a98xfx9mp9vy55vq";

     

       35
       35
        
             };

     

       36
       36
        
           }.${stdenv.hostPlatform.system} or throwSystem;

     

       37
       37
        
       

     
···

       59
       59
        
       

     

       60
       60
        
           src = fetchurl {

     

       61
       61
        
             url = "https://github.com/electron/electron/releases/download/v${version}/electron-v${version}-darwin-x64.zip";

     

       62
       62
       -
             sha256 = "0zbgrwphd1xfkzqai8n7mi9vpzqflq4wwwnl4pdryrkyi3k4yxa6";

     

       62
       62
       +
             sha256 = "1z43ga620rw84x1yxvnxf11pd782s5vgj5dgnn4k0nfgxlihy058";

     

       63
       63
        
           };

     

       64
       64
        
       

     

       65
       65
        
           buildInputs = [ unzip ];

+3 -3

pkgs/development/tools/java/cfr/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "cfr-${version}";

     

       5
       5
       -
         version = "0.140";

     

       5
       5
       +
         version = "0.143";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url = "http://www.benf.org/other/cfr/cfr_${version}.jar";

     

       9
       9
       -
           sha256 = "0pgja3inhwikis80zwa58x5y51xg7pp1ji63n1xsab8ciyca52if";

     

       9
       9
       +
           sha256 = "129ab79xavrk0bwkmpvl56f74hyl1phfgbgz86cbij8bpvhhljyz";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
       -
         buildInputs = [ makeWrapper ];

     

       12
       12
       +
         nativeBuildInputs = [ makeWrapper ];

     

       13
       13
        
       

     

       14
       14
        
         buildCommand = ''

     

       15
       15
        
           jar=$out/share/java/cfr_${version}.jar

+2 -2

pkgs/development/tools/pipenv/default.nix

···

       15
       15
        
           flake8

     

       16
       16
        
           invoke

     

       17
       17
        
           parver

     

       18
       18
       -
           pew

     

       19
       18
        
           pip

     

       20
       19
        
           requests

     

       20
       20
       +
           virtualenv

     

       21
       21
        
         ];

     

       22
       22
        
       

     

       23
       23
        
         doCheck = false;

     

       24
       24
        
       

     

       25
       25
        
         makeWrapperArgs = [

     

       26
       26
       -
           "--set PYTHONPATH \"$PYTHONPATH\""

     

       26
       26
       +
           "--set PYTHONPATH \".:$PYTHONPATH\""

     

       27
       27
        
           "--set PIP_IGNORE_INSTALLED 1"

     

       28
       28
        
         ];

     

       29
       29

+7 -7

pkgs/development/tools/rust/bindgen/default.nix

···

       2
       2
        
         runtimeShell }:

     

       3
       3
        
       

     

       4
       4
        
       rustPlatform.buildRustPackage rec {

     

       5
       5
       -
         name = "rust-bindgen-${version}";

     

       6
       6
       -
         version = "0.42.2";

     

       5
       5
       +
         pname = "rust-bindgen";

     

       6
       6
       +
         version = "0.49.0";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
       -
           owner = "rust-lang-nursery";

     

       10
       10
       -
           repo = "rust-bindgen";

     

       9
       9
       +
           owner = "rust-lang";

     

       10
       10
       +
           repo = pname;

     

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

     

       12
       12
       -
           sha256 = "10h0h7x8yf4dsyw2p2nas2jg5p3i29np0y3rfzrdq898d70gvq4j";

     

       12
       12
       +
           sha256 = "0i1lh8z0jpf8gcfqxig8kl6wzjrkwb3jkad5ghb6ppkdkpr94jq4";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
       -
         cargoSha256 = "01jvi86xgz0r7ia9agnfpms6b6x68lzwj6f085m0w659i94acgpi";

     

       15
       15
       +
         cargoSha256 = "0v3slbah0s1w75s38x1akvshcxsi1s810yybd9faday7biwmdbmj";

     

       16
       16
        
       

     

       17
       17
        
         libclang = llvmPackages.libclang.lib; #for substituteAll

     

       18
       18
        
       

     
···

       56
       56
        
             As with most compiler related software, this will only work

     

       57
       57
        
             inside a nix-shell with the required libraries as buildInputs.

     

       58
       58
        
           '';

     

       59
       59
       -
           homepage = https://github.com/rust-lang-nursery/rust-bindgen;

     

       59
       59
       +
           homepage = https://github.com/rust-lang/rust-bindgen;

     

       60
       60
        
           license = with licenses; [ bsd3 ];

     

       61
       61
        
           maintainers = [ maintainers.ralith ];

     

       62
       62
        
         };

+23

pkgs/development/tools/rust/cargo-sweep/default.nix

···

       1
       1
       +
       { stdenv, rustPlatform, fetchFromGitHub }:

     

       2
       2
       +
       

     

       3
       3
       +
       rustPlatform.buildRustPackage rec {

     

       4
       4
       +
         pname = "cargo-sweep";

     

       5
       5
       +
         version = "0.4.1";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "holmgr";

     

       9
       9
       +
           repo = pname;

     

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

     

       11
       11
       +
           sha256 = "1zp0x0jy5bjqbxawlwvpj6vb3y602mnh19p48rw70kdx6vripbvj";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         cargoSha256 = "06hx8mlqarjnqrprwdp80cmanmacg3xz62r1bbn27pn60xv719hn";

     

       15
       15
       +
       

     

       16
       16
       +
         meta = with stdenv.lib; {

     

       17
       17
       +
           description = "A Cargo subcommand for cleaning up unused build files generated by Cargo";

     

       18
       18
       +
           homepage = https://github.com/holmgr/cargo-sweep;

     

       19
       19
       +
           license = licenses.mit;

     

       20
       20
       +
           platforms = platforms.all;

     

       21
       21
       +
           maintainers = with maintainers; [ xrelkd ];

     

       22
       22
       +
         };

     

       23
       23
       +
       }

+10 -6

pkgs/development/tools/rust/rls/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, rustPlatform

     

       2
       2
       -
       , openssh, openssl, pkgconfig, cmake, zlib, curl }:

     

       2
       2
       +
       , openssh, openssl, pkgconfig, cmake, zlib, curl, libiconv }:

     

       3
       3
        
       

     

       4
       4
        
       rustPlatform.buildRustPackage rec {

     

       5
       5
        
         name = "rls-${version}";

     

       6
       6
        
         # with rust 1.x you can only build rls version 1.x.y

     

       7
       7
       -
         version = "1.31.7";

     

       7
       7
       +
         version = "1.34.0";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchFromGitHub {

     

       10
       10
        
           owner = "rust-lang";

     

       11
       11
        
           repo = "rls";

     

       12
       12
       -
           rev = version;

     

       13
       13
       -
           sha256 = "0n33pf7sm31y55rllb8wv3mn75srspr4yj2y6cpcdyf15n47c8cf";

     

       12
       12
       +
           rev = "0d6f53e1a4adbaf7d83cdc0cb54720203fcb522e";

     

       13
       13
       +
           sha256 = "1aabs0kr87sp68n9893im5wz21dicip9ixir9a9l56nis4qxpm7i";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
       -
         cargoSha256 = "0jcsggq4ay8f4vb8n6gh8z995icvvbjkzapxf6jq6qkg6jp3vv17";

     

       16
       16
       +
         cargoSha256 = "16r9rmjhb0dbdgx9qf740nsckjazz4z663vaajw5z9i4qh0jsy18";

     

       17
       17
        
       

     

       18
       18
        
         # a nightly compiler is required unless we use this cheat code.

     

       19
       19
        
         RUSTC_BOOTSTRAP=1;

     
···

       22
       22
        
         cargoBuildFlags = [ "--no-default-features" ];

     

       23
       23
        
       

     

       24
       24
        
         nativeBuildInputs = [ pkgconfig cmake ];

     

       25
       25
       -
         buildInputs = [ openssh openssl curl zlib ];

     

       25
       25
       +
         buildInputs = [ openssh openssl curl zlib libiconv ];

     

       26
       26
        
       

     

       27
       27
        
         doCheck = true;

     

       28
       28
        
         # the default checkPhase has no way to pass --no-default-features

     

       29
       29
        
         checkPhase = ''

     

       30
       30
        
           runHook preCheck

     

       31
       31
       +
       

     

       32
       32
       +
           # client tests are flaky

     

       33
       33
       +
           rm tests/client.rs

     

       34
       34
       +
       

     

       31
       35
        
           echo "Running cargo test"

     

       32
       36
        
           cargo test --no-default-features

     

       33
       37
        
           runHook postCheck

+15 -4

pkgs/games/crawl/default.nix

···

       1
       1
       -
       { stdenv, lib, fetchFromGitHub, which, sqlite, lua5_1, perl, python3, zlib, pkgconfig, ncurses

     

       1
       1
       +
       { stdenv, lib, fetchFromGitHub, fetchpatch, which, sqlite, lua5_1, perl, python3, zlib, pkgconfig, ncurses

     

       2
       2
        
       , dejavu_fonts, libpng, SDL2, SDL2_image, SDL2_mixer, libGLU_combined, freetype, pngcrush, advancecomp

     

       3
       3
        
       , tileMode ? false, enableSound ? tileMode

     

       4
       4
        
       }:

     
···

       14
       14
        
           sha256 = "1d6mip4rvp81839yf2xm63hf34aza5wg4g5z5hi5275j94szaacs";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         # Patch hard-coded paths in the makefile

     

       18
       18
       -
         patches = [ ./crawl_purify.patch ];

     

       17
       17
       +
         patches = [

     

       18
       18
       +
           ./crawl_purify.patch  # Patch hard-coded paths

     

       19
       19
       +
           (fetchpatch {         # Use a nice high-res app icon

     

       20
       20
       +
             url = "https://github.com/crawl/crawl/commit/2aa1166087e44e6585b26cedf1fe81b3f3ba547f.patch";

     

       21
       21
       +
             sha256 = "1jqrdv4wy18shg1fdabdb421232hg5micphkixcyzxd1lrmvadg0";

     

       22
       22
       +
           })

     

       23
       23
       +
         ];

     

       19
       24
        
       

     

       20
       25
        
         nativeBuildInputs = [ pkgconfig which perl pngcrush advancecomp ];

     

       21
       26
        
       

     
···

       40
       45
        
                     ] ++ lib.optional tileMode "TILES=y"

     

       41
       46
        
                       ++ lib.optional enableSound "SOUND=y";

     

       42
       47
        
       

     

       43
       43
       -
         postInstall = lib.optionalString tileMode "mv $out/bin/crawl $out/bin/crawl-tiles";

     

       48
       48
       +
         postInstall = ''

     

       49
       49
       +
           ${lib.optionalString tileMode "mv $out/bin/crawl $out/bin/crawl-tiles"}

     

       50
       50
       +
           sed -i 's#/usr/games/##' debian/crawl${lib.optionalString tileMode "-tiles"}.desktop

     

       51
       51
       +
           install -m 444 -D debian/crawl${lib.optionalString tileMode "-tiles"}.desktop \

     

       52
       52
       +
             $out/share/applications/crawl${lib.optionalString tileMode "-tiles"}.desktop

     

       53
       53
       +
           install -m 444 -D dat/tiles/stone_soup_icon-512x512.png $out/share/icons/hicolor/512x512/apps/crawl.png

     

       54
       54
       +
         '';

     

       44
       55
        
       

     

       45
       56
        
         enableParallelBuilding = true;

     

       46
       57

+9 -4

pkgs/games/torcs/default.nix

···

       12
       12
        
       

     

       13
       13
        
         patches = [

     

       14
       14
        
           (fetchpatch {

     

       15
       15
       -
             url = "https://salsa.debian.org/games-team/torcs/raw/master/debian/patches/gcc6-isnan.patch";

     

       15
       15
       +
             url = "https://salsa.debian.org/games-team/torcs/raw/fb0711c171b38c4648dc7c048249ec20f79eb8e2/debian/patches/gcc6-isnan.patch";

     

       16
       16
        
             sha256 = "16scmq30vwb8429ah9d4ws0v1w6ai59lvn7hcgnvfzyap42ry876";

     

       17
       17
        
           })

     

       18
       18
        
           (fetchpatch {

     

       19
       19
       -
             url = "https://salsa.debian.org/games-team/torcs/raw/master/debian/patches/format-argument.patch";

     

       19
       19
       +
             url = "https://salsa.debian.org/games-team/torcs/raw/fb0711c171b38c4648dc7c048249ec20f79eb8e2/debian/patches/format-argument.patch";

     

       20
       20
        
             sha256 = "04advcx88yh23ww767iysydzhp370x7cqp2wf9hk2y1qvw7mxsja";

     

       21
       21
        
           })

     

       22
       22
        
           (fetchpatch {

     

       23
       23
       -
             url = "https://salsa.debian.org/games-team/torcs/raw/master/debian/patches/glibc-default-source.patch";

     

       23
       23
       +
             url = "https://salsa.debian.org/games-team/torcs/raw/fb0711c171b38c4648dc7c048249ec20f79eb8e2/debian/patches/glibc-default-source.patch";

     

       24
       24
        
             sha256 = "0k4hgpddnhv68mdc9ics7ah8q54j60g394d7zmcmzg6l3bjd9pyp";

     

       25
       25
        
           })

     

       26
       26
       +
           (fetchpatch {

     

       27
       27
       +
             url = "https://salsa.debian.org/games-team/torcs/raw/32bbe77c68b4de07b28c34497f3c0ad666ee618d/debian/patches/gcc7.patch";

     

       28
       28
       +
             sha256 = "09iilnvdv8h7b4nb1372arszkbz9hbzsck4rimzz1xjdh9ydniw9";

     

       29
       29
       +
           })

     

       26
       30
        
         ];

     

       27
       31
        
       

     

       28
       32
        
         postPatch = ''

     

       29
       33
        
           sed -i -e s,/bin/bash,`type -P bash`, src/linux/torcs.in

     

       30
       34
        
         '';

     

       31
       35
        
       

     

       36
       36
       +
         nativeBuildInputs = [ makeWrapper ];

     

       32
       37
        
         buildInputs = [ libGLU freeglut libX11 plib openal freealut libXrandr xorgproto

     

       33
       33
       -
           libXext libSM libICE libXi libXt libXrender libXxf86vm libpng zlib libvorbis makeWrapper ];

     

       38
       38
       +
           libXext libSM libICE libXi libXt libXrender libXxf86vm libpng zlib libvorbis ];

     

       34
       39
        
       

     

       35
       40
        
         installTargets = "install datainstall";

     

       36
       41

pkgs/misc/tmux-plugins/default.nix

···

       230
       230
        
       

     

       231
       231
        
         vim-tmux-navigator = mkDerivation {

     

       232
       232
        
           pluginName = "vim-tmux-navigator";

     

       233
       233
       +
           rtpFilePath = "vim-tmux-navigator.tmux";

     

       233
       234
        
           src = fetchgit {

     

       234
       235
        
             url = "https://github.com/christoomey/vim-tmux-navigator";

     

       235
       236
        
             rev = "4e1a877f51a17a961b8c2a285ee80aebf05ccf42";

pkgs/misc/uboot/default.nix

···

       120
       120
        
           filesToInstall = ["u-boot-sunxi-with-spl.bin"];

     

       121
       121
        
         };

     

       122
       122
        
       

     

       123
       123
       +
         ubootBananaPim64 = buildUBoot rec {

     

       124
       124
       +
           defconfig = "bananapi_m64_defconfig";

     

       125
       125
       +
           extraMeta.platforms = ["aarch64-linux"];

     

       126
       126
       +
           BL31 = "${armTrustedFirmwareAllwinner}/bl31.bin";

     

       127
       127
       +
           filesToInstall = ["u-boot-sunxi-with-spl.bin"];

     

       128
       128
       +
         };

     

       129
       129
       +
       

     

       123
       130
        
         ubootBeagleboneBlack = buildUBoot rec {

     

       124
       131
        
           defconfig = "am335x_boneblack_defconfig";

     

       125
       132
        
           extraMeta.platforms = ["armv7l-linux"];

+2 -2

pkgs/os-specific/linux/cifs-utils/default.nix

···

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         name = "cifs-utils-${version}";

     

       6
       6
       -
         version = "6.8";

     

       6
       6
       +
         version = "6.9";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           url = "mirror://samba/pub/linux-cifs/cifs-utils/${name}.tar.bz2";

     

       10
       10
       -
           sha256 = "0ygz3pagjpaj5ky11hzh4byyymb7fpmqiqkprn11zwj31h2zdlg7";

     

       10
       10
       +
           sha256 = "175cp509wn1zv8p8mv37hkf6sxiskrsxdnq22mhlsg61jazz3n0q";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         nativeBuildInputs = [ autoreconfHook docutils pkgconfig ];

+2 -2

pkgs/os-specific/linux/fwts/default.nix

···

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         name = "fwts-${version}";

     

       6
       6
       -
         version = "19.02.00";

     

       6
       6
       +
         version = "19.03.00";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchzip {

     

       9
       9
        
           url = "http://fwts.ubuntu.com/release/fwts-V${version}.tar.gz";

     

       10
       10
       -
           sha256 = "1rjyfscchman9ih0473hgzvfzrvkfwl5bjf7c9ksr3d9plz3n7ad";

     

       10
       10
       +
           sha256 = "1zri73qmpgc0dwmdcfbcywcvxld7dqz7rkwwqncfkvvfc9zchk5l";

     

       11
       11
        
           stripRoot = false;

     

       12
       12
        
         };

     

       13
       13

+12

pkgs/os-specific/linux/kernel/i2c-oops.patch

···

       1
       1
       +
       diff --git a/drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c b/drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c

     

       2
       2
       +
       index 1d645c9ab417bf..cac262a912c124 100644

     

       3
       3
       +
       --- a/drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c

     

       4
       4
       +
       +++ b/drivers/hid/i2c-hid/i2c-hid-dmi-quirks.c

     

       5
       5
       +
       @@ -337,7 +337,8 @@ static const struct dmi_system_id i2c_hid_dmi_desc_override_table[] = {

     

       6
       6
       +
       			DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "FlexBook edge11 - M-FBE11"),

     

       7
       7
       +
       		},

     

       8
       8
       +
       		.driver_data = (void *)&sipodev_desc

     

       9
       9
       +
       -	}

     

       10
       10
       +
       +	},

     

       11
       11
       +
       +	{ }	/* Terminate list */

     

       12
       12
       +
        };

+3 -3

pkgs/os-specific/linux/kernel/linux-rpi.nix

···

       1
       1
        
       { stdenv, lib, buildPackages, fetchFromGitHub, perl, buildLinux, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         modDirVersion = "4.14.70";

     

       5
       5
       -
         tag = "1.20180919";

     

       4
       4
       +
         modDirVersion = "4.14.98";

     

       5
       5
       +
         tag = "1.20190215";

     

       6
       6
        
       in

     

       7
       7
        
       lib.overrideDerivation (buildLinux (args // rec {

     

       8
       8
        
         version = "${modDirVersion}-${tag}";

     
···

       12
       12
        
           owner = "raspberrypi";

     

       13
       13
        
           repo = "linux";

     

       14
       14
        
           rev = "raspberrypi-kernel_${tag}-1";

     

       15
       15
       -
           sha256 = "1zjvzk6rhrn3ngc012gjq3v7lxn8hy89ljb7fqwld5g7py9lkf0b";

     

       15
       15
       +
           sha256 = "1gc4x7p82m2v1jhahhyl7qfdkflj71ly6p0fpc1vf9sk13hbwgj2";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         defconfig = {

+14 -5

pkgs/os-specific/linux/kernel/linux-testing-bcachefs.nix

···

       1
       1
       -
       { stdenv, buildPackages, fetchgit, perl, buildLinux, ... } @ args:

     

       1
       1
       +
       { stdenv, buildPackages, fetchgit, fetchpatch, perl, buildLinux, ... } @ args:

     

       2
       2
        
       

     

       3
       3
        
       buildLinux (args // rec {

     

       4
       4
       -
         version = "4.20.2019.03.13";

     

       5
       5
       -
         modDirVersion = "4.20.0";

     

       4
       4
       +
         version = "5.0.2019.04.04";

     

       5
       5
       +
         modDirVersion = "5.0.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchgit {

     

       8
       8
        
           url = "https://evilpiepirate.org/git/bcachefs.git";

     

       9
       9
       -
           rev = "986543d24e08a0c0308472403b230d546e7ecbbb";

     

       10
       10
       -
           sha256 = "07h9l47wijhlx3xnyxnj8kv1zb9yf2x0gag8n606yq6wn9r523hv";

     

       9
       9
       +
           rev = "d83b992f653d9f742f3f8567dbcfd1f4f72e858f";

     

       10
       10
       +
           sha256 = "17xipjhkl4arshyj3riwq4pgl2qqcnlfhaga77a430wy22s7plh2";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         extraConfig = "BCACHEFS_FS m";

     

       14
       14
       +
       

     

       15
       15
       +
         kernelPatches = [

     

       16
       16
       +
           { name = "export-bio_iov_iter_get_pages";

     

       17
       17
       +
             patch = fetchpatch {

     

       18
       18
       +
               name = "export-bio_iov_iter_get_pages.patch";

     

       19
       19
       +
               url = "https://evilpiepirate.org/git/bcachefs.git/patch/?id=bd8be01aa04eb9cc33fcdce89ac6e0fac0ae0fcf";

     

       20
       20
       +
               sha256 = "0h5z98krx8077wwhiqp3bwc1h4nwnifxsn8mpxr2lcxnqmky3hz0";

     

       21
       21
       +
             }; }

     

       22
       22
       +
         ];

     

       14
       23
        
       

     

       15
       24
        
         extraMeta = {

     

       16
       25
        
           branch = "master";

pkgs/os-specific/linux/kernel/patches.nix

···

       57
       57
        
             sha256 = "1l8xq02rd7vakxg52xm9g4zng0ald866rpgm8kjlh88mwwyjkrwv";

     

       58
       58
        
           };

     

       59
       59
        
         };

     

       60
       60
       +
       

     

       61
       61
       +
         # Fix kernel OOPS on boot: https://github.com/NixOS/nixpkgs/issues/60126

     

       62
       62
       +
         # Remove with the next release.

     

       63
       63
       +
         i2c-oops = { name = "i2c-oops"; patch = ./i2c-oops.patch; };

     

       60
       64
        
       }

+1 -1

pkgs/os-specific/linux/kexectools/default.nix

···

       15
       15
        
         hardeningDisable = [ "format" "pic" "relro" "pie" ];

     

       16
       16
        
       

     

       17
       17
        
         configureFlags = [ "BUILD_CC=${buildPackages.stdenv.cc.targetPrefix}cc" ];

     

       18
       18
       -
         nativeBuildInputs = [ buildPackages.stdenv.cc ];

     

       18
       18
       +
         depsBuildBuild = [ buildPackages.stdenv.cc ];

     

       19
       19
        
         buildInputs = [ zlib ];

     

       20
       20
        
       

     

       21
       21
        
         meta = with stdenv.lib; {

+7 -10

pkgs/os-specific/linux/mxu11x0/default.nix

···

       1
       1
       -
       { stdenv, fetchFromGitHub, kernel }:

     

       1
       1
       +
       { stdenv, fetchurl, kernel }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation {

     

       4
       4
       -
         name = "mxu11x0-1.3.11+git2017-07-13-${kernel.version}";

     

       4
       4
       +
         name = "mxu11x0-1.4-${kernel.version}";

     

       5
       5
        
       

     

       6
       6
       -
         src = fetchFromGitHub {

     

       7
       7
       -
           owner = "ellysh";

     

       8
       8
       -
           repo = "mxu11x0";

     

       9
       9
       -
           rev = "cbbb5ec2045939209117cb5fcd6c7c23bcc109ef";

     

       10
       10
       -
           sha256 = "0wf44pnz5aclvg2k1f8ljnwws8hh6191i5h06nz95ijbxhwz63w4";

     

       6
       6
       +
         src = fetchurl {

     

       7
       7
       +
           url = "https://www.moxa.com/Moxa/media/PDIM/S100000385/moxa-uport-1000-series-linux-3.x-and-4.x-for-uport-11x0-series-driver-v1.4.tgz";

     

       8
       8
       +
           sha256 = "1hz9ygabbp8pv49k1j4qcsr0v3zw9xy0bh1akqgxp5v29gbdgxjl";

     

       11
       9
        
         };

     

       12
       10
        
       

     

       13
       11
        
         preBuild = ''

     
···

       30
       28
        
       

     

       31
       29
        
         meta = with stdenv.lib; {

     

       32
       30
        
           description = "MOXA UPort 11x0 USB to Serial Hub driver";

     

       33
       33
       -
           homepage = https://github.com/ellysh/mxu11x0;

     

       34
       34
       -
           license = licenses.gpl1;

     

       31
       31
       +
           homepage = https://www.moxa.com/en/products/industrial-edge-connectivity/usb-to-serial-converters-usb-hubs/usb-to-serial-converters/uport-1000-series;

     

       32
       32
       +
           license = licenses.gpl2Plus;

     

       35
       33
        
           maintainers = with maintainers; [ uralbash ];

     

       36
       34
        
           platforms = platforms.linux;

     

       37
       37
       -
           broken = versionOlder kernel.version "4.9" || !versionOlder kernel.version "4.13";

     

       38
       35
        
         };

     

       39
       36
        
       }

+4 -4

pkgs/os-specific/linux/sysdig/default.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, cmake, kernel

     

       2
       2
       -
       , luajit, zlib, ncurses, perl, jsoncpp, libb64, openssl, curl, jq, gcc, elfutils, tbb

     

       2
       2
       +
       , luajit, zlib, ncurses, perl, jsoncpp, libb64, openssl, curl, jq, gcc, elfutils, tbb, c-ares, protobuf, grpc

     

       3
       3
        
       }:

     

       4
       4
        
       

     

       5
       5
        
       with stdenv.lib;

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
        
         name = "sysdig-${version}";

     

       8
       8
       -
         version = "0.24.2";

     

       8
       8
       +
         version = "0.25";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "draios";

     

       12
       12
        
           repo = "sysdig";

     

       13
       13
        
           rev = version;

     

       14
       14
       -
           sha256 = "16gz6gcp0zfhrqldw9cms38w0x5h3qhlx64dayqgsqbkw914b31a";

     

       14
       14
       +
           sha256 = "1591jz4fmgk5r3q410h771nzhv6wfqpnr7pn34kpc5rl0vhky37m";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         nativeBuildInputs = [ cmake perl ];

     

       18
       18
        
         buildInputs = [

     

       19
       19
       -
           zlib luajit ncurses jsoncpp libb64 openssl curl jq gcc elfutils tbb

     

       19
       19
       +
           zlib luajit ncurses jsoncpp libb64 openssl curl jq gcc elfutils tbb c-ares protobuf grpc

     

       20
       20
        
         ] ++ optional (kernel != null) kernel.moduleBuildDependencies;

     

       21
       21
        
       

     

       22
       22
        
         hardeningDisable = [ "pic" ];

+2 -10

pkgs/os-specific/linux/wpa_supplicant/default.nix

···

       4
       4
        
       

     

       5
       5
        
       with stdenv.lib;

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
       -
         version = "2.7";

     

       7
       7
       +
         version = "2.8";

     

       8
       8
        
       

     

       9
       9
        
         name = "wpa_supplicant-${version}";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchurl {

     

       12
       12
        
           url = "https://w1.fi/releases/${name}.tar.gz";

     

       13
       13
       -
           sha256 = "0x1hqyahq44jyla8jl6791nnwrgicrhidadikrnqxsm2nw36pskn";

     

       13
       13
       +
           sha256 = "15ixzm347n8w6gdvi3j3yks3i15qmp6by9ayvswm34d929m372d6";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         # TODO: Patch epoll so that the dbus actually responds

     
···

       80
       80
        
         buildInputs = [ openssl libnl dbus readline pcsclite ];

     

       81
       81
        
       

     

       82
       82
        
         nativeBuildInputs = [ pkgconfig ];

     

       83
       83
       -
       

     

       84
       84
       -
         patches = [

     

       85
       85
       -
           (fetchpatch {

     

       86
       86
       -
             name = "build-fix.patch";

     

       87
       87
       -
             url = "https://gitweb.gentoo.org/repo/gentoo.git/plain/net-wireless/wpa_supplicant/files/wpa_supplicant-2.7-fix-undefined-remove-ie.patch?id=e0288112138a70a8acc3ae0196772fd7ccb677ce";

     

       88
       88
       -
             sha256 = "0ysazfcyn195mvkb1v10mgzzmpmqgv5kwqxwzfbsfhzq5bbaihld";

     

       89
       89
       -
           })

     

       90
       90
       -
         ];

     

       91
       83
        
       

     

       92
       84
        
         postInstall = ''

     

       93
       85
        
           mkdir -p $out/share/man/man5 $out/share/man/man8

+12 -8

pkgs/servers/dex/default.nix

···

       1
       1
        
       { lib, buildGoPackage, fetchFromGitHub }:

     

       2
       2
        
       

     

       3
       3
       -
       let version = "2.4.1"; in

     

       4
       4
       -
       

     

       5
       3
        
       buildGoPackage rec {

     

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

     

       4
       4
       +
         pname = "dex";

     

       5
       5
       +
         version = "2.16.0";

     

       7
       6
        
       

     

       8
       8
       -
         goPackagePath = "github.com/coreos/dex";

     

       7
       7
       +
         goPackagePath = "github.com/dexidp/dex";

     

       9
       8
        
       

     

       10
       9
        
         src = fetchFromGitHub {

     

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

     

       12
       12
       -
           owner = "coreos";

     

       13
       13
       -
           repo = "dex";

     

       14
       14
       -
           sha256 = "11qpn3wh74mq16xgl9l50n2v02ffqcd14xccf77j5il04xr764nx";

     

       11
       11
       +
           owner = "dexidp";

     

       12
       12
       +
           repo = pname;

     

       13
       13
       +
           sha256 = "0w8nl7inqp4grbaq320dgynmznbrln8vihd799dwb2cx86laxsi1";

     

       15
       14
        
         };

     

       16
       15
        
       

     

       17
       16
        
         subPackages = [

     
···

       22
       21
        
           "-ldflags=-w -X ${goPackagePath}/version.Version=${src.rev}"

     

       23
       22
        
         ];

     

       24
       23
        
       

     

       24
       24
       +
         postInstall = ''

     

       25
       25
       +
           mkdir -p $out/share

     

       26
       26
       +
           cp -r go/src/${goPackagePath}/web $out/share/web

     

       27
       27
       +
         '';

     

       28
       28
       +
       

     

       25
       29
        
         meta = {

     

       26
       30
        
           description = "OpenID Connect and OAuth2 identity provider with pluggable connectors";

     

       27
       31
        
           license = lib.licenses.asl20;

     

       28
       28
       -
           homepage = https://github.com/coreos/dex;

     

       32
       32
       +
           homepage = https://github.com/dexidp/dex;

     

       29
       33
        
           maintainers = with lib.maintainers; [benley];

     

       30
       34
        
           platforms = lib.platforms.unix;

     

       31
       35
        
         };

+2 -2

pkgs/servers/dns/bind/default.nix

···

       8
       8
        
       assert enableSeccomp -> libseccomp != null;

     

       9
       9
        
       assert enablePython -> python3 != null;

     

       10
       10
        
       

     

       11
       11
       -
       let version = "9.12.3-P4"; in

     

       11
       11
       +
       let version = "9.12.4-P1"; in

     

       12
       12
        
       

     

       13
       13
        
       stdenv.mkDerivation rec {

     

       14
       14
        
         name = "bind-${version}";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchurl {

     

       17
       17
        
           url = "https://ftp.isc.org/isc/bind9/${version}/${name}.tar.gz";

     

       18
       18
       -
           sha256 = "01pj47z5582rd538dmbzf1msw4jc8j4zr0zx4ciy88r6qr9l80fi";

     

       18
       18
       +
           sha256 = "1if7zc5gzrfd28csc63v9bjwrc0rgvm1x9yx058946hc5gp5lyp2";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         outputs = [ "out" "lib" "dev" "man" "dnsutils" "host" ];

+2 -2

pkgs/servers/monitoring/cadvisor/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "cadvisor-${version}";

     

       5
       5
       -
         version = "0.33.0";

     

       5
       5
       +
         version = "0.33.1";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "google";

     

       9
       9
        
           repo = "cadvisor";

     

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

     

       11
       11
       -
           sha256 = "14v4xjycr34kvilidhhavc8yvhkxb7mxc9qd56jd1x2c42lfna8k";

     

       11
       11
       +
           sha256 = "15wddg0xwkz42n5y2f72yq3imhbvnp83g1jq6p81ddw9qzbz62zs";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ go ];

+89 -68

pkgs/servers/plex/default.nix

···

       1
       1
       -
       { config, stdenv, fetchurl, rpmextract, glibc

     

       2
       2
       -
       , dataDir ? "/var/lib/plex" # Plex's data directory must be baked into the package due to symlinks.

     

       3
       3
       -
       , enablePlexPass ? config.plex.enablePlexPass or false

     

       1
       1
       +
       # The actual Plex package that we run is a FHS userenv of the "raw" package.

     

       2
       2
       +
       { stdenv

     

       3
       3
       +
       , buildFHSUserEnv

     

       4
       4
       +
       , writeScript

     

       5
       5
       +
       , plexRaw

     

       6
       6
       +
       

     

       7
       7
       +
       # Old argument for overriding the Plex data directory; isn't necessary for this

     

       8
       8
       +
       # version of Plex to function, but still around for backwards-compatibility.

     

       9
       9
       +
       , dataDir ? "/var/lib/plex"

     

       4
       10
        
       }:

     

       5
       11
        
       

     

       6
       6
       -
       let

     

       7
       7
       -
         plexPass = throw "Plex pass has been removed at upstream's request; please unset nixpkgs.config.plex.pass";

     

       8
       8
       -
         plexpkg = if enablePlexPass then plexPass else {

     

       9
       9
       -
           version = "1.15.3.876";

     

       10
       10
       -
           vsnHash = "ad6e39743";

     

       11
       11
       -
           sha256 = "01g7wccm01kg3nhf3qrmwcn20nkpv0bqz6zqv2gq5v03ps58h6g5";

     

       12
       12
       -
         };

     

       12
       12
       +
       buildFHSUserEnv rec {

     

       13
       13
       +
         name = "plexmediaserver";

     

       14
       14
       +
         inherit (plexRaw) meta;

     

       15
       15
       +
       

     

       16
       16
       +
         # This script is run when we start our Plex binary

     

       17
       17
       +
         runScript = writeScript "plex-run-script" ''

     

       18
       18
       +
           #!${stdenv.shell}

     

       19
       19
       +
       

     

       20
       20
       +
           set -eu

     

       21
       21
       +
       

     

       22
       22
       +
           # The root path to our Plex installation

     

       23
       23
       +
           root=${plexRaw}/lib/plexmediaserver

     

       24
       24
       +
       

     

       25
       25
       +
           # Path to where we're storing our Plex data files. We default to storing

     

       26
       26
       +
           # them in the user's home directory under the XDG-compatible location, but

     

       27
       27
       +
           # allow overriding with an environment variable so the location can be

     

       28
       28
       +
           # configured in our NixOS module.

     

       29
       29
       +
           #

     

       30
       30
       +
           # NOTE: the old version of Plex used /var/lib/plex as the default location,

     

       31
       31
       +
           # but this package shouldn't assume that we're going to run Plex with the

     

       32
       32
       +
           # ability to write to /var/lib, so using a subdirectory of $HOME when none

     

       33
       33
       +
           # is specified feels less likely to have permission errors.

     

       34
       34
       +
           if [[ -z "''${PLEX_DATADIR:-}" ]]; then

     

       35
       35
       +
             PLEX_DATADIR="$HOME/.local/share/plex"

     

       36
       36
       +
           fi

     

       37
       37
       +
           if [[ ! -d "$PLEX_DATADIR" ]]; then

     

       38
       38
       +
             echo "Creating Plex data directory: $PLEX_DATADIR"

     

       39
       39
       +
             mkdir -p "$PLEX_DATADIR"

     

       40
       40
       +
           fi

     

       13
       41
        
       

     

       14
       14
       -
       in stdenv.mkDerivation rec {

     

       15
       15
       -
         name = "plex-${version}";

     

       16
       16
       -
         version = plexpkg.version;

     

       17
       17
       -
         vsnHash = plexpkg.vsnHash;

     

       18
       18
       -
         sha256 = plexpkg.sha256;

     

       42
       42
       +
           # The database is stored under the given directory

     

       43
       43
       +
           db="$PLEX_DATADIR/.skeleton/com.plexapp.plugins.library.db"

     

       44
       44
       +
       

     

       45
       45
       +
           # If we don't have a database in the expected path, then create one by

     

       46
       46
       +
           # copying our base database to that location.

     

       47
       47
       +
           if ! test -f "$db"; then

     

       48
       48
       +
             echo "Copying base database file to: $db"

     

       49
       49
       +
             mkdir -p "$(dirname "$db")"

     

       50
       50
       +
             cat "${plexRaw.basedb}" > "$db"

     

       51
       51
       +
           fi

     

       52
       52
       +
       

     

       53
       53
       +
           # Set up symbolic link at '/db', which is linked to by our Plex package

     

       54
       54
       +
           # (see the 'plexRaw' package).

     

       55
       55
       +
           ln -s "$db" /db

     

       19
       56
        
       

     

       20
       20
       -
         src = fetchurl {

     

       21
       21
       -
           url = "https://downloads.plex.tv/plex-media-server-new/${version}-${vsnHash}/redhat/plexmediaserver-${version}-${vsnHash}.x86_64.rpm";

     

       22
       22
       -
           inherit sha256;

     

       23
       23
       -
         };

     

       57
       57
       +
           # If we have a plugin list (set by our NixOS module), we create plugins in

     

       58
       58
       +
           # the data directory as expected. This is a colon-separated list of paths.

     

       59
       59
       +
           if [[ -n "''${PLEX_PLUGINS:-}" ]]; then

     

       60
       60
       +
             echo "Preparing plugin directory"

     

       24
       61
        
       

     

       25
       25
       -
         buildInputs = [ rpmextract glibc ];

     

       62
       62
       +
             pluginDir="$PLEX_DATADIR/Plex Media Server/Plug-ins"

     

       63
       63
       +
             test -d "$pluginDir" || mkdir -p "$pluginDir"

     

       26
       64
        
       

     

       27
       27
       -
         phases = [ "unpackPhase" "installPhase" "fixupPhase" "distPhase" ];

     

       65
       65
       +
             # First, remove all of the symlinks in the plugins directory.

     

       66
       66
       +
             echo "Removing old symlinks"

     

       67
       67
       +
             for f in $(ls "$pluginDir/"); do

     

       68
       68
       +
               if [[ -L "$pluginDir/$f" ]]; then

     

       69
       69
       +
                 echo "Removing plugin symlink: $pluginDir/$f"

     

       70
       70
       +
                 rm "$pluginDir/$f"

     

       71
       71
       +
               fi

     

       72
       72
       +
             done

     

       28
       73
        
       

     

       29
       29
       -
         unpackPhase = ''

     

       30
       30
       -
           rpmextract $src

     

       31
       31
       -
         '';

     

       74
       74
       +
             echo "Symlinking plugins"

     

       75
       75
       +
             IFS=':' read -ra pluginsArray <<< "$PLEX_PLUGINS"

     

       76
       76
       +
             for path in "''${pluginsArray[@]}"; do

     

       77
       77
       +
               dest="$pluginDir/$(basename "$path")"

     

       32
       78
        
       

     

       33
       33
       -
         installPhase = ''

     

       34
       34
       -
           install -d $out/usr/lib

     

       35
       35
       -
           cp -dr --no-preserve='ownership' usr/lib/plexmediaserver $out/usr/lib/

     

       79
       79
       +
               if [[ ! -d "$path" ]]; then

     

       80
       80
       +
                 echo "Error symlinking plugin from $path: no such directory"

     

       81
       81
       +
               elif [[ -d "$dest" || -L "$dest" ]]; then

     

       82
       82
       +
                 echo "Error symlinking plugin from $path to $dest: file or directory already exists"

     

       83
       83
       +
               else

     

       84
       84
       +
                 echo "Symlinking plugin at: $path"

     

       85
       85
       +
                 ln -s "$path" "$dest"

     

       86
       86
       +
               fi

     

       87
       87
       +
             done

     

       88
       88
       +
           fi

     

       36
       89
        
       

     

       37
       37
       -
           # Now we need to patch up the executables and libraries to work on Nix.

     

       38
       38
       -
           # Side note: PLEASE don't put spaces in your binary names. This is stupid.

     

       39
       39
       -
           for bin in "Plex Media Server"              \

     

       40
       40
       -
                      "Plex Commercial Skipper"        \

     

       41
       41
       -
                      "Plex DLNA Server"               \

     

       42
       42
       -
                      "Plex Media Scanner"             \

     

       43
       43
       -
                      "Plex Relay"                     \

     

       44
       44
       -
                      "Plex Script Host"               \

     

       45
       45
       -
                      "Plex Transcoder"                \

     

       46
       46
       -
                      "Plex Tuner Service"             ; do

     

       47
       47
       -
             patchelf --set-interpreter "${glibc.out}/lib/ld-linux-x86-64.so.2" "$out/usr/lib/plexmediaserver/$bin"

     

       48
       48
       -
             patchelf --set-rpath "$out/usr/lib/plexmediaserver/lib" "$out/usr/lib/plexmediaserver/$bin"

     

       49
       49
       -
           done

     

       90
       90
       +
           # Tell Plex to use the data directory as the "Application Support"

     

       91
       91
       +
           # directory, otherwise it tries to write things into the user's home

     

       92
       92
       +
           # directory.

     

       93
       93
       +
           export PLEX_MEDIA_SERVER_APPLICATION_SUPPORT_DIR="$PLEX_DATADIR"

     

       50
       94
        
       

     

       51
       51
       -
           find $out/usr/lib/plexmediaserver/Resources -type f -a -perm -0100 \

     

       52
       52
       -
               -print -exec patchelf --set-interpreter "${glibc.out}/lib/ld-linux-x86-64.so.2" '{}' \;

     

       95
       95
       +
           # Tell Plex where the 'home' directory for itself is.

     

       96
       96
       +
           export PLEX_MEDIA_SERVER_HOME="${plexRaw}/lib/plexmediaserver"

     

       53
       97
        
       

     

       54
       54
       -
           # Our next problem is the "Resources" directory in /usr/lib/plexmediaserver.

     

       55
       55
       -
           # This is ostensibly a skeleton directory, which contains files that Plex

     

       56
       56
       -
           # copies into its folder in /var. Unfortunately, there are some SQLite

     

       57
       57
       -
           # databases in the directory that are opened at startup. Since these

     

       58
       58
       -
           # database files are read-only, SQLite chokes and Plex fails to start. To

     

       59
       59
       -
           # solve this, we keep the resources directory in the Nix store, but we

     

       60
       60
       -
           # rename the database files and replace the originals with symlinks to

     

       61
       61
       -
           # /var/lib/plex. Then, in the systemd unit, the base database files are

     

       62
       62
       -
           # copied to /var/lib/plex before starting Plex.

     

       63
       63
       -
           RSC=$out/usr/lib/plexmediaserver/Resources

     

       64
       64
       -
           for db in "com.plexapp.plugins.library.db"; do

     

       65
       65
       -
               mv $RSC/$db $RSC/base_$db

     

       66
       66
       -
               ln -s "${dataDir}/.skeleton/$db" $RSC/$db

     

       67
       67
       -
           done

     

       98
       98
       +
           # Actually run Plex, prepending LD_LIBRARY_PATH with the libraries from

     

       99
       99
       +
           # the Plex package.

     

       100
       100
       +
           LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$root exec "$root/Plex Media Server"

     

       68
       101
        
         '';

     

       69
       69
       -
       

     

       70
       70
       -
         meta = with stdenv.lib; {

     

       71
       71
       -
           homepage = https://plex.tv/;

     

       72
       72
       -
           license = licenses.unfree;

     

       73
       73
       -
           platforms = platforms.linux;

     

       74
       74
       -
           maintainers = with stdenv.lib.maintainers; [ colemickens forkk thoughtpolice pjones lnl7 ];

     

       75
       75
       -
           description = "Media / DLNA server";

     

       76
       76
       -
           longDescription = ''

     

       77
       77
       -
             Plex is a media server which allows you to store your media and play it

     

       78
       78
       -
             back across many different devices.

     

       79
       79
       -
           '';

     

       80
       80
       -
         };

     

       81
       102
        
       }

+70

pkgs/servers/plex/raw.nix

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , fetchurl

     

       3
       3
       +
       , rpmextract

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       # The raw package that fetches and extracts the Plex RPM. Override the source

     

       7
       7
       +
       # and version of this derivation if you want to use a Plex Pass version of the

     

       8
       8
       +
       # server, and the FHS userenv and corresponding NixOS module should

     

       9
       9
       +
       # automatically pick up the changes.

     

       10
       10
       +
       stdenv.mkDerivation rec {

     

       11
       11
       +
         version = "1.15.3.876-ad6e39743";

     

       12
       12
       +
         pname = "plexmediaserver";

     

       13
       13
       +
         name = "${pname}-${version}";

     

       14
       14
       +
       

     

       15
       15
       +
         # Fetch the source

     

       16
       16
       +
         src = fetchurl {

     

       17
       17
       +
           url = "https://downloads.plex.tv/plex-media-server-new/${version}/redhat/plexmediaserver-${version}.x86_64.rpm";

     

       18
       18
       +
           sha256 = "01g7wccm01kg3nhf3qrmwcn20nkpv0bqz6zqv2gq5v03ps58h6g5";

     

       19
       19
       +
         };

     

       20
       20
       +
       

     

       21
       21
       +
         outputs = [ "out" "basedb" ];

     

       22
       22
       +
       

     

       23
       23
       +
         nativeBuildInputs = [ rpmextract ];

     

       24
       24
       +
       

     

       25
       25
       +
         phases = [ "unpackPhase" "installPhase" "fixupPhase" "distPhase" ];

     

       26
       26
       +
       

     

       27
       27
       +
         unpackPhase = ''

     

       28
       28
       +
           rpmextract $src

     

       29
       29
       +
         '';

     

       30
       30
       +
       

     

       31
       31
       +
         installPhase = ''

     

       32
       32
       +
           mkdir -p "$out/lib"

     

       33
       33
       +
           cp -dr --no-preserve='ownership' usr/lib/plexmediaserver $out/lib/

     

       34
       34
       +
       

     

       35
       35
       +
           # Location of the initial Plex plugins database

     

       36
       36
       +
           f=$out/lib/plexmediaserver/Resources/com.plexapp.plugins.library.db

     

       37
       37
       +
       

     

       38
       38
       +
           # Store the base database in the 'basedb' output

     

       39
       39
       +
           cat $f > $basedb

     

       40
       40
       +
       

     

       41
       41
       +
           # Overwrite the base database in the Plex package with an absolute symlink

     

       42
       42
       +
           # to the '/db' file; we create this path in the FHS userenv (see the "plex"

     

       43
       43
       +
           # package).

     

       44
       44
       +
           ln -fs /db $f

     

       45
       45
       +
         '';

     

       46
       46
       +
       

     

       47
       47
       +
         # We're running in a FHS userenv; don't patch anything

     

       48
       48
       +
         dontPatchShebangs = true;

     

       49
       49
       +
         dontStrip = true;

     

       50
       50
       +
         dontPatchELF = true;

     

       51
       51
       +
         dontAutoPatchelf = true;

     

       52
       52
       +
       

     

       53
       53
       +
         meta = with stdenv.lib; {

     

       54
       54
       +
           homepage = https://plex.tv/;

     

       55
       55
       +
           license = licenses.unfree;

     

       56
       56
       +
           platforms = platforms.linux;

     

       57
       57
       +
           maintainers = with maintainers; [

     

       58
       58
       +
             colemickens

     

       59
       59
       +
             forkk

     

       60
       60
       +
             lnl7

     

       61
       61
       +
             pjones

     

       62
       62
       +
             thoughtpolice

     

       63
       63
       +
           ];

     

       64
       64
       +
           description = "Media library streaming server";

     

       65
       65
       +
           longDescription = ''

     

       66
       66
       +
             Plex is a media server which allows you to store your media and play it

     

       67
       67
       +
             back across many different devices.

     

       68
       68
       +
           '';

     

       69
       69
       +
         };

     

       70
       70
       +
       }

+3 -3

pkgs/servers/sql/postgresql/ext/plv8.nix

···

       1
       1
        
       { stdenv, fetchFromGitHub, v8, perl, postgresql }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "plv8-${version}";

     

       5
       5
       -
         version = "2.3.8";

     

       4
       4
       +
         pname = "plv8";

     

       5
       5
       +
         version = "2.3.11";

     

       6
       6
        
       

     

       7
       7
        
         nativeBuildInputs = [ perl ];

     

       8
       8
        
         buildInputs = [ v8 postgresql ];

     
···

       11
       11
        
           owner = "plv8";

     

       12
       12
        
           repo = "plv8";

     

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

     

       14
       14
       -
           sha256 = "0hrmn1zzzdf52zwldg6axv57p0f3b279l9s8lbpijcv60fqrzx16";

     

       14
       14
       +
           sha256 = "0bv2b8xxdqqhj6nwyc8kwhi5m5i7i1yl078sk3bnnc84b0mnza5x";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         makeFlags = [ "--makefile=Makefile.shared" ];

+4 -4

pkgs/servers/sql/postgresql/ext/timescaledb.nix

···

       8
       8
        
       

     

       9
       9
        
       stdenv.mkDerivation rec {

     

       10
       10
        
         name = "timescaledb-${version}";

     

       11
       11
       -
         version = "1.0.0";

     

       11
       11
       +
         version = "1.2.2";

     

       12
       12
        
       

     

       13
       13
        
         nativeBuildInputs = [ cmake ];

     

       14
       14
        
         buildInputs = [ postgresql openssl ];

     
···

       17
       17
        
           owner  = "timescale";

     

       18
       18
        
           repo   = "timescaledb";

     

       19
       19
        
           rev    = "refs/tags/${version}";

     

       20
       20
       -
           sha256 = "1359jc0dw8q3f0iipqfadzs8lvri9qa5w59ziz00x1d09ppw2q40";

     

       20
       20
       +
           sha256 = "1fb1ab07jmgd1drinl25mbhwx966f75c7i7nh3ah0xf3cbk298xr";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         # Fix the install phase which tries to install into the pgsql extension dir,

     
···

       28
       28
        
               --replace 'DESTINATION "''${PG_SHAREDIR}/extension"' "DESTINATION \"$out/share/extension\""

     

       29
       29
        
           done

     

       30
       30
        
       

     

       31
       31
       -
           for x in src/CMakeLists.txt src/loader/CMakeLists.txt; do

     

       31
       31
       +
           for x in src/CMakeLists.txt src/loader/CMakeLists.txt tsl/src/CMakeLists.txt; do

     

       32
       32
        
             substituteInPlace "$x" \

     

       33
       33
        
               --replace 'DESTINATION ''${PG_PKGLIBDIR}' "DESTINATION \"$out/lib\""

     

       34
       34
        
           done

     
···

       45
       45
        
           description = "Scales PostgreSQL for time-series data via automatic partitioning across time and space";

     

       46
       46
        
           homepage    = https://www.timescale.com/;

     

       47
       47
        
           maintainers = with maintainers; [ volth ];

     

       48
       48
       -
           platforms   = platforms.linux;

     

       48
       48
       +
           platforms   = postgresql.meta.platforms;

     

       49
       49
        
           license     = licenses.asl20;

     

       50
       50
        
         };

     

       51
       51
        
       }

+4 -7

pkgs/shells/rush/default.nix

···

       1
       1
        
       { fetchurl, stdenv }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         name = "rush-1.8";

     

       4
       4
       +
         pname = "rush";

     

       5
       5
       +
         version = "1.9";

     

       5
       6
        
       

     

       6
       7
        
         src = fetchurl {

     

       7
       7
       -
           url = "mirror://gnu/rush/${name}.tar.gz";

     

       8
       8
       -
           sha256 = "1vxdb81ify4xcyygh86250pi50krb16dkj42i5ii4ns3araiwckz";

     

       8
       8
       +
           url = "mirror://gnu/${pname}/${pname}-${version}.tar.gz";

     

       9
       9
       +
           sha256 = "12x7dyi9vl3lwlv618156nzpi5s0li93wcx2c26h4z7la20yq2yk";

     

       9
       10
        
         };

     

       10
       10
       -
       

     

       11
       11
       -
         patches = [ ./fix-format-security-error.patch

     

       12
       12
       -
           ./intprops.patch

     

       13
       13
       -
         ];

     

       14
       11
        
       

     

       15
       12
        
         doCheck = true;

     

       16
       13

-12

pkgs/shells/rush/fix-format-security-error.patch

···

       1
       1
       -
       diff -Nur rush-1.8.orig/lib/wordsplit.c rush-1.8/lib/wordsplit.c

     

       2
       2
       -
       --- rush-1.8.orig/lib/wordsplit.c	2016-08-18 20:11:43.000000000 +0200

     

       3
       3
       -
       +++ rush-1.8/lib/wordsplit.c	2016-11-14 14:37:02.976177414 +0100

     

       4
       4
       -
       @@ -2330,7 +2330,7 @@

     

       5
       5
       -
              break;

     

       6
       6
       -
        

     

       7
       7
       -
            default:

     

       8
       8
       -
       -      wsp->ws_error (wordsplit_strerror (wsp));

     

       9
       9
       -
       +      wsp->ws_error ("%s", wordsplit_strerror (wsp));

     

       10
       10
       -
            }

     

       11
       11
       -
        }

     

       12
       12
       -

-257

pkgs/shells/rush/intprops.patch

···

       1
       1
       -
       Description: Update to latest intprops.h from gnulib, fixes FTBFS with gcc 7

     

       2
       2
       -
       Author: Adrian Bunk <bunk@debian.org>

     

       3
       3
       -
       Bug-Debian: https://bugs.debian.org/853649

     

       4
       4
       -
       

     

       5
       5
       -
       --- rush-1.8+dfsg.orig/gnu/intprops.h

     

       6
       6
       -
       +++ rush-1.8+dfsg/gnu/intprops.h

     

       7
       7
       -
       @@ -1,20 +1,18 @@

     

       8
       8
       -
       -/* -*- buffer-read-only: t -*- vi: set ro: */

     

       9
       9
       -
       -/* DO NOT EDIT! GENERATED AUTOMATICALLY! */

     

       10
       10
       -
        /* intprops.h -- properties of integer types

     

       11
       11
       -
        

     

       12
       12
       -
       -   Copyright (C) 2001-2016 Free Software Foundation, Inc.

     

       13
       13
       -
       +   Copyright (C) 2001-2017 Free Software Foundation, Inc.

     

       14
       14
       -
        

     

       15
       15
       -
           This program is free software: you can redistribute it and/or modify it

     

       16
       16
       -
       -   under the terms of the GNU General Public License as published

     

       17
       17
       -
       -   by the Free Software Foundation; either version 3 of the License, or

     

       18
       18
       -
       +   under the terms of the GNU Lesser General Public License as published

     

       19
       19
       -
       +   by the Free Software Foundation; either version 2.1 of the License, or

     

       20
       20
       -
           (at your option) any later version.

     

       21
       21
       -
        

     

       22
       22
       -
           This program is distributed in the hope that it will be useful,

     

       23
       23
       -
           but WITHOUT ANY WARRANTY; without even the implied warranty of

     

       24
       24
       -
           MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     

       25
       25
       -
       -   GNU General Public License for more details.

     

       26
       26
       -
       +   GNU Lesser General Public License for more details.

     

       27
       27
       -
        

     

       28
       28
       -
       -   You should have received a copy of the GNU General Public License

     

       29
       29
       -
       +   You should have received a copy of the GNU Lesser General Public License

     

       30
       30
       -
           along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

     

       31
       31
       -
        

     

       32
       32
       -
        /* Written by Paul Eggert.  */

     

       33
       33
       -
       @@ -23,7 +21,6 @@

     

       34
       34
       -
        #define _GL_INTPROPS_H

     

       35
       35
       -
        

     

       36
       36
       -
        #include <limits.h>

     

       37
       37
       -
       -#include <verify.h>

     

       38
       38
       -
        

     

       39
       39
       -
        /* Return a value with the common real type of E and V and the value of V.  */

     

       40
       40
       -
        #define _GL_INT_CONVERT(e, v) (0 * (e) + (v))

     

       41
       41
       -
       @@ -49,12 +46,16 @@

     

       42
       42
       -
        

     

       43
       43
       -
        /* Minimum and maximum values for integer types and expressions.  */

     

       44
       44
       -
        

     

       45
       45
       -
       +/* The width in bits of the integer type or expression T.

     

       46
       46
       -
       +   Padding bits are not supported; this is checked at compile-time below.  */

     

       47
       47
       -
       +#define TYPE_WIDTH(t) (sizeof (t) * CHAR_BIT)

     

       48
       48
       -
       +

     

       49
       49
       -
        /* The maximum and minimum values for the integer type T.  */

     

       50
       50
       -
        #define TYPE_MINIMUM(t) ((t) ~ TYPE_MAXIMUM (t))

     

       51
       51
       -
        #define TYPE_MAXIMUM(t)                                                 \

     

       52
       52
       -
          ((t) (! TYPE_SIGNED (t)                                               \

     

       53
       53
       -
                ? (t) -1                                                        \

     

       54
       54
       -
       -        : ((((t) 1 << (sizeof (t) * CHAR_BIT - 2)) - 1) * 2 + 1)))

     

       55
       55
       -
       +        : ((((t) 1 << (TYPE_WIDTH (t) - 2)) - 1) * 2 + 1)))

     

       56
       56
       -
        

     

       57
       57
       -
        /* The maximum and minimum values for the type of the expression E,

     

       58
       58
       -
           after integer promotion.  E should not have side effects.  */

     

       59
       59
       -
       @@ -67,29 +68,23 @@

     

       60
       60
       -
           ? _GL_SIGNED_INT_MAXIMUM (e)                                         \

     

       61
       61
       -
           : _GL_INT_NEGATE_CONVERT (e, 1))

     

       62
       62
       -
        #define _GL_SIGNED_INT_MAXIMUM(e)                                       \

     

       63
       63
       -
       -  (((_GL_INT_CONVERT (e, 1) << (sizeof ((e) + 0) * CHAR_BIT - 2)) - 1) * 2 + 1)

     

       64
       64
       -
       +  (((_GL_INT_CONVERT (e, 1) << (TYPE_WIDTH ((e) + 0) - 2)) - 1) * 2 + 1)

     

       65
       65
       -
       +

     

       66
       66
       -
       +/* Work around OpenVMS incompatibility with C99.  */

     

       67
       67
       -
       +#if !defined LLONG_MAX && defined __INT64_MAX

     

       68
       68
       -
       +# define LLONG_MAX __INT64_MAX

     

       69
       69
       -
       +# define LLONG_MIN __INT64_MIN

     

       70
       70
       -
       +#endif

     

       71
       71
       -
        

     

       72
       72
       -
        /* This include file assumes that signed types are two's complement without

     

       73
       73
       -
           padding bits; the above macros have undefined behavior otherwise.

     

       74
       74
       -
           If this is a problem for you, please let us know how to fix it for your host.

     

       75
       75
       -
       -   As a sanity check, test the assumption for some signed types that

     

       76
       76
       -
       -   <limits.h> bounds.  */

     

       77
       77
       -
       -verify (TYPE_MINIMUM (signed char) == SCHAR_MIN);

     

       78
       78
       -
       -verify (TYPE_MAXIMUM (signed char) == SCHAR_MAX);

     

       79
       79
       -
       -verify (TYPE_MINIMUM (short int) == SHRT_MIN);

     

       80
       80
       -
       -verify (TYPE_MAXIMUM (short int) == SHRT_MAX);

     

       81
       81
       -
       -verify (TYPE_MINIMUM (int) == INT_MIN);

     

       82
       82
       -
       -verify (TYPE_MAXIMUM (int) == INT_MAX);

     

       83
       83
       -
       -verify (TYPE_MINIMUM (long int) == LONG_MIN);

     

       84
       84
       -
       -verify (TYPE_MAXIMUM (long int) == LONG_MAX);

     

       85
       85
       -
       -#ifdef LLONG_MAX

     

       86
       86
       -
       -verify (TYPE_MINIMUM (long long int) == LLONG_MIN);

     

       87
       87
       -
       -verify (TYPE_MAXIMUM (long long int) == LLONG_MAX);

     

       88
       88
       -
       -#endif

     

       89
       89
       -
       +   This assumption is tested by the intprops-tests module.  */

     

       90
       90
       -
        

     

       91
       91
       -
        /* Does the __typeof__ keyword work?  This could be done by

     

       92
       92
       -
           'configure', but for now it's easier to do it by hand.  */

     

       93
       93
       -
       -#if (2 <= __GNUC__ || defined __IBM__TYPEOF__ \

     

       94
       94
       -
       +#if (2 <= __GNUC__ \

     

       95
       95
       -
       +     || (1210 <= __IBMC__ && defined __IBM__TYPEOF__) \

     

       96
       96
       -
             || (0x5110 <= __SUNPRO_C && !__STDC__))

     

       97
       97
       -
        # define _GL_HAVE___TYPEOF__ 1

     

       98
       98
       -
        #else

     

       99
       99
       -
       @@ -118,8 +113,7 @@ verify (TYPE_MAXIMUM (long long int) ==

     

       100
       100
       -
           signed, this macro may overestimate the true bound by one byte when

     

       101
       101
       -
           applied to unsigned types of size 2, 4, 16, ... bytes.  */

     

       102
       102
       -
        #define INT_STRLEN_BOUND(t)                                     \

     

       103
       103
       -
       -  (INT_BITS_STRLEN_BOUND (sizeof (t) * CHAR_BIT                 \

     

       104
       104
       -
       -                          - _GL_SIGNED_TYPE_OR_EXPR (t))        \

     

       105
       105
       -
       +  (INT_BITS_STRLEN_BOUND (TYPE_WIDTH (t) - _GL_SIGNED_TYPE_OR_EXPR (t)) \

     

       106
       106
       -
           + _GL_SIGNED_TYPE_OR_EXPR (t))

     

       107
       107
       -
        

     

       108
       108
       -
        /* Bound on buffer size needed to represent an integer type or expression T,

     

       109
       109
       -
       @@ -224,20 +218,27 @@ verify (TYPE_MAXIMUM (long long int) ==

     

       110
       110
       -
           ? (a) < (min) >> (b)                                 \

     

       111
       111
       -
           : (max) >> (b) < (a))

     

       112
       112
       -
        

     

       113
       113
       -
       -/* True if __builtin_add_overflow (A, B, P) works when P is null.  */

     

       114
       114
       -
       -#define _GL_HAS_BUILTIN_OVERFLOW_WITH_NULL (7 <= __GNUC__)

     

       115
       115
       -
       +/* True if __builtin_add_overflow (A, B, P) works when P is non-null.  */

     

       116
       116
       -
       +#if 5 <= __GNUC__ && !defined __ICC

     

       117
       117
       -
       +# define _GL_HAS_BUILTIN_OVERFLOW 1

     

       118
       118
       -
       +#else

     

       119
       119
       -
       +# define _GL_HAS_BUILTIN_OVERFLOW 0

     

       120
       120
       -
       +#endif

     

       121
       121
       -
       +

     

       122
       122
       -
       +/* True if __builtin_add_overflow_p (A, B, C) works.  */

     

       123
       123
       -
       +#define _GL_HAS_BUILTIN_OVERFLOW_P (7 <= __GNUC__)

     

       124
       124
       -
        

     

       125
       125
       -
        /* The _GL*_OVERFLOW macros have the same restrictions as the

     

       126
       126
       -
           *_RANGE_OVERFLOW macros, except that they do not assume that operands

     

       127
       127
       -
           (e.g., A and B) have the same type as MIN and MAX.  Instead, they assume

     

       128
       128
       -
           that the result (e.g., A + B) has that type.  */

     

       129
       129
       -
       -#if _GL_HAS_BUILTIN_OVERFLOW_WITH_NULL

     

       130
       130
       -
       -# define _GL_ADD_OVERFLOW(a, b, min, max)

     

       131
       131
       -
       -   __builtin_add_overflow (a, b, (__typeof__ ((a) + (b)) *) 0)

     

       132
       132
       -
       -# define _GL_SUBTRACT_OVERFLOW(a, b, min, max)

     

       133
       133
       -
       -   __builtin_sub_overflow (a, b, (__typeof__ ((a) - (b)) *) 0)

     

       134
       134
       -
       -# define _GL_MULTIPLY_OVERFLOW(a, b, min, max)

     

       135
       135
       -
       -   __builtin_mul_overflow (a, b, (__typeof__ ((a) * (b)) *) 0)

     

       136
       136
       -
       +#if _GL_HAS_BUILTIN_OVERFLOW_P

     

       137
       137
       -
       +# define _GL_ADD_OVERFLOW(a, b, min, max)                               \

     

       138
       138
       -
       +   __builtin_add_overflow_p (a, b, (__typeof__ ((a) + (b))) 0)

     

       139
       139
       -
       +# define _GL_SUBTRACT_OVERFLOW(a, b, min, max)                          \

     

       140
       140
       -
       +   __builtin_sub_overflow_p (a, b, (__typeof__ ((a) - (b))) 0)

     

       141
       141
       -
       +# define _GL_MULTIPLY_OVERFLOW(a, b, min, max)                          \

     

       142
       142
       -
       +   __builtin_mul_overflow_p (a, b, (__typeof__ ((a) * (b))) 0)

     

       143
       143
       -
        #else

     

       144
       144
       -
        # define _GL_ADD_OVERFLOW(a, b, min, max)                                \

     

       145
       145
       -
           ((min) < 0 ? INT_ADD_RANGE_OVERFLOW (a, b, min, max)                  \

     

       146
       146
       -
       @@ -317,7 +318,7 @@ verify (TYPE_MAXIMUM (long long int) ==

     

       147
       147
       -
          _GL_BINARY_OP_OVERFLOW (a, b, _GL_ADD_OVERFLOW)

     

       148
       148
       -
        #define INT_SUBTRACT_OVERFLOW(a, b) \

     

       149
       149
       -
          _GL_BINARY_OP_OVERFLOW (a, b, _GL_SUBTRACT_OVERFLOW)

     

       150
       150
       -
       -#if _GL_HAS_BUILTIN_OVERFLOW_WITH_NULL

     

       151
       151
       -
       +#if _GL_HAS_BUILTIN_OVERFLOW_P

     

       152
       152
       -
        # define INT_NEGATE_OVERFLOW(a) INT_SUBTRACT_OVERFLOW (0, a)

     

       153
       153
       -
        #else

     

       154
       154
       -
        # define INT_NEGATE_OVERFLOW(a) \

     

       155
       155
       -
       @@ -351,10 +352,6 @@ verify (TYPE_MAXIMUM (long long int) ==

     

       156
       156
       -
        #define INT_MULTIPLY_WRAPV(a, b, r) \

     

       157
       157
       -
          _GL_INT_OP_WRAPV (a, b, r, *, __builtin_mul_overflow, INT_MULTIPLY_OVERFLOW)

     

       158
       158
       -
        

     

       159
       159
       -
       -#ifndef __has_builtin

     

       160
       160
       -
       -# define __has_builtin(x) 0

     

       161
       161
       -
       -#endif

     

       162
       162
       -
       -

     

       163
       163
       -
        /* Nonzero if this compiler has GCC bug 68193 or Clang bug 25390.  See:

     

       164
       164
       -
           https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68193

     

       165
       165
       -
           https://llvm.org/bugs/show_bug.cgi?id=25390

     

       166
       166
       -
       @@ -371,17 +368,17 @@ verify (TYPE_MAXIMUM (long long int) ==

     

       167
       167
       -
           the operation.  BUILTIN is the builtin operation, and OVERFLOW the

     

       168
       168
       -
           overflow predicate.  Return 1 if the result overflows.  See above

     

       169
       169
       -
           for restrictions.  */

     

       170
       170
       -
       -#if 5 <= __GNUC__ || __has_builtin (__builtin_add_overflow)

     

       171
       171
       -
       +#if _GL_HAS_BUILTIN_OVERFLOW

     

       172
       172
       -
        # define _GL_INT_OP_WRAPV(a, b, r, op, builtin, overflow) builtin (a, b, r)

     

       173
       173
       -
        #elif 201112 <= __STDC_VERSION__ && !_GL__GENERIC_BOGUS

     

       174
       174
       -
        # define _GL_INT_OP_WRAPV(a, b, r, op, builtin, overflow) \

     

       175
       175
       -
           (_Generic \

     

       176
       176
       -
            (*(r), \

     

       177
       177
       -
             signed char: \

     

       178
       178
       -
       -       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned char, \

     

       179
       179
       -
       +       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \

     

       180
       180
       -
                                signed char, SCHAR_MIN, SCHAR_MAX), \

     

       181
       181
       -
             short int: \

     

       182
       182
       -
       -       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned short int, \

     

       183
       183
       -
       +       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \

     

       184
       184
       -
                                short int, SHRT_MIN, SHRT_MAX), \

     

       185
       185
       -
             int: \

     

       186
       186
       -
               _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \

     

       187
       187
       -
       @@ -395,10 +392,10 @@ verify (TYPE_MAXIMUM (long long int) ==

     

       188
       188
       -
        #else

     

       189
       189
       -
        # define _GL_INT_OP_WRAPV(a, b, r, op, builtin, overflow) \

     

       190
       190
       -
           (sizeof *(r) == sizeof (signed char) \

     

       191
       191
       -
       -    ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned char, \

     

       192
       192
       -
       +    ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \

     

       193
       193
       -
                               signed char, SCHAR_MIN, SCHAR_MAX) \

     

       194
       194
       -
            : sizeof *(r) == sizeof (short int) \

     

       195
       195
       -
       -    ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned short int, \

     

       196
       196
       -
       +    ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \

     

       197
       197
       -
                               short int, SHRT_MIN, SHRT_MAX) \

     

       198
       198
       -
            : sizeof *(r) == sizeof (int) \

     

       199
       199
       -
            ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \

     

       200
       200
       -
       @@ -414,15 +411,14 @@ verify (TYPE_MAXIMUM (long long int) ==

     

       201
       201
       -
        # else

     

       202
       202
       -
        #  define _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow) \

     

       203
       203
       -
            _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \

     

       204
       204
       -
       -                     long int, LONG_MIN, LONG_MAX))

     

       205
       205
       -
       +                     long int, LONG_MIN, LONG_MAX)

     

       206
       206
       -
        # endif

     

       207
       207
       -
        #endif

     

       208
       208
       -
        

     

       209
       209
       -
        /* Store the low-order bits of A <op> B into *R, where the operation

     

       210
       210
       -
           is given by OP.  Use the unsigned type UT for calculation to avoid

     

       211
       211
       -
       -   overflow problems.  *R's type is T, with extremal values TMIN and

     

       212
       212
       -
       -   TMAX.  T must be a signed integer type.  Return 1 if the result

     

       213
       213
       -
       -   overflows.  */

     

       214
       214
       -
       +   overflow problems.  *R's type is T, with extrema TMIN and TMAX.

     

       215
       215
       -
       +   T must be a signed integer type.  Return 1 if the result overflows.  */

     

       216
       216
       -
        #define _GL_INT_OP_CALC(a, b, r, op, overflow, ut, t, tmin, tmax) \

     

       217
       217
       -
          (sizeof ((a) op (b)) < sizeof (t) \

     

       218
       218
       -
           ? _GL_INT_OP_CALC1 ((t) (a), (t) (b), r, op, overflow, ut, t, tmin, tmax) \

     

       219
       219
       -
       @@ -431,17 +427,27 @@ verify (TYPE_MAXIMUM (long long int) ==

     

       220
       220
       -
          ((overflow (a, b) \

     

       221
       221
       -
            || (EXPR_SIGNED ((a) op (b)) && ((a) op (b)) < (tmin)) \

     

       222
       222
       -
            || (tmax) < ((a) op (b))) \

     

       223
       223
       -
       -   ? (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a, b, op, ut, t, tmin, tmax), 1) \

     

       224
       224
       -
       -   : (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a, b, op, ut, t, tmin, tmax), 0))

     

       225
       225
       -
       +   ? (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a, b, op, ut, t), 1) \

     

       226
       226
       -
       +   : (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a, b, op, ut, t), 0))

     

       227
       227
       -
       +

     

       228
       228
       -
       +/* Return the low-order bits of A <op> B, where the operation is given

     

       229
       229
       -
       +   by OP.  Use the unsigned type UT for calculation to avoid undefined

     

       230
       230
       -
       +   behavior on signed integer overflow, and convert the result to type T.

     

       231
       231
       -
       +   UT is at least as wide as T and is no narrower than unsigned int,

     

       232
       232
       -
       +   T is two's complement, and there is no padding or trap representations.

     

       233
       233
       -
       +   Assume that converting UT to T yields the low-order bits, as is

     

       234
       234
       -
       +   done in all known two's-complement C compilers.  E.g., see:

     

       235
       235
       -
       +   https://gcc.gnu.org/onlinedocs/gcc/Integers-implementation.html

     

       236
       236
       -
       +

     

       237
       237
       -
       +   According to the C standard, converting UT to T yields an

     

       238
       238
       -
       +   implementation-defined result or signal for values outside T's

     

       239
       239
       -
       +   range.  However, code that works around this theoretical problem

     

       240
       240
       -
       +   runs afoul of a compiler bug in Oracle Studio 12.3 x86.  See:

     

       241
       241
       -
       +   http://lists.gnu.org/archive/html/bug-gnulib/2017-04/msg00049.html

     

       242
       242
       -
       +   As the compiler bug is real, don't try to work around the

     

       243
       243
       -
       +   theoretical problem.  */

     

       244
       244
       -
        

     

       245
       245
       -
       -/* Return A <op> B, where the operation is given by OP.  Use the

     

       246
       246
       -
       -   unsigned type UT for calculation to avoid overflow problems.

     

       247
       247
       -
       -   Convert the result to type T without overflow by subtracting TMIN

     

       248
       248
       -
       -   from large values before converting, and adding it afterwards.

     

       249
       249
       -
       -   Compilers can optimize all the operations except OP.  */

     

       250
       250
       -
       -#define _GL_INT_OP_WRAPV_VIA_UNSIGNED(a, b, op, ut, t, tmin, tmax) \

     

       251
       251
       -
       -  (((ut) (a) op (ut) (b)) <= (tmax) \

     

       252
       252
       -
       -   ? (t) ((ut) (a) op (ut) (b)) \

     

       253
       253
       -
       -   : ((t) (((ut) (a) op (ut) (b)) - (tmin)) + (tmin)))

     

       254
       254
       -
       +#define _GL_INT_OP_WRAPV_VIA_UNSIGNED(a, b, op, ut, t) \

     

       255
       255
       -
       +  ((t) ((ut) (a) op (ut) (b)))

     

       256
       256
       -
        

     

       257
       257
       -
        #endif /* _GL_INTPROPS_H */

+3 -3

pkgs/shells/zsh/oh-my-zsh/default.nix

···

       4
       4
        
       { stdenv, fetchgit }:

     

       5
       5
        
       

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
       -
         version = "2019-04-22";

     

       7
       7
       +
         version = "2019-04-26";

     

       8
       8
        
         name = "oh-my-zsh-${version}";

     

       9
       9
       -
         rev = "f46476589aa092f75f5911fa4d6f65401a8d3577";

     

       9
       9
       +
         rev = "f5b2d9c7ce8ced5a4ec67a4ecfa877e6951124ef";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchgit { inherit rev;

     

       12
       12
        
           url = "https://github.com/robbyrussell/oh-my-zsh";

     

       13
       13
       -
           sha256 = "1zfqa39da867zxwsyms12qv4jxl1z7rgnr817hhh1xn62i4y41f2";

     

       13
       13
       +
           sha256 = "17d837kyw16g91cnmdpdvhl2sgi3cb7fzligwwzjyp0y7kbiy3n4";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         pathsToLink = [ "/share/oh-my-zsh" ];

+2 -2

pkgs/tools/X11/wpgtk/default.nix

···

       3
       3
        
       

     

       4
       4
        
       python3Packages.buildPythonApplication rec {

     

       5
       5
        
         pname = "wpgtk";

     

       6
       6
       -
         version = "6.0.3";

     

       6
       6
       +
         version = "6.0.5";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           owner = "deviantfero";

     

       10
       10
        
           repo = "wpgtk";

     

       11
       11
        
           rev = version;

     

       12
       12
       -
           sha256 = "1ma1d4h751qnxadfn42h29knq0rl1lgzraifx6ypidjph5i5a10l";

     

       12
       12
       +
           sha256 = "00nrc6ad2y0ivics6gpg63s86m8014a79yjn1q6d905qx32kk9dr";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         buildInputs = [

+2 -2

pkgs/tools/backup/restic/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoPackage rec {

     

       4
       4
        
         name = "restic-${version}";

     

       5
       5
       -
         version = "0.9.4";

     

       5
       5
       +
         version = "0.9.5";

     

       6
       6
        
       

     

       7
       7
        
         goPackagePath = "github.com/restic/restic";

     

       8
       8
        
       

     
···

       10
       10
        
           owner = "restic";

     

       11
       11
        
           repo = "restic";

     

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

     

       13
       13
       -
           sha256 = "15lx01w46bwn3hjwpmm8xy71m7ml9wdwddbbfvmk5in61gv1acr5";

     

       13
       13
       +
           sha256 = "1bhn3xwlycpnjg2qbqblwxn3apj43lr5cakgkmrblk13yfwfv5xv";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         buildPhase = ''

+1 -1

pkgs/tools/compression/pigz/default.nix

···

       15
       15
        
       

     

       16
       16
        
         buildInputs = [zlib] ++ stdenv.lib.optional stdenv.isLinux utillinux;

     

       17
       17
        
       

     

       18
       18
       -
         makeFlags = [ "CC=cc" ];

     

       18
       18
       +
         makeFlags = [ "CC=${stdenv.cc}/bin/${stdenv.cc.targetPrefix}cc" ];

     

       19
       19
        
       

     

       20
       20
        
         doCheck = stdenv.isLinux;

     

       21
       21
        
         checkTarget = "tests";

+3 -3

pkgs/tools/filesystems/bcachefs-tools/default.nix

···

       3
       3
        
       

     

       4
       4
        
       stdenv.mkDerivation rec {

     

       5
       5
        
         pname = "bcachefs-tools";

     

       6
       6
       -
         version = "2019-03-13";

     

       6
       6
       +
         version = "2019-04-04";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchgit {

     

       9
       9
        
           url = "https://evilpiepirate.org/git/bcachefs-tools.git";

     

       10
       10
       -
           rev = "0894d547501fb9306ae7b1c669b66a7b49fb2205";

     

       11
       11
       -
           sha256 = "1vwzwag413kzlij2f1hw1b8g592m40dr03zwkc8k5snbl4daiwr6";

     

       10
       10
       +
           rev = "d13bbb2955f899f10be4ab315ad229d2951fdcda";

     

       11
       11
       +
           sha256 = "0cjy12qjd572sbg8h4i18fn001p6a6ahc4ljwids58nv83q99ll3";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         enableParallelBuilding = true;

+2 -2

pkgs/tools/filesystems/bindfs/default.nix

···

       1
       1
        
       { stdenv, fetchurl, fuse, pkgconfig }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
       -
         version = "1.13.10";

     

       4
       4
       +
         version = "1.13.11";

     

       5
       5
        
         name    = "bindfs-${version}";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchurl {

     

       8
       8
        
           url    = "https://bindfs.org/downloads/${name}.tar.gz";

     

       9
       9
       -
           sha256 = "14wfp2dcjm0f1pmqqvkf94k7pijbi8ka395cm3hryqpi4k0w3f4j";

     

       9
       9
       +
           sha256 = "0ayadwlc6j1ba0n0dkry4iyp49nxkkj5l4dazzqybl5d5c4n605b";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         dontStrip = true;

+32

pkgs/tools/filesystems/rmount/default.nix

···

       1
       1
       +
       { stdenv, nmap, jq, cifs-utils, sshfs, fetchFromGitHub, makeWrapper }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
       

     

       5
       5
       +
         pname   = "rmount";

     

       6
       6
       +
         version = "1.0.1";

     

       7
       7
       +
       

     

       8
       8
       +
         src = fetchFromGitHub rec {

     

       9
       9
       +
           rev = "v${version}";

     

       10
       10
       +
           owner = "Luis-Hebendanz";

     

       11
       11
       +
           repo = "rmount";

     

       12
       12
       +
           sha256 = "1wjmfvbsq3126z51f2ivj85cjmkrzdm2acqsiyqs57qga2g6w5p9";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         buildInputs = [ makeWrapper ];

     

       16
       16
       +
       

     

       17
       17
       +
         installPhase = ''

     

       18
       18
       +
           install -D ${src}/rmount.man  $out/share/man/man1/rmount.1

     

       19
       19
       +
           install -D ${src}/rmount.bash $out/bin/rmount

     

       20
       20
       +
           install -D ${src}/config.json $out/share/config.json

     

       21
       21
       +
       

     

       22
       22
       +
           wrapProgram $out/bin/rmount --prefix PATH : ${stdenv.lib.makeBinPath [ nmap jq cifs-utils sshfs ]}

     

       23
       23
       +
         '';

     

       24
       24
       +
       

     

       25
       25
       +
         meta = with stdenv.lib; {

     

       26
       26
       +
           homepage = https://github.com/Luis-Hebendanz/rmount;

     

       27
       27
       +
           description = "Remote mount utility which parses a json file";

     

       28
       28
       +
           license = licenses.mit;

     

       29
       29
       +
           maintainers = [ maintainers.luis ];

     

       30
       30
       +
           platforms = platforms.linux;

     

       31
       31
       +
         };

     

       32
       32
       +
       }

+1 -1

pkgs/tools/misc/mpdscribble/default.nix

···

       15
       15
        
       

     

       16
       16
        
         meta = with stdenv.lib; {

     

       17
       17
        
           description = "A Music Player Daemon (MPD) client which submits information about tracks beeing played to a scrobbler (e.g. last.fm)";

     

       18
       18
       -
           homepage = http://mpd.wikia.com/wiki/Client:mpdscribble;

     

       18
       18
       +
           homepage = https://www.musicpd.org/clients/mpdscribble/;

     

       19
       19
        
           license = licenses.gpl2;

     

       20
       20
        
           maintainers = [ maintainers.matthiasbeyer ];

     

       21
       21
        
           platforms = platforms.linux;

+28

pkgs/tools/misc/pandoc-imagine/default.nix

···

       1
       1
       +
       { fetchFromGitHub, buildPythonApplication, lib, pandocfilters, six }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildPythonApplication rec {

     

       4
       4
       +
         pname = "pandoc-imagine";

     

       5
       5
       +
         version = "unstable-2018-11-19";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           repo = "imagine";

     

       9
       9
       +
           owner = "hertogp";

     

       10
       10
       +
           rev = "cc9be85155666c2d12d47a71690ba618cea1fac2";

     

       11
       11
       +
           sha256 = "0iksh9081g488yfjzd24bz4lm1nrrjamph1vynx3imrcfgyq7nsb";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         propagatedBuildInputs = [ pandocfilters six ];

     

       15
       15
       +
       

     

       16
       16
       +
         # No tests in archive

     

       17
       17
       +
         doCheck = false;

     

       18
       18
       +
       

     

       19
       19
       +
         meta = with lib; {

     

       20
       20
       +
           homepage = src.meta.homepage;

     

       21
       21
       +
           description = ''

     

       22
       22
       +
             A pandoc filter that will turn code blocks tagged with certain classes

     

       23
       23
       +
             into images or ASCII art

     

       24
       24
       +
           '';

     

       25
       25
       +
           license = with licenses; [ mit ];

     

       26
       26
       +
           maintainers = with maintainers; [ synthetica ];

     

       27
       27
       +
         };

     

       28
       28
       +
       }

+6 -10

pkgs/tools/misc/tmux/default.nix

···

       12
       12
        
       in

     

       13
       13
        
       

     

       14
       14
        
       stdenv.mkDerivation rec {

     

       15
       15
       -
         name = "tmux-${version}";

     

       16
       16
       -
         version = "2.8";

     

       15
       15
       +
         pname = "tmux";

     

       16
       16
       +
         version = "2.9";

     

       17
       17
        
       

     

       18
       18
        
         outputs = [ "out" "man" ];

     

       19
       19
        
       

     

       20
       20
        
         src = fetchFromGitHub {

     

       21
       21
       -
           owner = "tmux";

     

       22
       22
       -
           repo = "tmux";

     

       23
       23
       -
           rev = "01918cb0170e07288d3aec624516e6470bf5b7fc";

     

       24
       24
       -
           sha256 = "1fy87wvxn7r7jzqapvjisc1iizic3kxqk2lv83giqmw1y4g3s7rl";

     

       21
       21
       +
           owner = pname;

     

       22
       22
       +
           repo = pname;

     

       23
       23
       +
           rev = version;

     

       24
       24
       +
           sha256 = "191y986k9q17fdxlh3ldkr81s8fpxj4n2lc2lys6hzi4ybrhgdik";

     

       25
       25
        
         };

     

       26
       26
       -
       

     

       27
       27
       -
         postPatch = ''

     

       28
       28
       -
           sed -i 's/2.8-rc/2.8/' configure.ac

     

       29
       29
       -
         '';

     

       30
       26
        
       

     

       31
       27
        
         nativeBuildInputs = [ pkgconfig autoreconfHook ];

     

       32
       28

+2 -2

pkgs/tools/misc/you-get/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildPythonApplication rec {

     

       4
       4
        
         pname = "you-get";

     

       5
       5
       -
         version = "0.4.1270";

     

       5
       5
       +
         version = "0.4.1295";

     

       6
       6
        
       

     

       7
       7
        
         # Tests aren't packaged, but they all hit the real network so

     

       8
       8
        
         # probably aren't suitable for a build environment anyway.

     
···

       10
       10
        
       

     

       11
       11
        
         src = fetchPypi {

     

       12
       12
        
           inherit pname version;

     

       13
       13
       -
           sha256 = "1gq6z605xfhgama11krsc8y0qr690dgf9x39q2z941bqdxvxra5g";

     

       13
       13
       +
           sha256 = "15p9ngscrn20shkg909hcnsizqpbl038zbnmxwbprj88lnn8xz9m";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
        
         meta = with stdenv.lib; {

+7 -5

pkgs/tools/package-management/home-manager/default.nix

···

       1
       1
        
       #Adapted from

     

       2
       2
       -
       #https://github.com/rycee/home-manager/blob/9c1b3735b402346533449efc741f191d6ef578dd/home-manager/default.nix

     

       2
       2
       +
       #https://github.com/rycee/home-manager/blob/2c07829be2bcae55e04997b19719ff902a44016d/home-manager/default.nix

     

       3
       3
        
       

     

       4
       4
       -
       { bash, coreutils, less, stdenv, makeWrapper, fetchFromGitHub }:

     

       4
       4
       +
       { bash, coreutils, findutils, gnused, less, stdenv, makeWrapper, fetchFromGitHub }:

     

       5
       5
        
       

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
        
       

     

       8
       8
        
         name = "home-manager-${version}";

     

       9
       9
       -
         version = "2018-11-04";

     

       9
       9
       +
         version = "2019-04-23";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "rycee";

     

       13
       13
        
           repo = "home-manager";

     

       14
       14
       -
           rev = "05c93ff3ae13f1a2d90a279a890534cda7dc8ad6";

     

       15
       15
       -
           sha256 = "0ymfvjnnz98ynws3v6dcil1cmp7x2cmm6zy8yqgkn8z7wyrrqq0v";

     

       14
       14
       +
           rev = "ba0375bf06e0e0c3b2377edf913b7fddfd5a0b40";

     

       15
       15
       +
           sha256 = "1ksr8fw5p5ai2a02whppc0kz9b3m5363hvfjghkzkd623kfh9073";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         nativeBuildInputs = [ makeWrapper ];

     
···

       24
       24
        
           substituteInPlace $out/bin/home-manager \

     

       25
       25
        
             --subst-var-by bash "${bash}" \

     

       26
       26
        
             --subst-var-by coreutils "${coreutils}" \

     

       27
       27
       +
             --subst-var-by findutils "${findutils}" \

     

       28
       28
       +
             --subst-var-by gnused "${gnused}" \

     

       27
       29
        
             --subst-var-by less "${less}" \

     

       28
       30
        
             --subst-var-by HOME_MANAGER_PATH '${src}'

     

       29
       31
        
         '';

+32 -16

pkgs/tools/security/rng-tools/default.nix

···

       1
       1
       -
       { stdenv, fetchFromGitHub, libtool, autoconf, automake, pkgconfig

     

       1
       1
       +
       { stdenv, fetchFromGitHub, libtool, autoreconfHook, pkgconfig

     

       2
       2
        
       , sysfsutils

     

       3
       3
        
         # WARNING: DO NOT USE BEACON GENERATED VALUES AS SECRET CRYPTOGRAPHIC KEYS

     

       4
       4
        
         # https://www.nist.gov/programs-projects/nist-randomness-beacon

     
···

       8
       8
        
         # Not sure if jitterentropy is safe to use for cryptography

     

       9
       9
        
         # and thus a default entropy source

     

       10
       10
        
       , jitterentropy ? null, withJitterEntropy ? false

     

       11
       11
       +
       , libp11 ? null, opensc ? null, withPkcs11 ? true

     

       11
       12
        
       }:

     

       13
       13
       +
       

     

       12
       14
        
       with stdenv.lib;

     

       15
       15
       +
       

     

       13
       16
        
       stdenv.mkDerivation rec {

     

       14
       14
       -
         name = "rng-tools-${version}";

     

       15
       15
       -
         version = "6.6";

     

       17
       17
       +
         pname = "rng-tools";

     

       18
       18
       +
         version = "6.7";

     

       16
       19
        
       

     

       17
       20
        
         src = fetchFromGitHub {

     

       18
       21
        
           owner = "nhorman";

     

       19
       22
        
           repo = "rng-tools";

     

       20
       23
        
           rev = "v${version}";

     

       21
       21
       -
           sha256 = "0c32sxfvngdjzfmxn5ngc5yxwi8ij3yl216nhzyz9r31qi3m14v7";

     

       24
       24
       +
           sha256 = "19f75m6mzg8h7b4snzg7d6ypvkz6nq32lrpi9ja95gqz4wsd18a5";

     

       22
       25
        
         };

     

       23
       26
        
       

     

       24
       24
       -
         nativeBuildInputs = [ libtool autoconf automake pkgconfig ];

     

       27
       27
       +
         postPatch = ''

     

       28
       28
       +
           cp README.md README

     

       25
       29
        
       

     

       26
       26
       -
         preConfigure = "./autogen.sh";

     

       30
       30
       +
           ${optionalString withPkcs11 ''

     

       31
       31
       +
             substituteInPlace rngd.c \

     

       32
       32
       +
               --replace /usr/lib64/opensc-pkcs11.so ${opensc}/lib/opensc-pkcs11.so

     

       33
       33
       +
           ''}

     

       34
       34
       +
         '';

     

       27
       35
        
       

     

       28
       28
       -
         configureFlags =

     

       29
       29
       -
              optional (!withJitterEntropy) "--disable-jitterentropy"

     

       30
       30
       -
           ++ optional (!withNistBeacon) "--without-nistbeacon"

     

       31
       31
       -
           ++ optional (!withGcrypt) "--without-libgcrypt";

     

       36
       36
       +
         nativeBuildInputs = [ autoreconfHook libtool pkgconfig ];

     

       37
       37
       +
       

     

       38
       38
       +
         configureFlags = [

     

       39
       39
       +
           (withFeature   withGcrypt        "libgcrypt")

     

       40
       40
       +
           (enableFeature withJitterEntropy "jitterentropy")

     

       41
       41
       +
           (withFeature   withNistBeacon    "nistbeacon")

     

       42
       42
       +
           (withFeature   withPkcs11        "pkcs11")

     

       43
       43
       +
         ];

     

       32
       44
        
       

     

       33
       45
        
         buildInputs = [ sysfsutils ]

     

       34
       34
       -
           ++ optional withJitterEntropy [ jitterentropy ]

     

       35
       35
       -
           ++ optional withGcrypt [ libgcrypt.dev ]

     

       36
       36
       -
           ++ optional withNistBeacon [ openssl.dev curl.dev libxml2.dev ];

     

       46
       46
       +
           ++ optionals withGcrypt        [ libgcrypt ]

     

       47
       47
       +
           ++ optionals withJitterEntropy [ jitterentropy ]

     

       48
       48
       +
           ++ optionals withNistBeacon    [ curl libxml2 openssl ]

     

       49
       49
       +
           ++ optionals withPkcs11        [ libp11 openssl ];

     

       50
       50
       +
       

     

       51
       51
       +
         # This shouldn't be necessary but is as of 6.7

     

       52
       52
       +
         NIX_LDFLAGS = optionalString withPkcs11 "-lcrypto";

     

       37
       53
        
       

     

       38
       54
        
         enableParallelBuilding = true;

     

       39
       55
        
       

     
···

       43
       59
        
         meta = {

     

       44
       60
        
           description = "A random number generator daemon";

     

       45
       61
        
           homepage = https://github.com/nhorman/rng-tools;

     

       46
       46
       -
           license = stdenv.lib.licenses.gpl2Plus;

     

       47
       47
       -
           platforms = stdenv.lib.platforms.linux;

     

       48
       48
       -
           maintainers = with stdenv.lib.maintainers; [ johnazoidberg ];

     

       62
       62
       +
           license = licenses.gpl2Plus;

     

       63
       63
       +
           platforms = platforms.linux;

     

       64
       64
       +
           maintainers = with maintainers; [ johnazoidberg ];

     

       49
       65
        
         };

     

       50
       66
        
       }

+35

pkgs/tools/system/ledmon/default.nix

···

       1
       1
       +
       { stdenv, fetchFromGitHub, perl, udev, sg3_utils }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         pname = "ledmon";

     

       5
       5
       +
         version = "0.92";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "intel";

     

       9
       9
       +
           repo = "ledmon";

     

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

     

       11
       11
       +
           sha256 = "1lz59606vf2sws5xwijxyffm8kxcf8p9qbdpczsq1b5mm3dk6lvp";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         nativeBuildInputs = [

     

       15
       15
       +
           perl # for pod2man

     

       16
       16
       +
         ];

     

       17
       17
       +
         buildInputs = [ udev sg3_utils ];

     

       18
       18
       +
       

     

       19
       19
       +
         installTargets = [ "install" "install-systemd" ];

     

       20
       20
       +
       

     

       21
       21
       +
         makeFlags = [

     

       22
       22
       +
           "MAN_INSTDIR=${placeholder "out"}/share/man"

     

       23
       23
       +
           "SYSTEMD_SERVICE_INSTDIR=${placeholder "out"}/lib/systemd/system"

     

       24
       24
       +
           "LEDCTL_INSTDIR=${placeholder "out"}/sbin"

     

       25
       25
       +
           "LEDMON_INSTDIR=${placeholder "out"}/sbin"

     

       26
       26
       +
         ];

     

       27
       27
       +
       

     

       28
       28
       +
         meta = with stdenv.lib; {

     

       29
       29
       +
           homepage = https://github.com/intel/ledmon;

     

       30
       30
       +
           description = "Enclosure LED Utilities";

     

       31
       31
       +
           platforms = platforms.linux;

     

       32
       32
       +
           license = with licenses; [ gpl2 ];

     

       33
       33
       +
           maintainers = with stdenv.lib.maintainers; [ sorki ];

     

       34
       34
       +
         };

     

       35
       35
       +
       }

+41

pkgs/tools/text/epubcheck/default.nix

···

       1
       1
       +
       { stdenv, fetchzip

     

       2
       2
       +
       , jre, makeWrapper }:

     

       3
       3
       +
       

     

       4
       4
       +
       stdenv.mkDerivation rec {

     

       5
       5
       +
         pname = "epubcheck";

     

       6
       6
       +
         version = "4.2.0";

     

       7
       7
       +
       

     

       8
       8
       +
         src = fetchzip {

     

       9
       9
       +
           url = "https://github.com/w3c/epubcheck/releases/download/v${version}/epubcheck-${version}.zip";

     

       10
       10
       +
           sha256 = "1bf5jbzqvgpvhbkprynxj75ilk3r6zld157vjf6k7l5g21cwyn9d";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         nativeBuildInputs = [ makeWrapper ];

     

       14
       14
       +
       

     

       15
       15
       +
         dontBuild = true;

     

       16
       16
       +
       

     

       17
       17
       +
         installPhase = ''

     

       18
       18
       +
           mkdir -p $out/lib

     

       19
       19
       +
           cp -r lib/* $out/lib

     

       20
       20
       +
       

     

       21
       21
       +
           mkdir -p $out/libexec/epubcheck

     

       22
       22
       +
           cp epubcheck.jar $out/libexec/epubcheck

     

       23
       23
       +
       

     

       24
       24
       +
           classpath=$out/libexec/epubcheck/epubcheck.jar

     

       25
       25
       +
           for jar in $out/lib/*.jar; do

     

       26
       26
       +
             classpath="$classpath:$jar"

     

       27
       27
       +
           done

     

       28
       28
       +
       

     

       29
       29
       +
           mkdir -p $out/bin

     

       30
       30
       +
           makeWrapper ${jre}/bin/java $out/bin/epubcheck \

     

       31
       31
       +
             --add-flags "-classpath $classpath com.adobe.epubcheck.tool.Checker"

     

       32
       32
       +
         '';

     

       33
       33
       +
       

     

       34
       34
       +
         meta = with stdenv.lib; {

     

       35
       35
       +
           homepage = https://github.com/w3c/epubcheck;

     

       36
       36
       +
           description = "Validation tool for EPUB";

     

       37
       37
       +
           license = with licenses; [ asl20 bsd3 mpl10 w3c ];

     

       38
       38
       +
           platforms = platforms.all;

     

       39
       39
       +
           maintainers = with maintainers; [ eadwu ];

     

       40
       40
       +
         };

     

       41
       41
       +
       }

+36 -1

pkgs/top-level/all-packages.nix

···

       2560
       2560
        
       

     

       2561
       2561
        
         eid-mw = callPackage ../tools/security/eid-mw { };

     

       2562
       2562
        
       

     

       2563
       2563
       +
         epubcheck = callPackage ../tools/text/epubcheck { };

     

       2564
       2564
       +
       

     

       2563
       2565
        
         mcrcon = callPackage ../tools/networking/mcrcon {};

     

       2564
       2566
        
       

     

       2565
       2567
        
         s-tar = callPackage ../tools/archivers/s-tar {};

     
···

       4120
       4122
        
       

     

       4121
       4123
        
         leatherman = callPackage ../development/libraries/leatherman { };

     

       4122
       4124
        
       

     

       4125
       4125
       +
         ledmon = callPackage ../tools/system/ledmon { };

     

       4126
       4126
       +
       

     

       4123
       4127
        
         leela = callPackage ../tools/graphics/leela { };

     

       4124
       4128
        
       

     

       4125
       4129
        
         lftp = callPackage ../tools/networking/lftp { };

     
···

       4401
       4405
        
       

     

       4402
       4406
        
         mimetic = callPackage ../development/libraries/mimetic { };

     

       4403
       4407
        
       

     

       4408
       4408
       +
         minetime = callPackage ../applications/office/minetime { };

     

       4409
       4409
       +
       

     

       4404
       4410
        
         minio-client = callPackage ../tools/networking/minio-client {

     

       4405
       4411
        
           buildGoPackage = buildGo110Package;

     

       4406
       4412
        
         };

     
···

       4649
       4655
        
           buildGoPackage = buildGo110Package;

     

       4650
       4656
        
         };

     

       4651
       4657
        
       

     

       4658
       4658
       +
         notable = callPackage ../applications/misc/notable { };

     

       4659
       4659
       +
       

     

       4652
       4660
        
         miller = callPackage ../tools/text/miller { };

     

       4653
       4661
        
       

     

       4654
       4662
        
         milu = callPackage ../applications/misc/milu { };

     
···

       4656
       4664
        
         mpack = callPackage ../tools/networking/mpack { };

     

       4657
       4665
        
       

     

       4658
       4666
        
         pa_applet = callPackage ../tools/audio/pa-applet { };

     

       4667
       4667
       +
       

     

       4668
       4668
       +
         pandoc-imagine = python3Packages.callPackage ../tools/misc/pandoc-imagine { };

     

       4659
       4669
        
       

     

       4660
       4670
        
         pasystray = callPackage ../tools/audio/pasystray { };

     

       4661
       4671
        
       

     
···

       5105
       5115
        
         playbar2 = libsForQt5.callPackage ../applications/audio/playbar2 { };

     

       5106
       5116
        
       

     

       5107
       5117
        
         plex = callPackage ../servers/plex { };

     

       5118
       5118
       +
         plexRaw = callPackage ../servers/plex/raw.nix { };

     

       5108
       5119
        
       

     

       5109
       5120
        
         tautulli = callPackage ../servers/tautulli { python = python2; };

     

       5110
       5121
        
       

     
···

       5232
       5243
        
         pycangjie = pythonPackages.pycangjie;

     

       5233
       5244
        
       

     

       5234
       5245
        
         pydb = callPackage ../development/tools/pydb { };

     

       5246
       5246
       +
       

     

       5247
       5247
       +
         pydf = callPackage ../applications/misc/pydf { };

     

       5235
       5248
        
       

     

       5236
       5249
        
         pygmentex = callPackage ../tools/typesetting/pygmentex { };

     

       5237
       5250
        
       

     
···

       7731
       7744
        
           inherit (ocaml-ng.ocamlPackages_4_05) ocaml;

     

       7732
       7745
        
         };

     

       7733
       7746
        
       

     

       7747
       7747
       +
         pforth = callPackage ../development/compilers/pforth {};

     

       7748
       7748
       +
       

     

       7734
       7749
        
         picat = callPackage ../development/compilers/picat {

     

       7735
       7750
        
           stdenv = overrideCC stdenv gcc49;

     

       7736
       7751
        
         };

     
···

       7783
       7798
        
         cargo-bloat = callPackage ../development/tools/rust/cargo-bloat { };

     

       7784
       7799
        
         cargo-expand = callPackage ../development/tools/rust/cargo-expand { };

     

       7785
       7800
        
         cargo-fuzz = callPackage ../development/tools/rust/cargo-fuzz { };

     

       7801
       7801
       +
         cargo-sweep = callPackage ../development/tools/rust/cargo-sweep { };

     

       7786
       7802
        
         cargo-xbuild = callPackage ../development/tools/rust/cargo-xbuild { };

     

       7787
       7803
        
       

     

       7788
       7804
        
         pyo3-pack = callPackage ../development/tools/rust/pyo3-pack { };

     
···

       8940
       8956
        
         epm = callPackage ../development/tools/misc/epm { };

     

       8941
       8957
        
       

     

       8942
       8958
        
         eresi = callPackage ../development/tools/analysis/eresi { };

     

       8959
       8959
       +
       

     

       8960
       8960
       +
         evmdis = callPackage ../development/tools/analysis/evmdis { };

     

       8943
       8961
        
       

     

       8944
       8962
        
         eweb = callPackage ../development/tools/literate-programming/eweb { };

     

       8945
       8963
        
       

     
···

       14299
       14317
        
       

     

       14300
       14318
        
         timescaledb-parallel-copy = callPackage ../development/tools/database/timescaledb-parallel-copy { };

     

       14301
       14319
        
       

     

       14320
       14320
       +
         timescaledb-tune = callPackage ../development/tools/database/timescaledb-tune { };

     

       14321
       14321
       +
       

     

       14302
       14322
        
         inherit (import ../servers/sql/postgresql pkgs)

     

       14303
       14323
        
           postgresql_9_4

     

       14304
       14324
        
           postgresql_9_5

     
···

       14987
       15007
        
             [ kernelPatches.bridge_stp_helper

     

       14988
       15008
        
               kernelPatches.cpu-cgroup-v2."4.9"

     

       14989
       15009
        
               kernelPatches.modinst_arg_list_too_long

     

       15010
       15010
       +
               kernelPatches.i2c-oops

     

       14990
       15011
        
             ];

     

       14991
       15012
        
         };

     

       14992
       15013
        
       

     
···

       14997
       15018
        
               # when adding a new linux version

     

       14998
       15019
        
               kernelPatches.cpu-cgroup-v2."4.11"

     

       14999
       15020
        
               kernelPatches.modinst_arg_list_too_long

     

       15021
       15021
       +
               kernelPatches.i2c-oops

     

       15000
       15022
        
             ];

     

       15001
       15023
        
         };

     

       15002
       15024
        
       

     
···

       15004
       15026
        
           kernelPatches =

     

       15005
       15027
        
             [ kernelPatches.bridge_stp_helper

     

       15006
       15028
        
               kernelPatches.modinst_arg_list_too_long

     

       15029
       15029
       +
               kernelPatches.i2c-oops

     

       15007
       15030
        
             ];

     

       15008
       15031
        
         };

     

       15009
       15032
        
       

     
···

       15678
       15701
        
           ubootTools

     

       15679
       15702
        
           ubootA20OlinuxinoLime

     

       15680
       15703
        
           ubootBananaPi

     

       15704
       15704
       +
           ubootBananaPim64

     

       15681
       15705
        
           ubootBeagleboneBlack

     

       15682
       15706
        
           ubootClearfog

     

       15683
       15707
        
           ubootGuruplug

     
···

       16412
       16436
        
       

     

       16413
       16437
        
         xits-math = callPackage ../data/fonts/xits-math { };

     

       16414
       16438
        
       

     

       16439
       16439
       +
         xkcd-font = callPackage ../data/fonts/xkcd-font { };

     

       16440
       16440
       +
       

     

       16415
       16441
        
         xkeyboard_config = xorg.xkeyboardconfig;

     

       16416
       16442
        
       

     

       16417
       16443
        
         xlsx2csv = with python3Packages; toPythonApplication xlsx2csv;

     
···

       18309
       18335
        
         inherit (kdeApplications)

     

       18310
       18336
        
           akonadi akregator ark dolphin dragon ffmpegthumbs filelight gwenview k3b

     

       18311
       18337
        
           kaddressbook kate kcachegrind kcalc kcharselect kcolorchooser kcontacts kdenlive kdf kdialog

     

       18312
       18312
       -
           keditbookmarks kget kgpg khelpcenter kig kleopatra kmail kmix kmplot kolourpaint kompare konsole

     

       18338
       18338
       +
           keditbookmarks kfind kget kgpg khelpcenter kig kleopatra kmail kmix kmplot kolourpaint kompare konsole

     

       18313
       18339
        
           kpkpass kitinerary kontact korganizer krdc krfb ksystemlog ktouch kwalletmanager marble minuet okular spectacle;

     

       18314
       18340
        
       

     

       18315
       18341
        
         okteta = libsForQt5.callPackage ../applications/editors/okteta { };

     
···

       20006
       20032
        
       

     

       20007
       20033
        
         taskserver = callPackage ../servers/misc/taskserver { };

     

       20008
       20034
        
       

     

       20035
       20035
       +
         taskopen = callPackage ../applications/misc/taskopen { };

     

       20036
       20036
       +
       

     

       20009
       20037
        
         tdesktopPackages = dontRecurseIntoAttrs (callPackage ../applications/networking/instant-messengers/telegram/tdesktop { });

     

       20010
       20038
        
         tdesktop = tdesktopPackages.stable;

     

       20011
       20039
        
       

     
···

       22031
       22059
        
       

     

       22032
       22060
        
         strelka = callPackage ../applications/science/biology/strelka { };

     

       22033
       22061
        
       

     

       22062
       22062
       +
         inherit (callPackages ../applications/science/biology/sumatools {})

     

       22063
       22063
       +
             sumalibs

     

       22064
       22064
       +
             sumaclust

     

       22065
       22065
       +
             sumatra;

     

       22066
       22066
       +
       

     

       22034
       22067
        
         seaview = callPackage ../applications/science/biology/seaview { };

     

       22035
       22068
        
       

     

       22036
       22069
        
         varscan = callPackage ../applications/science/biology/varscan { };

     
···

       23270
       23303
        
         };

     

       23271
       23304
        
       

     

       23272
       23305
        
         ricty = callPackage ../data/fonts/ricty { };

     

       23306
       23306
       +
       

     

       23307
       23307
       +
         rmount = callPackage ../tools/filesystems/rmount {};

     

       23273
       23308
        
       

     

       23274
       23309
        
         rss-glx = callPackage ../misc/screensavers/rss-glx { };

     

       23275
       23310

+20 -14

pkgs/top-level/php-packages.nix

···

       7
       7
        
             inherit (pkgs) stdenv autoreconfHook fetchurl;

     

       8
       8
        
           };

     

       9
       9
        
       

     

       10
       10
       +
           # Wrap mkDerivation to prepend pname with "php-" to make names consistent

     

       11
       11
       +
           # with how buildPecl does it and make the file easier to overview.

     

       12
       12
       +
           mkDerivation = { pname, ... }@args: pkgs.stdenv.mkDerivation (args // {

     

       13
       13
       +
             pname = "php-${pname}";

     

       14
       14
       +
           });

     

       15
       15
       +
       

     

       10
       16
        
         isPhp73 = pkgs.lib.versionAtLeast php.version "7.3";

     

       11
       17
        
       

     

       12
       18
        
         apcu = buildPecl rec {

     
···

       39
       45
        
           sha256 = "0ja74k2lmxwhhvp9y9kc7khijd7s2dqma5x8ghbhx9ajkn0wg8iq";

     

       40
       46
        
         };

     

       41
       47
        
       

     

       42
       42
       -
         box = pkgs.stdenv.mkDerivation rec {

     

       48
       48
       +
         box = mkDerivation rec {

     

       43
       49
        
           version = "2.7.5";

     

       44
       44
       -
           pname = "php-box";

     

       50
       50
       +
           pname = "box";

     

       45
       51
        
       

     

       46
       52
        
           src = pkgs.fetchurl {

     

       47
       53
        
             url = "https://github.com/box-project/box2/releases/download/${version}/box-${version}.phar";

     
···

       66
       72
        
           };

     

       67
       73
        
         };

     

       68
       74
        
       

     

       69
       69
       -
         composer = pkgs.stdenv.mkDerivation rec {

     

       75
       75
       +
         composer = mkDerivation rec {

     

       70
       76
        
           version = "1.8.5";

     

       71
       71
       -
           pname = "php-composer";

     

       77
       77
       +
           pname = "composer";

     

       72
       78
        
       

     

       73
       79
        
           src = pkgs.fetchurl {

     

       74
       80
        
             url = "https://getcomposer.org/download/${version}/composer.phar";

     
···

       210
       216
        
           buildInputs = [ pkgs.unixODBC ];

     

       211
       217
        
         };

     

       212
       218
        
       

     

       213
       213
       -
         php-cs-fixer = pkgs.stdenv.mkDerivation rec {

     

       219
       219
       +
         php-cs-fixer = mkDerivation rec {

     

       214
       220
        
           version = "2.14.2";

     

       215
       221
        
           pname = "php-cs-fixer";

     

       216
       222
        
       

     
···

       237
       243
        
           };

     

       238
       244
        
         };

     

       239
       245
        
       

     

       240
       240
       -
         php-parallel-lint = pkgs.stdenv.mkDerivation rec {

     

       246
       246
       +
         php-parallel-lint = mkDerivation rec {

     

       241
       247
        
           version = "1.0.0";

     

       242
       248
        
           pname = "php-parallel-lint";

     

       243
       249
        
       

     
···

       286
       292
        
           meta.broken = true;

     

       287
       293
        
         };

     

       288
       294
        
       

     

       289
       289
       -
         phpcbf = pkgs.stdenv.mkDerivation rec {

     

       295
       295
       +
         phpcbf = mkDerivation rec {

     

       290
       296
        
           version = "3.4.2";

     

       291
       291
       -
           pname = "php-phpcbf";

     

       297
       297
       +
           pname = "phpcbf";

     

       292
       298
        
       

     

       293
       299
        
           src = pkgs.fetchurl {

     

       294
       300
        
             url = "https://github.com/squizlabs/PHP_CodeSniffer/releases/download/${version}/phpcbf.phar";

     
···

       313
       319
        
           };

     

       314
       320
        
         };

     

       315
       321
        
       

     

       316
       316
       -
         phpcs = pkgs.stdenv.mkDerivation rec {

     

       322
       322
       +
         phpcs = mkDerivation rec {

     

       317
       323
        
           version = "3.4.2";

     

       318
       318
       -
           pname = "php-phpcs";

     

       324
       324
       +
           pname = "phpcs";

     

       319
       325
        
       

     

       320
       326
        
           src = pkgs.fetchurl {

     

       321
       327
        
             url = "https://github.com/squizlabs/PHP_CodeSniffer/releases/download/${version}/phpcs.phar";

     
···

       340
       346
        
           };

     

       341
       347
        
         };

     

       342
       348
        
       

     

       343
       343
       -
         phpstan = pkgs.stdenv.mkDerivation rec {

     

       349
       349
       +
         phpstan = mkDerivation rec {

     

       344
       350
        
           version = "0.11.5";

     

       345
       345
       -
           pname = "php-phpstan";

     

       351
       351
       +
           pname = "phpstan";

     

       346
       352
        
       

     

       347
       353
        
           src = pkgs.fetchurl {

     

       348
       354
        
             url = "https://github.com/phpstan/phpstan/releases/download/${version}/phpstan.phar";

     
···

       374
       380
        
           };

     

       375
       381
        
         };

     

       376
       382
        
       

     

       377
       377
       -
         psysh = pkgs.stdenv.mkDerivation rec {

     

       383
       383
       +
         psysh = mkDerivation rec {

     

       378
       384
        
           version = "0.9.9";

     

       379
       379
       -
           pname = "php-psysh";

     

       385
       385
       +
           pname = "psysh";

     

       380
       386
        
       

     

       381
       387
        
           src = pkgs.fetchurl {

     

       382
       388
        
             url = "https://github.com/bobthecow/psysh/releases/download/v${version}/psysh-v${version}.tar.gz";

pkgs/top-level/python-packages.nix

···

       4434
       4434
        
       

     

       4435
       4435
        
         wordfreq = callPackage ../development/python-modules/wordfreq { };

     

       4436
       4436
        
       

     

       4437
       4437
       +
         wikipedia = callPackage ../development/python-modules/wikipedia { };

     

       4438
       4438
       +
       

     

       4437
       4439
        
         magic-wormhole = callPackage ../development/python-modules/magic-wormhole { };

     

       4438
       4440
        
       

     

       4439
       4441
        
         magic-wormhole-mailbox-server = callPackage ../development/python-modules/magic-wormhole-mailbox-server { };