commit aaaeebad7a823083078771b624fd64e747fa81a1 · pyrox.dev/nixpkgs

+6 -8

nixos/modules/misc/version.nix

···

       89
       89
        
       

     

       90
       90
        
           stateVersion = mkOption {

     

       91
       91
        
             type = types.str;

     

       92
       92
       +
             # TODO Remove this and drop the default of the option so people are forced to set it.

     

       93
       93
       +
             # Doing this also means fixing the comment in nixos/modules/testing/test-instrumentation.nix

     

       94
       94
       +
             apply = v:

     

       95
       95
       +
               lib.warnIf (options.system.stateVersion.highestPrio == (lib.mkOptionDefault { }).priority)

     

       96
       96
       +
                 "system.stateVersion is not set, defaulting to ${v}. Read why this matters on https://nixos.org/manual/nixos/stable/options.html#opt-system.stateVersion."

     

       97
       97
       +
                 v;

     

       92
       98
        
             default = cfg.release;

     

       93
       99
        
             defaultText = literalExpression "config.${opt.release}";

     

       94
       100
        
             description = lib.mdDoc ''

     
···

       149
       155
        
             "os-release".text = attrsToText osReleaseContents;

     

       150
       156
        
           };

     

       151
       157
        
       

     

       152
       152
       -
           # We have to use `warnings` because when warning in the default of the option

     

       153
       153
       -
           # the warning would also be shown when building the manual since the manual

     

       154
       154
       -
           # has to evaluate the default.

     

       155
       155
       -
           #

     

       156
       156
       -
           # TODO Remove this and drop the default of the option so people are forced to set it.

     

       157
       157
       -
           # Doing this also means fixing the comment in nixos/modules/testing/test-instrumentation.nix

     

       158
       158
       -
           warnings = lib.optional (options.system.stateVersion.highestPrio == (lib.mkOptionDefault { }).priority)

     

       159
       159
       -
             "system.stateVersion is not set, defaulting to ${config.system.stateVersion}. Read why this matters on https://nixos.org/manual/nixos/stable/options.html#opt-system.stateVersion.";

     

       160
       158
        
         };

     

       161
       159
        
       

     

       162
       160
        
         # uses version info nixpkgs, which requires a full nixpkgs path

nixos/modules/module-list.nix

···

       1313
       1313
        
         ./tasks/filesystems/btrfs.nix

     

       1314
       1314
        
         ./tasks/filesystems/cifs.nix

     

       1315
       1315
        
         ./tasks/filesystems/ecryptfs.nix

     

       1316
       1316
       +
         ./tasks/filesystems/envfs.nix

     

       1316
       1317
        
         ./tasks/filesystems/exfat.nix

     

       1317
       1318
        
         ./tasks/filesystems/ext.nix

     

       1318
       1319
        
         ./tasks/filesystems/f2fs.nix

+19 -1

nixos/modules/profiles/macos-builder.nix

···

       11
       11
        
       

     

       12
       12
        
       { imports = [

     

       13
       13
        
           ../virtualisation/qemu-vm.nix

     

       14
       14
       +
       

     

       15
       15
       +
           # Avoid a dependency on stateVersion

     

       16
       16
       +
           {

     

       17
       17
       +
             disabledModules = [

     

       18
       18
       +
               ../virtualisation/nixos-containers.nix

     

       19
       19
       +
               ../services/x11/desktop-managers/xterm.nix

     

       20
       20
       +
             ];

     

       21
       21
       +
             config = {

     

       22
       22
       +
             };

     

       23
       23
       +
             options.boot.isContainer = lib.mkOption { default = false; internal = true; };

     

       24
       24
       +
           }

     

       14
       25
        
         ];

     

       15
       26
        
       

     

       16
       27
        
         # The builder is not intended to be used interactively

     
···

       97
       108
        
           # To prevent gratuitous rebuilds on each change to Nixpkgs

     

       98
       109
        
           nixos.revision = null;

     

       99
       110
        
       

     

       100
       100
       -
           stateVersion = "22.05";

     

       111
       111
       +
           stateVersion = lib.mkDefault (throw ''

     

       112
       112
       +
             The macOS linux builder should not need a stateVersion to be set, but a module

     

       113
       113
       +
             has accessed stateVersion nonetheless.

     

       114
       114
       +
             Please inspect the trace of the following command to figure out which module

     

       115
       115
       +
             has a dependency on stateVersion.

     

       116
       116
       +
       

     

       117
       117
       +
               nix-instantiate --attr darwin.builder --show-trace

     

       118
       118
       +
           '');

     

       101
       119
        
         };

     

       102
       120
        
       

     

       103
       121
        
         users.users."${user}"= {

+3 -2

nixos/modules/services/backup/borgbackup.nix

···

       150
       150
        
               # Ensure that the home directory already exists

     

       151
       151
        
               # We can't assert createHome == true because that's not the case for root

     

       152
       152
        
               cd "${config.users.users.${cfg.user}.home}"

     

       153
       153
       -
               ${install} -d .config/borg

     

       154
       154
       -
               ${install} -d .cache/borg

     

       153
       153
       +
               # Create each directory separately to prevent root owned parent dirs

     

       154
       154
       +
               ${install} -d .config .config/borg

     

       155
       155
       +
               ${install} -d .cache .cache/borg

     

       155
       156
        
             '' + optionalString (isLocalPath cfg.repo && !cfg.removableDevice) ''

     

       156
       157
        
               ${install} -d ${escapeShellArg cfg.repo}

     

       157
       158
        
             ''));

nixos/modules/services/matrix/synapse.nix

···

       507
       507
        
                       sqlite3 = null;

     

       508
       508
        
                       psycopg2 = "matrix-synapse";

     

       509
       509
        
                     }.${cfg.settings.database.name};

     

       510
       510
       +
                     defaultText = lib.literalExpression ''

     

       511
       511
       +
                       {

     

       512
       512
       +
                         sqlite3 = null;

     

       513
       513
       +
                         psycopg2 = "matrix-synapse";

     

       514
       514
       +
                       }.''${cfg.settings.database.name};

     

       515
       515
       +
                     '';

     

       510
       516
        
                     description = lib.mdDoc ''

     

       511
       517
        
                       Username to connect with psycopg2, set to null

     

       512
       518
        
                       when using sqlite3.

+1 -1

nixos/modules/services/misc/nix-daemon.nix

···

       819
       819
        
                 optionals (pkgs.hostPlatform ? gcc.arch) (

     

       820
       820
        
                   # a builder can run code for `gcc.arch` and inferior architectures

     

       821
       821
        
                   [ "gccarch-${pkgs.hostPlatform.gcc.arch}" ] ++

     

       822
       822
       -
                   map (x: "gccarch-${x}") systems.architectures.inferiors.${pkgs.hostPlatform.gcc.arch}

     

       822
       822
       +
                   map (x: "gccarch-${x}") (systems.architectures.inferiors.${pkgs.hostPlatform.gcc.arch} or [])

     

       823
       823
        
                 )

     

       824
       824
        
               );

     

       825
       825
        
             }

+1 -4

nixos/modules/system/boot/initrd-openvpn.nix

···

       68
       68
        
             $out/bin/openvpn --show-gateway

     

       69
       69
        
           '';

     

       70
       70
        
       

     

       71
       71
       -
           # Add `iproute /bin/ip` to the config, to ensure that openvpn

     

       72
       72
       -
           # is able to set the routes

     

       73
       71
        
           boot.initrd.network.postCommands = ''

     

       74
       74
       -
             (cat /etc/initrd.ovpn; echo -e '\niproute /bin/ip') | \

     

       75
       75
       -
               openvpn /dev/stdin &

     

       72
       72
       +
             openvpn /etc/initrd.ovpn &

     

       76
       73
        
           '';

     

       77
       74
        
         };

     

       78
       75

+51

nixos/modules/tasks/filesystems/envfs.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         cfg = config.services.envfs;

     

       5
       5
       +
         mounts = {

     

       6
       6
       +
           "/usr/bin" = {

     

       7
       7
       +
             device = "none";

     

       8
       8
       +
             fsType = "envfs";

     

       9
       9
       +
             options = [

     

       10
       10
       +
               "fallback-path=${pkgs.runCommand "fallback-path" {} ''

     

       11
       11
       +
                 mkdir -p $out

     

       12
       12
       +
                 ln -s ${pkgs.coreutils}/bin/env $out/env

     

       13
       13
       +
                 ln -s ${config.system.build.binsh}/bin/sh $out/sh

     

       14
       14
       +
               ''}"

     

       15
       15
       +
             ];

     

       16
       16
       +
           };

     

       17
       17
       +
           "/bin" = {

     

       18
       18
       +
             device = "/usr/bin";

     

       19
       19
       +
             fsType = "none";

     

       20
       20
       +
             options = [ "bind" ];

     

       21
       21
       +
           };

     

       22
       22
       +
         };

     

       23
       23
       +
       in {

     

       24
       24
       +
         options = {

     

       25
       25
       +
           services.envfs = {

     

       26
       26
       +
             enable = lib.mkEnableOption (lib.mdDoc "Envfs filesystem") // {

     

       27
       27
       +
               description = lib.mdDoc ''

     

       28
       28
       +
                 Fuse filesystem that returns symlinks to executables based on the PATH

     

       29
       29
       +
                 of the requesting process. This is useful to execute shebangs on NixOS

     

       30
       30
       +
                 that assume hard coded locations in locations like /bin or /usr/bin

     

       31
       31
       +
                 etc.

     

       32
       32
       +
               '';

     

       33
       33
       +
             };

     

       34
       34
       +
             package = lib.mkOption {

     

       35
       35
       +
               type = lib.types.package;

     

       36
       36
       +
               description = lib.mdDoc "Which package to use for the envfs.";

     

       37
       37
       +
               default = pkgs.envfs;

     

       38
       38
       +
               defaultText = lib.mdDoc "pkgs.envfs";

     

       39
       39
       +
             };

     

       40
       40
       +
           };

     

       41
       41
       +
         };

     

       42
       42
       +
         config = lib.mkIf (cfg.enable) {

     

       43
       43
       +
           environment.systemPackages = [ cfg.package ];

     

       44
       44
       +
           # we also want these mounts in virtual machines.

     

       45
       45
       +
           fileSystems = if config.virtualisation ? qemu then lib.mkVMOverride mounts else mounts;

     

       46
       46
       +
       

     

       47
       47
       +
           # We no longer need those when using envfs

     

       48
       48
       +
           system.activationScripts.usrbinenv = lib.mkForce "";

     

       49
       49
       +
           system.activationScripts.binsh = lib.mkForce "";

     

       50
       50
       +
         };

     

       51
       51
       +
       }

nixos/tests/all-tests.nix

···

       195
       195
        
         engelsystem = handleTest ./engelsystem.nix {};

     

       196
       196
        
         enlightenment = handleTest ./enlightenment.nix {};

     

       197
       197
        
         env = handleTest ./env.nix {};

     

       198
       198
       +
         envfs = handleTest ./envfs.nix {};

     

       198
       199
        
         envoy = handleTest ./envoy.nix {};

     

       199
       200
        
         ergo = handleTest ./ergo.nix {};

     

       200
       201
        
         ergochat = handleTest ./ergochat.nix {};

+42

nixos/tests/envfs.nix

···

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

     

       2
       2
       +
       let

     

       3
       3
       +
         pythonShebang = pkgs.writeScript "python-shebang" ''

     

       4
       4
       +
           #!/usr/bin/python

     

       5
       5
       +
           print("OK")

     

       6
       6
       +
         '';

     

       7
       7
       +
       

     

       8
       8
       +
         bashShebang = pkgs.writeScript "bash-shebang" ''

     

       9
       9
       +
           #!/usr/bin/bash

     

       10
       10
       +
           echo "OK"

     

       11
       11
       +
         '';

     

       12
       12
       +
       in

     

       13
       13
       +
       {

     

       14
       14
       +
         name = "envfs";

     

       15
       15
       +
         nodes.machine.services.envfs.enable = true;

     

       16
       16
       +
       

     

       17
       17
       +
         testScript = ''

     

       18
       18
       +
           start_all()

     

       19
       19
       +
           machine.wait_until_succeeds("mountpoint -q /usr/bin/")

     

       20
       20
       +
           machine.succeed(

     

       21
       21
       +
               "PATH=${pkgs.coreutils}/bin /usr/bin/cp --version",

     

       22
       22
       +
               # check fallback paths

     

       23
       23
       +
               "PATH= /usr/bin/sh --version",

     

       24
       24
       +
               "PATH= /usr/bin/env --version",

     

       25
       25
       +
               "PATH= test -e /usr/bin/sh",

     

       26
       26
       +
               "PATH= test -e /usr/bin/env",

     

       27
       27
       +
               # no stat

     

       28
       28
       +
               "! test -e /usr/bin/cp",

     

       29
       29
       +
               # also picks up PATH that was set after execve

     

       30
       30
       +
               "! /usr/bin/hello",

     

       31
       31
       +
               "PATH=${pkgs.hello}/bin /usr/bin/hello",

     

       32
       32
       +
           )

     

       33
       33
       +
       

     

       34
       34
       +
           out = machine.succeed("PATH=${pkgs.python3}/bin ${pythonShebang}")

     

       35
       35
       +
           print(out)

     

       36
       36
       +
           assert out == "OK\n"

     

       37
       37
       +
       

     

       38
       38
       +
           out = machine.succeed("PATH=${pkgs.bash}/bin ${bashShebang}")

     

       39
       39
       +
           print(out)

     

       40
       40
       +
           assert out == "OK\n"

     

       41
       41
       +
         '';

     

       42
       42
       +
       })

nixos/tests/initrd-network-openvpn/default.nix

···

       91
       91
        
                   config = ''

     

       92
       92
        
                     dev tun0

     

       93
       93
        
                     ifconfig 10.8.0.1 10.8.0.2

     

       94
       94
       +
                     cipher AES-256-CBC

     

       94
       95
        
                     ${secretblock}

     

       95
       96
        
                   '';

     

       96
       97
        
                 };

+2 -1

nixos/tests/initrd-network-openvpn/initrd.ovpn

···

       3
       3
        
       ifconfig 10.8.0.2 10.8.0.1

     

       4
       4
        
       # Only force VLAN 2 through the VPN

     

       5
       5
        
       route 192.168.2.0 255.255.255.0 10.8.0.1

     

       6
       6
       +
       cipher AES-256-CBC

     

       6
       7
        
       secret [inline]

     

       7
       8
        
       <secret>

     

       8
       9
        
       #

     
···

       26
       27
        
       e7811584363597599cce2040a68ac00e

     

       27
       28
        
       f2125540e0f7f4adc37cb3f0d922eeb7

     

       28
       29
        
       -----END OpenVPN Static key V1-----

     

       29
       29
       -
       </secret>
     

       30
       30
       +
       </secret>

nixos/tests/trafficserver.nix

···

       172
       172
        
               assert re.fullmatch(expected, out) is not None, "no matching logs"

     

       173
       173
        
       

     

       174
       174
        
               out = json.loads(ats.succeed(f"traffic_logstats -jf {access_log_path}"))

     

       175
       175
       +
               assert isinstance(out, dict)

     

       175
       176
        
               assert out["total"]["error.total"]["req"] == "0", "unexpected log stat"

     

       176
       177
        
         '';

     

       177
       178
        
       })

+2 -2

pkgs/applications/editors/cpeditor/default.nix

···

       13
       13
        
       

     

       14
       14
        
       stdenv.mkDerivation rec {

     

       15
       15
        
         pname = "cpeditor";

     

       16
       16
       -
         version = "6.10.1";

     

       16
       16
       +
         version = "6.11.1";

     

       17
       17
        
       

     

       18
       18
        
         src = fetchFromGitHub {

     

       19
       19
        
           owner = "cpeditor";

     

       20
       20
        
           repo = "cpeditor";

     

       21
       21
        
           rev = version;

     

       22
       22
       -
           sha256 = "sha256-SIREoOapaZTLtqi0Z07lKmNqF9a9qIpgGxuhqaY3yfU=";

     

       22
       22
       +
           sha256 = "sha256-Uwo7ZE+9yrHV/+D6rvfew2d3ZJbpFOjgek38iYkPppw=";

     

       23
       23
        
           fetchSubmodules = true;

     

       24
       24
        
         };

     

       25
       25

+8 -1

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

···

       693
       693
        
           configurePhase = "cd vim";

     

       694
       694
        
         });

     

       695
       695
        
       

     

       696
       696
       +
         orgmode = super.orgmode.overrideAttrs (old: {

     

       697
       697
       +
           dependencies = with self; [ (nvim-treesitter.withPlugins (p: [ p.org ])) ];

     

       698
       698
       +
         });

     

       699
       699
       +
       

     

       696
       700
        
         inherit parinfer-rust;

     

       697
       701
        
       

     

       698
       702
        
         plenary-nvim = super.plenary-nvim.overrideAttrs (old: {

     
···

       715
       719
        
       

     

       716
       720
        
         # needs  "http" and "json" treesitter grammars too

     

       717
       721
        
         rest-nvim = super.rest-nvim.overrideAttrs (old: {

     

       718
       718
       -
           dependencies = with self; [ plenary-nvim ];

     

       722
       722
       +
           dependencies = with self; [

     

       723
       723
       +
             plenary-nvim

     

       724
       724
       +
             (nvim-treesitter.withPlugins (p: [ p.http p.json ]))

     

       725
       725
       +
           ];

     

       719
       726
        
         });

     

       720
       727
        
       

     

       721
       728
        
         skim = buildVimPluginFrom2Nix {

+39

pkgs/applications/emulators/bsnes/ares/002-sips-to-png2icns.patch

···

       1
       1
       +
       diff --git a/desktop-ui/GNUmakefile b/desktop-ui/GNUmakefile

     

       2
       2
       +
       index 4515610d3..916c8fcd8 100644

     

       3
       3
       +
       --- a/desktop-ui/GNUmakefile

     

       4
       4
       +
       +++ b/desktop-ui/GNUmakefile

     

       5
       5
       +
       @@ -91,7 +91,7 @@ endif

     

       6
       6
       +
        	cp resource/$(name).plist $(output.path)/$(name).app/Contents/Info.plist

     

       7
       7
       +
        	cp -R $(ares.path)/Shaders $(output.path)/$(name).app/Contents/Resources/

     

       8
       8
       +
        	cp -R $(mia.path)/Database $(output.path)/$(name).app/Contents/Resources/	

     

       9
       9
       +
       -	sips -s format icns resource/$(name).png --out $(output.path)/$(name).app/Contents/Resources/$(name).icns

     

       10
       10
       +
       +	png2icns $(output.path)/$(name).app/Contents/Resources/$(name).icns resource/$(name).png

     

       11
       11
       +
        	codesign --force --deep --options runtime --entitlements resource/$(name).selfsigned.entitlements --sign - $(output.path)/$(name).app

     

       12
       12
       +
        else ifeq ($(platform),windows)

     

       13
       13
       +
        	$(call mkdir,$(output.path)/Shaders/)

     

       14
       14
       +
       diff --git a/genius/GNUmakefile b/genius/GNUmakefile

     

       15
       15
       +
       index 5287309a8..8d80f9306 100644

     

       16
       16
       +
       --- a/genius/GNUmakefile

     

       17
       17
       +
       +++ b/genius/GNUmakefile

     

       18
       18
       +
       @@ -24,7 +24,7 @@ ifeq ($(platform),macos)

     

       19
       19
       +
        	mkdir -p $(output.path)/$(name).app/Contents/Resources/

     

       20
       20
       +
        	mv $(output.path)/$(name) $(output.path)/$(name).app/Contents/MacOS/$(name)

     

       21
       21
       +
        	cp data/$(name).plist $(output.path)/$(name).app/Contents/Info.plist

     

       22
       22
       +
       -	sips -s format icns data/$(name).png --$(output.path) $(output.path)/$(name).app/Contents/Resources/$(name).icns

     

       23
       23
       +
       +	png2icns $(output.path)/$(name).app/Contents/Resources/$(name).icns data/$(name).png

     

       24
       24
       +
        endif

     

       25
       25
       +
        

     

       26
       26
       +
        verbose: hiro.verbose nall.verbose all;

     

       27
       27
       +
       diff --git a/mia/GNUmakefile b/mia/GNUmakefile

     

       28
       28
       +
       index b6930b6df..7a51b5028 100644

     

       29
       29
       +
       --- a/mia/GNUmakefile

     

       30
       30
       +
       +++ b/mia/GNUmakefile

     

       31
       31
       +
       @@ -32,7 +32,7 @@ ifeq ($(platform),macos)

     

       32
       32
       +
        	mkdir -p $(output.path)/$(name).app/Contents/Resources/

     

       33
       33
       +
        	mv $(output.path)/$(name) $(output.path)/$(name).app/Contents/MacOS/$(name)

     

       34
       34
       +
        	cp resource/$(name).plist $(output.path)/$(name).app/Contents/Info.plist

     

       35
       35
       +
       -	sips -s format icns resource/$(name).png --out $(output.path)/$(name).app/Contents/Resources/$(name).icns

     

       36
       36
       +
       +	png2icns $(output.path)/$(name).app/Contents/Resources/$(name).icns resource/$(name).png

     

       37
       37
       +
        endif

     

       38
       38
       +
        

     

       39
       39
       +
        verbose: hiro.verbose nall.verbose all;

+23

pkgs/applications/emulators/bsnes/ares/003-fix-darwin-install.patch

···

       1
       1
       +
       diff --git a/desktop-ui/GNUmakefile b/desktop-ui/GNUmakefile

     

       2
       2
       +
       index 916c8fcd8..b767c1335 100644

     

       3
       3
       +
       --- a/desktop-ui/GNUmakefile

     

       4
       4
       +
       +++ b/desktop-ui/GNUmakefile

     

       5
       5
       +
       @@ -92,7 +92,6 @@ endif

     

       6
       6
       +
        	cp -R $(ares.path)/Shaders $(output.path)/$(name).app/Contents/Resources/

     

       7
       7
       +
        	cp -R $(mia.path)/Database $(output.path)/$(name).app/Contents/Resources/	

     

       8
       8
       +
        	png2icns $(output.path)/$(name).app/Contents/Resources/$(name).icns resource/$(name).png

     

       9
       9
       +
       -	codesign --force --deep --options runtime --entitlements resource/$(name).selfsigned.entitlements --sign - $(output.path)/$(name).app

     

       10
       10
       +
        else ifeq ($(platform),windows)

     

       11
       11
       +
        	$(call mkdir,$(output.path)/Shaders/)

     

       12
       12
       +
        	$(call mkdir,$(output.path)/Database/)

     

       13
       13
       +
       @@ -115,8 +114,8 @@ ifeq ($(platform),windows)

     

       14
       14
       +
        else ifeq ($(shell id -un),root)

     

       15
       15
       +
        	$(error "make install should not be run as root")

     

       16
       16
       +
        else ifeq ($(platform),macos)

     

       17
       17
       +
       -	mkdir -p ~/Library/Application\ Support/$(name)/

     

       18
       18
       +
       -	cp -R $(output.path)/$(name).app /Applications/$(name).app

     

       19
       19
       +
       +	mkdir -p $(prefix)/Applications/

     

       20
       20
       +
       +	cp -R $(output.path)/$(name).app $(prefix)/Applications/$(name).app

     

       21
       21
       +
        else ifneq ($(filter $(platform),linux bsd),)

     

       22
       22
       +
        	mkdir -p $(prefix)/bin/

     

       23
       23
       +
        	mkdir -p $(prefix)/share/applications/

+22 -4

pkgs/applications/emulators/bsnes/ares/default.nix

···

       3
       3
        
       , fetchFromGitHub

     

       4
       4
        
       , pkg-config

     

       5
       5
        
       , wrapGAppsHook

     

       6
       6
       +
       , libicns

     

       6
       7
        
       , SDL2

     

       7
       8
        
       , alsa-lib

     

       8
       9
        
       , gtk3

     
···

       15
       16
        
       , libpulseaudio

     

       16
       17
        
       , openal

     

       17
       18
        
       , udev

     

       19
       19
       +
       , darwin

     

       18
       20
        
       }:

     

       19
       21
        
       

     

       22
       22
       +
       let

     

       23
       23
       +
         inherit (darwin.apple_sdk_11_0.frameworks) Cocoa OpenAL;

     

       24
       24
       +
       in

     

       20
       25
        
       stdenv.mkDerivation (finalAttrs: {

     

       21
       26
        
         pname = "ares";

     

       22
       27
        
         version = "130.1";

     
···

       31
       36
        
         patches = [

     

       32
       37
        
           ./000-dont-rebuild-on-install.patch

     

       33
       38
        
           ./001-fix-ruby.patch

     

       39
       39
       +
           ./002-sips-to-png2icns.patch

     

       40
       40
       +
           ./003-fix-darwin-install.patch

     

       34
       41
        
         ];

     

       35
       42
        
       

     

       36
       43
        
         nativeBuildInputs = [

     

       37
       44
        
           pkg-config

     

       38
       45
        
           wrapGAppsHook

     

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

     

       47
       47
       +
           libicns

     

       39
       48
        
         ];

     

       40
       49
        
       

     

       41
       50
        
         buildInputs = [

     

       42
       51
        
           SDL2

     

       52
       52
       +
           libao

     

       53
       53
       +
         ] ++ lib.optionals stdenv.isLinux [

     

       43
       54
        
           alsa-lib

     

       44
       55
        
           gtk3

     

       45
       56
        
           gtksourceview3

     
···

       47
       58
        
           libGLU

     

       48
       59
        
           libX11

     

       49
       60
        
           libXv

     

       50
       50
       -
           libao

     

       51
       61
        
           libpulseaudio

     

       52
       62
        
           openal

     

       53
       63
        
           udev

     

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

     

       65
       65
       +
           Cocoa

     

       66
       66
       +
           OpenAL

     

       54
       67
        
         ];

     

       55
       68
        
       

     

       56
       69
        
         enableParallelBuilding = true;

     

       57
       70
        
       

     

       58
       58
       -
         makeFlags = [

     

       71
       71
       +
         makeFlags = lib.optionals stdenv.isLinux [

     

       59
       72
        
           "hiro=gtk3"

     

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

     

       74
       74
       +
           "hiro=cocoa"

     

       75
       75
       +
           "vulkan=false"

     

       76
       76
       +
         ] ++ [

     

       60
       77
        
           "local=false"

     

       61
       78
        
           "openmp=true"

     

       62
       79
        
           "prefix=$(out)"

     

       63
       80
        
           "-C desktop-ui"

     

       64
       81
        
         ];

     

       82
       82
       +
       

     

       83
       83
       +
         NIX_CFLAGS_COMPILE = lib.optionalString stdenv.isDarwin "-mmacosx-version-min=10.14";

     

       65
       84
        
       

     

       66
       85
        
         meta = with lib; {

     

       67
       86
        
           homepage = "https://ares-emu.net";

     

       68
       87
        
           description = "Open-source multi-system emulator with a focus on accuracy and preservation";

     

       69
       88
        
           license = licenses.isc;

     

       70
       89
        
           maintainers = with maintainers; [ Madouura AndersonTorres ];

     

       71
       71
       -
           platforms = platforms.linux;

     

       90
       90
       +
           platforms = platforms.unix;

     

       72
       91
        
         };

     

       73
       92
        
       })

     

       74
       93
        
       # TODO: select between Qt, GTK2 and GTK3

     

       75
       75
       -
       # TODO: support Darwin

+7 -2

pkgs/applications/networking/freefilesync/default.nix

···

       9
       9
        
       , libssh2

     

       10
       10
        
       , openssl

     

       11
       11
        
       , wxGTK32

     

       12
       12
       +
       , gitUpdater

     

       12
       13
        
       }:

     

       13
       14
        
       

     

       14
       15
        
       gcc12Stdenv.mkDerivation rec {

     

       15
       16
        
         pname = "freefilesync";

     

       16
       16
       -
         version = "11.28";

     

       17
       17
       +
         version = "11.29";

     

       17
       18
        
       

     

       18
       19
        
         src = fetchFromGitHub {

     

       19
       20
        
           owner = "hkneptune";

     

       20
       21
        
           repo = "FreeFileSync";

     

       21
       22
        
           rev = "v${version}";

     

       22
       22
       -
           sha256 = "sha256-3eYvXClMdOCdl35S1d7nP2kiYZZOjyydi2gKY62K/qM=";

     

       23
       23
       +
           sha256 = "sha256-UQ+CWqtcTwMGUTn6t3N+BkXs4qxddZtxDjcq7nz5F6U=";

     

       23
       24
        
         };

     

       24
       25
        
       

     

       25
       26
        
         # Patches from ROSA Linux

     
···

       87
       88
        
       

     

       88
       89
        
           runHook postInstall

     

       89
       90
        
         '';

     

       91
       91
       +
       

     

       92
       92
       +
         passthru.updateScript = gitUpdater {

     

       93
       93
       +
           rev-prefix = "v";

     

       94
       94
       +
         };

     

       90
       95
        
       

     

       91
       96
        
         meta = with lib; {

     

       92
       97
        
           description = "Open Source File Synchronization & Backup Software";

+3 -3

pkgs/applications/virtualization/colima/default.nix

···

       11
       11
        
       

     

       12
       12
        
       buildGoModule rec {

     

       13
       13
        
         pname = "colima";

     

       14
       14
       -
         version = "0.5.0";

     

       14
       14
       +
         version = "0.5.2";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "abiosoft";

     

       18
       18
        
           repo = pname;

     

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

     

       20
       20
       -
           sha256 = "sha256-Ey/h9W1WFMJdO5U9IeHhVTYDEJi8w18h2PY0lB0S/BU=";

     

       20
       20
       +
           sha256 = "sha256-xw+Yy9KejVkunOLJdmfXstP7aDrl3j0OZjCaf6pyL1U=";

     

       21
       21
        
           # We need the git revision

     

       22
       22
        
           leaveDotGit = true;

     

       23
       23
        
           postFetch = ''

     
···

       28
       28
        
       

     

       29
       29
        
         nativeBuildInputs = [ installShellFiles makeWrapper ];

     

       30
       30
        
       

     

       31
       31
       -
         vendorSha256 = "sha256-v0U7TorUwOtBzBQ/OQQSAX6faDI1IX/IDIJnY8UFsu8=";

     

       31
       31
       +
         vendorSha256 = "sha256-Iz1LYL25NpkztTM86zrLwehub8FzO1IlwZqCPW7wDN4=";

     

       32
       32
        
       

     

       33
       33
        
         CGO_ENABLED = 1;

     

       34
       34

+4 -4

pkgs/data/misc/hackage/pin.json

···

       1
       1
        
       {

     

       2
       2
       -
         "commit": "d2f407d64c568ff572505378248cd834f808f6e0",

     

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

     

       4
       4
       -
         "sha256": "0agbmi2gjrg5gnp8dy76770lyh3ny42clm55wlr529320wnc14wm",

     

       5
       5
       -
         "msg": "Update from Hackage at 2022-12-18T22:10:13Z"

     

       2
       2
       +
         "commit": "b88b3496b1b3beb0c706db8a39c0da3396d96f0b",

     

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

     

       4
       4
       +
         "sha256": "0gs807cbyi6zyk9bvg5d3wx16575pmgv4j3m8hbz57aa5i71r0nv",

     

       5
       5
       +
         "msg": "Update from Hackage at 2022-12-24T13:11:25Z"

     

       6
       6
        
       }

+1 -1

pkgs/desktops/gnome/apps/gnome-music/default.nix

···

       107
       107
        
           description = "Music player and management application for the GNOME desktop environment";

     

       108
       108
        
           maintainers = teams.gnome.members;

     

       109
       109
        
           license = licenses.gpl2Plus;

     

       110
       110
       -
           platforms = platforms.linux;

     

       110
       110
       +
           platforms = platforms.unix;

     

       111
       111
        
         };

     

       112
       112
        
       }

+1 -1

pkgs/desktops/gnome/core/baobab/default.nix

···

       69
       69
        
           homepage = "https://wiki.gnome.org/Apps/DiskUsageAnalyzer";

     

       70
       70
        
           license = licenses.gpl2Plus;

     

       71
       71
        
           maintainers = teams.gnome.members;

     

       72
       72
       -
           platforms = platforms.linux;

     

       72
       72
       +
           platforms = platforms.unix;

     

       73
       73
        
         };

     

       74
       74
        
       }

+1 -1

pkgs/desktops/gnome/core/dconf-editor/default.nix

···

       73
       73
        
           homepage = "https://wiki.gnome.org/Apps/DconfEditor";

     

       74
       74
        
           license = licenses.gpl3Plus;

     

       75
       75
        
           maintainers = teams.gnome.members;

     

       76
       76
       -
           platforms = platforms.linux;

     

       76
       76
       +
           platforms = platforms.unix;

     

       77
       77
        
         };

     

       78
       78
        
       }

+1 -1

pkgs/desktops/gnome/core/gnome-calculator/default.nix

···

       76
       76
        
           description = "Application that solves mathematical equations and is suitable as a default application in a Desktop environment";

     

       77
       77
        
           maintainers = teams.gnome.members;

     

       78
       78
        
           license = licenses.gpl3Plus;

     

       79
       79
       -
           platforms = platforms.linux;

     

       79
       79
       +
           platforms = platforms.unix;

     

       80
       80
        
         };

     

       81
       81
        
       }

+1 -1

pkgs/desktops/gnome/core/gnome-dictionary/default.nix

···

       80
       80
        
           description = "Dictionary is the GNOME application to look up definitions";

     

       81
       81
        
           maintainers = teams.gnome.members;

     

       82
       82
        
           license = licenses.gpl2;

     

       83
       83
       -
           platforms = platforms.linux;

     

       83
       83
       +
           platforms = platforms.unix;

     

       84
       84
        
         };

     

       85
       85
        
       }

+1 -1

pkgs/desktops/gnome/core/gnome-font-viewer/default.nix

···

       61
       61
        
           homepage = "https://gitlab.gnome.org/GNOME/gnome-font-viewer";

     

       62
       62
        
           maintainers = teams.gnome.members;

     

       63
       63
        
           license = licenses.gpl2Plus;

     

       64
       64
       -
           platforms = platforms.linux;

     

       64
       64
       +
           platforms = platforms.unix;

     

       65
       65
        
         };

     

       66
       66
        
       }

+1 -1

pkgs/desktops/gnome/core/gnome-themes-extra/default.nix

···

       29
       29
        
         '';

     

       30
       30
        
       

     

       31
       31
        
         meta = with lib; {

     

       32
       32
       -
           platforms = platforms.linux;

     

       32
       32
       +
           platforms = platforms.unix;

     

       33
       33
        
           maintainers = teams.gnome.members;

     

       34
       34
        
         };

     

       35
       35
        
       }

+5 -5

pkgs/desktops/gnome/extensions/paperwm/default.nix

···

       3
       3
        
       , fetchFromGitHub

     

       4
       4
        
       }:

     

       5
       5
        
       

     

       6
       6
       -
       stdenv.mkDerivation (finalAttrs: {

     

       6
       6
       +
       stdenv.mkDerivation {

     

       7
       7
        
         pname = "gnome-shell-extension-paperwm";

     

       8
       8
       -
         version = "38.2";

     

       8
       8
       +
         version = "unstable-2022-12-14";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "paperwm";

     

       12
       12
        
           repo = "PaperWM";

     

       13
       13
       -
           rev = finalAttrs.version;

     

       14
       14
       -
           hash = "sha256-Unhz2+MOygOog6B5sOLtYTpdeodQH+/CMI93gC5nDvI=";

     

       13
       13
       +
           rev = "7c0863c944a02d4e8095034403bff6ade3579091";

     

       14
       14
       +
           hash = "sha256-EN0sWW/NymRNKrApeFnqg8ax7Et4hr0gKZuvMF4kJYU=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         dontConfigure = true;

     
···

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         passthru.extensionUuid = "paperwm@hedning:matrix.org";

     

       36
       36
       -
       })

     

       36
       36
       +
       }

+5 -3

pkgs/development/compilers/ligo/default.nix

···

       1
       1
       -
       { lib

     

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , lib

     

       2
       3
        
       , fetchFromGitLab

     

       3
       4
        
       , git

     

       4
       5
        
       , coq

     
···

       9
       10
        
       

     

       10
       11
        
       ocamlPackages.buildDunePackage rec {

     

       11
       12
        
         pname = "ligo";

     

       12
       12
       -
         version = "0.55.0";

     

       13
       13
       +
         version = "0.58.0";

     

       13
       14
        
         src = fetchFromGitLab {

     

       14
       15
        
           owner = "ligolang";

     

       15
       16
        
           repo = "ligo";

     

       16
       17
        
           rev = version;

     

       17
       17
       -
           sha256 = "sha256-GEw9OEHXdTxBvb5ATIcL71wdUCLD+X/A7CYQxwTUQWw=";

     

       18
       18
       +
           sha256 = "sha256-WhqCkPkXHjWS8BDh13ODrHg2AHJ8CBfksTH4Fxx4xek=";

     

       18
       19
        
           fetchSubmodules = true;

     

       19
       20
        
         };

     

       20
       21
        
       

     
···

       108
       109
        
           description = "A friendly Smart Contract Language for Tezos";

     

       109
       110
        
           license = licenses.mit;

     

       110
       111
        
           platforms = ocamlPackages.ocaml.meta.platforms;

     

       112
       112
       +
           broken = stdenv.isLinux && stdenv.isAarch64;

     

       111
       113
        
           maintainers = with maintainers; [ ulrikstrid ];

     

       112
       114
        
         };

     

       113
       115
        
       }

+8 -7

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

···

       744
       744
        
           testHaskellDepends = drv.testHaskellDepends or [] ++ [ self.hspec-meta_2_10_5 ];

     

       745
       745
        
           testToolDepends = drv.testToolDepends or [] ++ [ pkgs.git ];

     

       746
       746
        
         }) (super.sensei.override {

     

       747
       747
       -
           hspec = self.hspec_2_10_7;

     

       747
       747
       +
           hspec = self.hspec_2_10_8;

     

       748
       748
        
           hspec-wai = super.hspec-wai.override {

     

       749
       749
       -
             hspec = self.hspec_2_10_7;

     

       749
       749
       +
             hspec = self.hspec_2_10_8;

     

       750
       750
        
           };

     

       751
       751
        
         });

     

       752
       752
        
       

     
···

       1440
       1440
        
         servant-openapi3 = dontCheck super.servant-openapi3;

     

       1441
       1441
        
       

     

       1442
       1442
        
         # Give hspec 2.10.* correct dependency versions without overrideScope

     

       1443
       1443
       -
         hspec_2_10_7 = doDistribute (super.hspec_2_10_7.override {

     

       1444
       1444
       -
           hspec-discover = self.hspec-discover_2_10_7;

     

       1445
       1445
       -
           hspec-core = self.hspec-core_2_10_7;

     

       1443
       1443
       +
         hspec_2_10_8 = doDistribute (super.hspec_2_10_8.override {

     

       1444
       1444
       +
           hspec-discover = self.hspec-discover_2_10_8;

     

       1445
       1445
       +
           hspec-core = self.hspec-core_2_10_8;

     

       1446
       1446
        
         });

     

       1447
       1447
       -
         hspec-discover_2_10_7 = super.hspec-discover_2_10_7.override {

     

       1447
       1447
       +
         hspec-discover_2_10_8 = super.hspec-discover_2_10_8.override {

     

       1448
       1448
        
           hspec-meta = self.hspec-meta_2_10_5;

     

       1449
       1449
        
         };

     

       1450
       1450
       -
         hspec-core_2_10_7 = super.hspec-core_2_10_7.override {

     

       1450
       1450
       +
         hspec-core_2_10_8 = super.hspec-core_2_10_8.override {

     

       1451
       1451
        
           hspec-meta = self.hspec-meta_2_10_5;

     

       1452
       1452
        
         };

     

       1453
       1453
        
       

     
···

       2214
       2214
        
       

     

       2215
       2215
        
         # Too strict upper bound on th-desugar, fixed in 3.1.1

     

       2216
       2216
        
         singletons-th = assert super.singletons-th.version == "3.1"; doJailbreak super.singletons-th;

     

       2217
       2217
       +
         singletons-base = doJailbreak super.singletons-base;

     

       2217
       2218
        
       

     

       2218
       2219
        
         # Ships a broken Setup.hs

     

       2219
       2220
        
         # https://github.com/lehins/conduit-aeson/issues/1

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

···

       176
       176
        
         # Later versions only support GHC >= 9.2

     

       177
       177
        
         ghc-exactprint = self.ghc-exactprint_0_6_4;

     

       178
       178
        
         apply-refact = self.apply-refact_0_9_3_0;

     

       179
       179
       +
       

     

       180
       180
       +
         # Needs OneTuple for ghc < 9.2

     

       181
       181
       +
         binary-orphans = addBuildDepends [ self.OneTuple ] super.binary-orphans;

     

       179
       182
        
       }

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

···

       205
       205
        
         # https://github.com/mrkkrp/megaparsec/pull/485#issuecomment-1250051823

     

       206
       206
        
         megaparsec = doJailbreak super.megaparsec;

     

       207
       207
        
       

     

       208
       208
       +
         # Needs OneTuple for ghc < 9.2

     

       209
       209
       +
         binary-orphans = addBuildDepends [ self.OneTuple ] super.binary-orphans;

     

       210
       210
       +
       

     

       208
       211
        
         # Later versions only support GHC >= 9.2

     

       209
       212
        
         ghc-exactprint = self.ghc-exactprint_0_6_4;

     

       210
       213
        
         apply-refact = self.apply-refact_0_9_3_0;

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

···

       178
       178
        
         # Later versions only support GHC >= 9.2

     

       179
       179
        
         ghc-exactprint = self.ghc-exactprint_0_6_4;

     

       180
       180
        
         apply-refact = self.apply-refact_0_9_3_0;

     

       181
       181
       +
       

     

       182
       182
       +
         # Needs OneTuple for ghc < 9.2

     

       183
       183
       +
         binary-orphans = addBuildDepends [ self.OneTuple ] super.binary-orphans;

     

       181
       184
        
       }

+3 -3

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

···

       112
       112
        
         # Note: Any compilation fixes need to be done on the versioned attributes,

     

       113
       113
        
         # since those are used for the internal dependencies between the versioned

     

       114
       114
        
         # hspec packages in configuration-common.nix.

     

       115
       115
       -
         hspec = self.hspec_2_10_7;

     

       116
       116
       -
         hspec-core = self.hspec-core_2_10_7;

     

       115
       115
       +
         hspec = self.hspec_2_10_8;

     

       116
       116
       +
         hspec-core = self.hspec-core_2_10_8;

     

       117
       117
        
         hspec-meta = self.hspec-meta_2_10_5;

     

       118
       118
       -
         hspec-discover = self.hspec-discover_2_10_7;

     

       118
       118
       +
         hspec-discover = self.hspec-discover_2_10_8;

     

       119
       119
        
       

     

       120
       120
        
         # the dontHaddock is due to a GHC panic. might be this bug, not sure.

     

       121
       121
        
         # https://gitlab.haskell.org/ghc/ghc/-/issues/21619

+8 -1

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

···

       633
       633
        
         - CC-delcont-ref-tf

     

       634
       634
        
         - cci

     

       635
       635
        
         - ccnx

     

       636
       636
       +
         - cdp

     

       636
       637
        
         - c-dsl

     

       637
       638
        
         - cedict

     

       638
       639
        
         - cef

     
···

       1099
       1100
        
         - derive-lifted-instances

     

       1100
       1101
        
         - derive-monoid

     

       1101
       1102
        
         - derive-trie

     

       1103
       1103
       +
         - deriving-openapi3

     

       1102
       1104
        
         - derp-lib

     

       1103
       1105
        
         - describe

     

       1104
       1106
        
         - descriptive

     
···

       1317
       1319
        
         - ekg-rrd

     

       1318
       1320
        
         - ekg-statsd

     

       1319
       1321
        
         - elevator

     

       1322
       1322
       +
         - eliminators

     

       1320
       1323
        
         - elision

     

       1321
       1324
        
         - elm-export-persistent

     

       1322
       1325
        
         - elm-street

     
···

       1575
       1578
        
         - forml

     

       1576
       1579
        
         - formura

     

       1577
       1580
        
         - Fortnite-Hack-Cheats-Free-V-Bucks-Generator

     

       1581
       1581
       +
         - fortran-src-extras

     

       1578
       1582
        
         - foscam-filename

     

       1579
       1583
        
         - fpe

     

       1580
       1584
        
         - FPretty

     
···

       2212
       2216
        
         - heterogeneous-list-literals

     

       2213
       2217
        
         - hetris

     

       2214
       2218
        
         - heukarya

     

       2219
       2219
       +
         - hevm

     

       2215
       2220
        
         - HExcel

     

       2216
       2221
        
         - hexchat

     

       2217
       2222
        
         - hexif

     
···

       3274
       3279
        
         - medium-sdk-haskell

     

       3275
       3280
        
         - meep

     

       3276
       3281
        
         - megalisp

     

       3282
       3282
       +
         - melf

     

       3277
       3283
        
         - mellon-core

     

       3278
       3284
        
         - melody

     

       3279
       3285
        
         - membrain

     
···

       4783
       4789
        
         - simplistic-generics

     

       4784
       4790
        
         - singlethongs

     

       4785
       4791
        
         - singleton-dict

     

       4786
       4786
       -
         - singletons-base

     

       4787
       4792
        
         - singleton-typelits

     

       4788
       4793
        
         - single-tuple

     

       4789
       4794
        
         - singnal

     
···

       5501
       5506
        
         - ui-command

     

       5502
       5507
        
         - unamb-custom

     

       5503
       5508
        
         - unbeliever

     

       5509
       5509
       +
         - unbounded-delays-units

     

       5504
       5510
        
         - unboxed

     

       5505
       5511
        
         - unboxed-containers

     

       5506
       5512
        
         - unboxed-references

     
···

       5521
       5527
        
         - uniqueness-periods-general

     

       5522
       5528
        
         - uniqueness-periods-vector

     

       5523
       5529
        
         - uniqueness-periods-vector-common

     

       5530
       5530
       +
         - units-attoparsec

     

       5524
       5531
        
         - unittyped

     

       5525
       5532
        
         - unitym-yesod

     

       5526
       5533
        
         - uni-util

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

···

       86
       86
        
         # hnix < 0.17 (unreleased) needs hnix-store-* 0.5.*

     

       87
       87
        
         - hnix-store-core == 0.5.0.0            # 2022-06-17: Until hnix 0.17

     

       88
       88
        
         - hnix-store-remote == 0.5.0.0        # 2022-06-17: Until hnix 0.17

     

       89
       89
       +
         # reflex-dom-core 0.7.0.2 has no reflex 0.9 compatible release and most likely most people will want to use them together

     

       90
       90
       +
         - reflex < 0.9.0.0

     

       89
       91
        
       

     

       90
       92
        
       extra-packages:

     

       91
       93
        
         - Cabal == 2.2.*                      # required for jailbreak-cabal etc.

+9 -14

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

···

       1331
       1331
        
        - elasticsearch-interchange

     

       1332
       1332
        
        - electrs-client

     

       1333
       1333
        
        - elerea-examples

     

       1334
       1334
       -
        - eliminators

     

       1335
       1335
       -
        - eliminators_0_9_1

     

       1336
       1334
        
        - elliptic-curve

     

       1337
       1335
        
        - elsa

     

       1338
       1336
        
        - emacs-keys

     
···

       1363
       1361
        
        - essence-of-live-coding-PortMidi

     

       1364
       1362
        
        - essence-of-live-coding-gloss

     

       1365
       1363
        
        - essence-of-live-coding-gloss-example

     

       1364
       1364
       +
        - essence-of-live-coding-gloss_0_2_7

     

       1366
       1365
        
        - essence-of-live-coding-pulse

     

       1367
       1366
        
        - essence-of-live-coding-pulse-example

     

       1367
       1367
       +
        - essence-of-live-coding-pulse_0_2_7

     

       1368
       1368
        
        - essence-of-live-coding-quickcheck

     

       1369
       1369
       +
        - essence-of-live-coding-quickcheck_0_2_7

     

       1369
       1370
        
        - essence-of-live-coding-vivid

     

       1370
       1371
        
        - essence-of-live-coding-warp

     

       1372
       1372
       +
        - essence-of-live-coding-warp_0_2_7

     

       1371
       1373
        
        - estimators

     

       1372
       1374
        
        - estreps

     

       1373
       1375
        
        - eternity

     
···

       1392
       1394
        
        - eventsource-geteventstore-store

     

       1393
       1395
        
        - eventsource-store-specs

     

       1394
       1396
        
        - eventsource-stub-store

     

       1397
       1397
       +
        - eventuo11y

     

       1398
       1398
       +
        - eventuo11y-batteries

     

       1399
       1399
       +
        - eventuo11y-json

     

       1395
       1400
        
        - every-bit-counts

     

       1396
       1401
        
        - ewe

     

       1397
       1402
        
        - exference

     
···

       1490
       1495
        
        - fmt-for-rio

     

       1491
       1496
        
        - foldable1

     

       1492
       1497
        
        - follower

     

       1498
       1498
       +
        - fontconfig-pure

     

       1493
       1499
        
        - foo

     

       1494
       1500
        
        - format

     

       1495
       1501
        
        - format-status

     
···

       1497
       1503
        
        - formlets-hsp

     

       1498
       1504
        
        - forsyde-deep

     

       1499
       1505
        
        - forth-hll

     

       1500
       1500
       -
        - fortran-src

     

       1501
       1501
       -
        - fortran-src-extras

     

       1502
       1506
        
        - fortran-vars

     

       1503
       1507
        
        - foscam-directory

     

       1504
       1508
        
        - foscam-sort

     
···

       2118
       2122
        
        - hesh

     

       2119
       2123
        
        - hesql

     

       2120
       2124
        
        - heterolist

     

       2121
       2121
       -
        - hevm

     

       2122
       2125
        
        - hevolisa

     

       2123
       2126
        
        - hevolisa-dph

     

       2124
       2127
        
        - hexpat-conduit

     
···

       2739
       2742
        
        - medea

     

       2740
       2743
        
        - mediabus-fdk-aac

     

       2741
       2744
        
        - mediabus-rtp

     

       2742
       2742
       -
        - melf

     

       2743
       2745
        
        - mellon-gpio

     

       2744
       2746
        
        - mellon-web

     

       2745
       2747
        
        - memcache-conduit

     
···

       2994
       2996
        
        - optimal-blocks

     

       2995
       2997
        
        - optimusprime

     

       2996
       2998
        
        - optparse-enum

     

       2997
       2997
       -
        - orbits

     

       2998
       2999
        
        - orchid

     

       2999
       3000
        
        - orchid-demo

     

       3000
       3001
        
        - order-maintenance

     
···

       3391
       3392
        
        - rfc-redis

     

       3392
       3393
        
        - rfc-servant

     

       3393
       3394
        
        - rhine-gloss

     

       3395
       3395
       +
        - rhine-terminal

     

       3394
       3396
        
        - rhythm-game-tutorial

     

       3395
       3397
        
        - rib

     

       3396
       3398
        
        - ribosome

     
···

       3597
       3599
        
        - simple-session

     

       3598
       3600
        
        - simpleirc-lens

     

       3599
       3601
        
        - simseq

     

       3600
       3600
       -
        - singleton-nats

     

       3601
       3601
       -
        - singletons-presburger

     

       3602
       3602
       -
        - singletons-presburger_0_7_1_0

     

       3603
       3602
        
        - siphon

     

       3604
       3603
        
        - siren-json

     

       3605
       3604
        
        - sirkel

     
···

       4009
       4008
        
        - ukrainian-phonetics-basic

     

       4010
       4009
        
        - unagi-bloomfilter

     

       4011
       4010
        
        - unbound

     

       4012
       4012
       -
        - unbounded-delays-units

     

       4013
       4011
        
        - uni-events

     

       4014
       4012
        
        - uni-graphs

     

       4015
       4013
        
        - uni-htk

     
···

       4023
       4021
        
        - uniqueness-periods-vector-filters

     

       4024
       4022
        
        - uniqueness-periods-vector-general

     

       4025
       4023
        
        - uniqueness-periods-vector-properties

     

       4026
       4026
       -
        - units

     

       4027
       4027
       -
        - units-attoparsec

     

       4028
       4028
       -
        - units-defs

     

       4029
       4024
        
        - universal

     

       4030
       4025
        
        - universe

     

       4031
       4026
        
        - universe-dependent-sum

+1025 -212

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

···

       11140
       11140
        
              license = lib.licenses.publicDomain;

     

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

     

       11142
       11142
        
       

     

       11143
       11143
       -
         "HsOpenSSL_0_11_7_3" = callPackage

     

       11143
       11143
       +
         "HsOpenSSL_0_11_7_4" = callPackage

     

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

     

       11145
       11145
        
            mkDerivation {

     

       11146
       11146
        
              pname = "HsOpenSSL";

     

       11147
       11147
       -
              version = "0.11.7.3";

     

       11148
       11148
       -
              sha256 = "0nb5rwz5rnyn4vzkl231r3maw4j4q9l92w07dxqyd1929p9yajgl";

     

       11149
       11149
       -
              revision = "1";

     

       11150
       11150
       -
              editedCabalFile = "03kaaxaxmggyn2zmsf4d8466j986sm5dw228ypf82nh6rmmzhfxj";

     

       11147
       11147
       +
              version = "0.11.7.4";

     

       11148
       11148
       +
              sha256 = "0zxcfa8b0ng97v53vb8fvg2gss89b28xiz83rx38a0h4lsxpn2xf";

     

       11151
       11149
        
              setupHaskellDepends = [ base Cabal ];

     

       11152
       11150
        
              libraryHaskellDepends = [ base bytestring network time ];

     

       11153
       11151
        
              librarySystemDepends = [ openssl ];

     
···

       21268
       21266
        
              pname = "Unique";

     

       21269
       21267
        
              version = "0.4.7.9";

     

       21270
       21268
        
              sha256 = "14f1qnmhdmbam8qis725dhwq1mk9h86fsnzhkwhsx73ny9z29s1l";

     

       21269
       21269
       +
              revision = "1";

     

       21270
       21270
       +
              editedCabalFile = "10s0npnfkh7naj49afmyrvnilikp6426fbhi49f97pxrgcmy4dvw";

     

       21271
       21271
        
              libraryHaskellDepends = [

     

       21272
       21272
        
                base containers extra hashable unordered-containers

     

       21273
       21273
        
              ];

     
···

       26323
       26323
        
            }:

     

       26324
       26324
        
            mkDerivation {

     

       26325
       26325
        
              pname = "aeson-tiled";

     

       26326
       26326
       -
              version = "0.0.2.1";

     

       26327
       26327
       -
              sha256 = "0fm2dkp0gi5h8xv6b3ax5v5ni7gkdvj8m2v1nrmf7hcyan0lp2aa";

     

       26326
       26326
       +
              version = "0.0.2.2";

     

       26327
       26327
       +
              sha256 = "1p2w19gmlrcdsni7dj2bs3ajzn8a5460gwas97yl930gwiwivyif";

     

       26328
       26328
        
              libraryHaskellDepends = [

     

       26329
       26329
        
                aeson base bytestring containers text vector

     

       26330
       26330
        
              ];

     
···

       31804
       31804
        
              license = lib.licenses.gpl3Only;

     

       31805
       31805
        
            }) {};

     

       31806
       31806
        
       

     

       31807
       31807
       +
         "ansi-terminal-game_1_8_1_0" = callPackage

     

       31808
       31808
       +
           ({ mkDerivation, ansi-terminal, array, base, bytestring, cereal

     

       31809
       31809
       +
            , clock, colour, containers, exceptions, hspec, hspec-discover

     

       31810
       31810
       +
            , linebreak, mintty, mtl, QuickCheck, random, split, terminal-size

     

       31811
       31811
       +
            , timers-tick, unidecode

     

       31812
       31812
       +
            }:

     

       31813
       31813
       +
            mkDerivation {

     

       31814
       31814
       +
              pname = "ansi-terminal-game";

     

       31815
       31815
       +
              version = "1.8.1.0";

     

       31816
       31816
       +
              sha256 = "0wyx6g9fydbnz9xwjniymwfgn3fgn6vql9spmzl3c1hlpbv5ikfq";

     

       31817
       31817
       +
              isLibrary = true;

     

       31818
       31818
       +
              isExecutable = true;

     

       31819
       31819
       +
              libraryHaskellDepends = [

     

       31820
       31820
       +
                ansi-terminal array base bytestring cereal clock colour containers

     

       31821
       31821
       +
                exceptions linebreak mintty mtl QuickCheck random split

     

       31822
       31822
       +
                terminal-size timers-tick unidecode

     

       31823
       31823
       +
              ];

     

       31824
       31824
       +
              testHaskellDepends = [

     

       31825
       31825
       +
                ansi-terminal array base bytestring cereal clock colour containers

     

       31826
       31826
       +
                exceptions hspec linebreak mintty mtl QuickCheck random split

     

       31827
       31827
       +
                terminal-size timers-tick unidecode

     

       31828
       31828
       +
              ];

     

       31829
       31829
       +
              testToolDepends = [ hspec-discover ];

     

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

     

       31831
       31831
       +
              license = lib.licenses.gpl3Only;

     

       31832
       31832
       +
              hydraPlatforms = lib.platforms.none;

     

       31833
       31833
       +
            }) {};

     

       31834
       31834
       +
       

     

       31807
       31835
        
         "ansi-wl-pprint" = callPackage

     

       31808
       31836
        
           ({ mkDerivation, ansi-terminal, base }:

     

       31809
       31837
        
            mkDerivation {

     
···

       33470
       33498
        
              mainProgram = "refactor";

     

       33471
       33499
        
            }) {};

     

       33472
       33500
        
       

     

       33501
       33501
       +
         "apply-refact_0_11_0_0" = callPackage

     

       33502
       33502
       +
           ({ mkDerivation, base, containers, directory, extra, filemanip

     

       33503
       33503
       +
            , filepath, ghc, ghc-boot-th, ghc-exactprint, ghc-paths

     

       33504
       33504
       +
            , optparse-applicative, process, refact, silently, syb, tasty

     

       33505
       33505
       +
            , tasty-expected-failure, tasty-golden, transformers, uniplate

     

       33506
       33506
       +
            , unix-compat

     

       33507
       33507
       +
            }:

     

       33508
       33508
       +
            mkDerivation {

     

       33509
       33509
       +
              pname = "apply-refact";

     

       33510
       33510
       +
              version = "0.11.0.0";

     

       33511
       33511
       +
              sha256 = "1bmm9s8h5grqp1c8m1x9icbhznfc565za8w3sqfpiylid7c7fz72";

     

       33512
       33512
       +
              isLibrary = true;

     

       33513
       33513
       +
              isExecutable = true;

     

       33514
       33514
       +
              libraryHaskellDepends = [

     

       33515
       33515
       +
                base containers directory extra filemanip ghc ghc-boot-th

     

       33516
       33516
       +
                ghc-exactprint ghc-paths process refact syb transformers uniplate

     

       33517
       33517
       +
                unix-compat

     

       33518
       33518
       +
              ];

     

       33519
       33519
       +
              executableHaskellDepends = [

     

       33520
       33520
       +
                base containers directory extra filemanip filepath ghc ghc-boot-th

     

       33521
       33521
       +
                ghc-exactprint ghc-paths optparse-applicative process refact syb

     

       33522
       33522
       +
                transformers uniplate unix-compat

     

       33523
       33523
       +
              ];

     

       33524
       33524
       +
              testHaskellDepends = [

     

       33525
       33525
       +
                base containers directory extra filemanip filepath ghc ghc-boot-th

     

       33526
       33526
       +
                ghc-exactprint ghc-paths optparse-applicative process refact

     

       33527
       33527
       +
                silently syb tasty tasty-expected-failure tasty-golden transformers

     

       33528
       33528
       +
                uniplate unix-compat

     

       33529
       33529
       +
              ];

     

       33530
       33530
       +
              description = "Perform refactorings specified by the refact library";

     

       33531
       33531
       +
              license = lib.licenses.bsd3;

     

       33532
       33532
       +
              hydraPlatforms = lib.platforms.none;

     

       33533
       33533
       +
              mainProgram = "refactor";

     

       33534
       33534
       +
            }) {};

     

       33535
       33535
       +
       

     

       33473
       33536
        
         "apply-unordered" = callPackage

     

       33474
       33537
        
           ({ mkDerivation, base, fin, ghc, ghc-tcplugins-extra, hspec

     

       33475
       33538
        
            , should-not-typecheck, syb

     
···

       35074
       35137
        
              license = lib.licenses.asl20;

     

       35075
       35138
        
            }) {};

     

       35076
       35139
        
       

     

       35140
       35140
       +
         "ascii_1_2_4_0" = callPackage

     

       35141
       35141
       +
           ({ mkDerivation, ascii-case, ascii-char, ascii-group, ascii-numbers

     

       35142
       35142
       +
            , ascii-predicates, ascii-superset, ascii-th, base, bytestring

     

       35143
       35143
       +
            , hedgehog, text

     

       35144
       35144
       +
            }:

     

       35145
       35145
       +
            mkDerivation {

     

       35146
       35146
       +
              pname = "ascii";

     

       35147
       35147
       +
              version = "1.2.4.0";

     

       35148
       35148
       +
              sha256 = "1rsv9ah0jvf66w3k4smh67wpbm03xl4pdyj8svmdy49hbpihimwi";

     

       35149
       35149
       +
              libraryHaskellDepends = [

     

       35150
       35150
       +
                ascii-case ascii-char ascii-group ascii-numbers ascii-predicates

     

       35151
       35151
       +
                ascii-superset ascii-th base bytestring text

     

       35152
       35152
       +
              ];

     

       35153
       35153
       +
              testHaskellDepends = [ base hedgehog text ];

     

       35154
       35154
       +
              description = "The ASCII character set and encoding";

     

       35155
       35155
       +
              license = lib.licenses.asl20;

     

       35156
       35156
       +
              hydraPlatforms = lib.platforms.none;

     

       35157
       35157
       +
            }) {};

     

       35158
       35158
       +
       

     

       35077
       35159
        
         "ascii-art-to-unicode" = callPackage

     

       35078
       35160
        
           ({ mkDerivation, base, comonad, doctest, strict }:

     

       35079
       35161
        
            mkDerivation {

     
···

       35102
       35184
        
              testHaskellDepends = [ ascii-char base ];

     

       35103
       35185
        
              description = "ASCII letter case";

     

       35104
       35186
        
              license = lib.licenses.asl20;

     

       35187
       35187
       +
            }) {};

     

       35188
       35188
       +
       

     

       35189
       35189
       +
         "ascii-case_1_0_1_0" = callPackage

     

       35190
       35190
       +
           ({ mkDerivation, ascii-char, base, hashable }:

     

       35191
       35191
       +
            mkDerivation {

     

       35192
       35192
       +
              pname = "ascii-case";

     

       35193
       35193
       +
              version = "1.0.1.0";

     

       35194
       35194
       +
              sha256 = "0hqpvhg4zvwjzya01y7sqly6dgfrg1zdvvpy6f1r5slzbnnfqswh";

     

       35195
       35195
       +
              libraryHaskellDepends = [ ascii-char base hashable ];

     

       35196
       35196
       +
              testHaskellDepends = [ ascii-char base ];

     

       35197
       35197
       +
              description = "ASCII letter case";

     

       35198
       35198
       +
              license = lib.licenses.asl20;

     

       35199
       35199
       +
              hydraPlatforms = lib.platforms.none;

     

       35105
       35200
        
            }) {};

     

       35106
       35201
        
       

     

       35107
       35202
        
         "ascii-char" = callPackage

     
···

       41624
       41719
        
            }:

     

       41625
       41720
        
            mkDerivation {

     

       41626
       41721
        
              pname = "bearriver";

     

       41627
       41627
       -
              version = "0.13.7";

     

       41628
       41628
       -
              sha256 = "1synznzas89cyp05lhiwxfsbmz5zv2pyjn08548dr21ih1x4560j";

     

       41722
       41722
       +
              version = "0.14";

     

       41723
       41723
       +
              sha256 = "0iyymq8iagdaymivvfg1vvks76bzaiyysw5mj4ifqn2zc9pyb3wd";

     

       41629
       41724
        
              libraryHaskellDepends = [

     

       41630
       41725
        
                base deepseq dunai MonadRandom mtl simple-affine-space transformers

     

       41631
       41726
        
              ];

     
···

       41972
       42067
        
              license = lib.licenses.bsd3;

     

       41973
       42068
        
            }) {};

     

       41974
       42069
        
       

     

       42070
       42070
       +
         "benri-hspec_0_1_0_1" = callPackage

     

       42071
       42071
       +
           ({ mkDerivation, base, hspec }:

     

       42072
       42072
       +
            mkDerivation {

     

       42073
       42073
       +
              pname = "benri-hspec";

     

       42074
       42074
       +
              version = "0.1.0.1";

     

       42075
       42075
       +
              sha256 = "11x7dsp6hmz1an1nm8076lgdvgd8r67hl54p81jprpi8m0lh6mqa";

     

       42076
       42076
       +
              libraryHaskellDepends = [ base hspec ];

     

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

     

       42078
       42078
       +
              license = lib.licenses.bsd3;

     

       42079
       42079
       +
              hydraPlatforms = lib.platforms.none;

     

       42080
       42080
       +
            }) {};

     

       42081
       42081
       +
       

     

       41975
       42082
        
         "bento" = callPackage

     

       41976
       42083
        
           ({ mkDerivation, base }:

     

       41977
       42084
        
            mkDerivation {

     
···

       49630
       49737
        
              pname = "bugzilla-redhat";

     

       49631
       49738
        
              version = "1.0.1";

     

       49632
       49739
        
              sha256 = "19dir39yxqd5psf3gj4f3vhcbdad1np7374nkxfk0gg4xxvywcvi";

     

       49740
       49740
       +
              revision = "1";

     

       49741
       49741
       +
              editedCabalFile = "1yai855w6s9xjyswpx206hnryi1y6kda1310vcfff0ghl4gdxpxw";

     

       49633
       49742
        
              isLibrary = true;

     

       49634
       49743
        
              isExecutable = true;

     

       49635
       49744
        
              libraryHaskellDepends = [

     
···

       51647
       51756
        
         "cabal-cache" = callPackage

     

       51648
       51757
        
           ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3

     

       51649
       51758
        
            , antiope-core, antiope-optparse-applicative, antiope-s3, base

     

       51650
       51650
       -
            , bytestring, containers, cryptonite, deepseq, directory

     

       51651
       51651
       -
            , exceptions, filepath, generic-lens, hedgehog, hspec

     

       51652
       51652
       -
            , hspec-discover, http-client, http-client-tls, http-types

     

       51759
       51759
       +
            , bytestring, cabal-install-parsers, containers, cryptonite

     

       51760
       51760
       +
            , deepseq, directory, exceptions, filepath, generic-lens, hedgehog

     

       51761
       51761
       +
            , hspec, hspec-discover, http-client, http-client-tls, http-types

     

       51653
       51762
        
            , hw-hspec-hedgehog, lens, mtl, network-uri, optparse-applicative

     

       51654
       51763
        
            , process, raw-strings-qq, relation, resourcet, stm, stringsearch

     

       51655
       51764
        
            , temporary, text, topograph, transformers, unliftio

     

       51656
       51765
        
            }:

     

       51657
       51766
        
            mkDerivation {

     

       51658
       51767
        
              pname = "cabal-cache";

     

       51659
       51659
       -
              version = "1.0.5.1";

     

       51660
       51660
       -
              sha256 = "02jin436jrbmfsr3n5qfkp95scybnfapls893kvx89ykya44cijg";

     

       51768
       51768
       +
              version = "1.0.5.4";

     

       51769
       51769
       +
              sha256 = "15jg140ly7rska7v8ihvd383q9lj4i5c18rzjad4yi8f78jjciqb";

     

       51661
       51770
        
              isLibrary = true;

     

       51662
       51771
        
              isExecutable = true;

     

       51663
       51772
        
              libraryHaskellDepends = [

     
···

       51669
       51778
        
              ];

     

       51670
       51779
        
              executableHaskellDepends = [

     

       51671
       51780
        
                aeson amazonka amazonka-core antiope-core

     

       51672
       51672
       -
                antiope-optparse-applicative base bytestring containers directory

     

       51673
       51673
       -
                generic-lens http-types lens mtl optparse-applicative resourcet stm

     

       51674
       51674
       -
                stringsearch temporary text unliftio

     

       51781
       51781
       +
                antiope-optparse-applicative base bytestring cabal-install-parsers

     

       51782
       51782
       +
                containers directory exceptions filepath generic-lens http-types

     

       51783
       51783
       +
                lens mtl optparse-applicative resourcet stm stringsearch temporary

     

       51784
       51784
       +
                text unliftio

     

       51675
       51785
        
              ];

     

       51676
       51786
        
              testHaskellDepends = [

     

       51677
       51787
        
                aeson antiope-core base bytestring filepath hedgehog hspec

     
···

       52521
       52631
        
              pname = "cabal-rpm";

     

       52522
       52632
        
              version = "2.0.11.1";

     

       52523
       52633
        
              sha256 = "07a2jnzldyva1smbxxdknimzydj2rhr7whhgh5q4nwkifkiliadv";

     

       52634
       52634
       +
              revision = "1";

     

       52635
       52635
       +
              editedCabalFile = "1dq6c9f0nm7a8nknc2haq79zkpkh1dgrkn2bixzsd16kmjjsl83m";

     

       52524
       52636
        
              isLibrary = false;

     

       52525
       52637
        
              isExecutable = true;

     

       52526
       52638
        
              executableHaskellDepends = [

     
···

       55989
       56101
        
              mainProgram = "cdeps";

     

       55990
       56102
        
            }) {};

     

       55991
       56103
        
       

     

       56104
       56104
       +
         "cdp" = callPackage

     

       56105
       56105
       +
           ({ mkDerivation, aeson, base, base64-bytestring, blaze-html

     

       56106
       56106
       +
            , blaze-markup, bytestring, containers, data-default, directory

     

       56107
       56107
       +
            , extra, filepath, hspec, http-conduit, monad-loops, mtl

     

       56108
       56108
       +
            , network-uri, process, random, text, utf8-string, vector

     

       56109
       56109
       +
            , websockets

     

       56110
       56110
       +
            }:

     

       56111
       56111
       +
            mkDerivation {

     

       56112
       56112
       +
              pname = "cdp";

     

       56113
       56113
       +
              version = "0.0.2.0";

     

       56114
       56114
       +
              sha256 = "1pi163mysavwhk9s2a78ldbnw0480b9vmvgyr4m426asc17g1kc9";

     

       56115
       56115
       +
              isLibrary = true;

     

       56116
       56116
       +
              isExecutable = true;

     

       56117
       56117
       +
              libraryHaskellDepends = [

     

       56118
       56118
       +
                aeson base bytestring containers data-default directory extra

     

       56119
       56119
       +
                filepath http-conduit monad-loops mtl network-uri process random

     

       56120
       56120
       +
                text vector websockets

     

       56121
       56121
       +
              ];

     

       56122
       56122
       +
              executableHaskellDepends = [

     

       56123
       56123
       +
                aeson base base64-bytestring blaze-html blaze-markup bytestring

     

       56124
       56124
       +
                containers data-default directory extra filepath http-conduit

     

       56125
       56125
       +
                monad-loops mtl network-uri process random text utf8-string vector

     

       56126
       56126
       +
                websockets

     

       56127
       56127
       +
              ];

     

       56128
       56128
       +
              testHaskellDepends = [

     

       56129
       56129
       +
                aeson base bytestring containers data-default directory extra

     

       56130
       56130
       +
                filepath hspec http-conduit monad-loops mtl network-uri process

     

       56131
       56131
       +
                random text vector websockets

     

       56132
       56132
       +
              ];

     

       56133
       56133
       +
              description = "A library for the Chrome Devtools Protocol";

     

       56134
       56134
       +
              license = lib.licenses.bsd3;

     

       56135
       56135
       +
              hydraPlatforms = lib.platforms.none;

     

       56136
       56136
       +
              broken = true;

     

       56137
       56137
       +
            }) {};

     

       56138
       56138
       +
       

     

       55992
       56139
        
         "cedict" = callPackage

     

       55993
       56140
        
           ({ mkDerivation, base, bytestring, containers, mtl, parsec

     

       55994
       56141
        
            , utf8-string

     
···

       60011
       60158
        
            }) {};

     

       60012
       60159
        
       

     

       60013
       60160
        
         "cleveland" = callPackage

     

       60014
       60014
       -
           ({ mkDerivation, aeson, base-noprelude, bytestring, constraints

     

       60015
       60015
       -
            , containers, criterion, cryptonite, data-default, directory

     

       60161
       60161
       +
           ({ mkDerivation, aeson, base-noprelude, constraints, containers

     

       60162
       60162
       +
            , criterion, cryptonite, data-default, dependent-map, directory

     

       60016
       60163
        
            , either, exceptions, file-embed, filepath, fmt, hedgehog, hex-text

     

       60017
       60164
        
            , hspec-expectations, HUnit, lens, lorentz, MonadRandom, morley

     

       60018
       60018
       -
            , morley-client, morley-prelude, mtl, named, o-clock

     

       60019
       60019
       -
            , optparse-applicative, safe-exceptions, servant-client

     

       60020
       60020
       -
            , servant-client-core, singletons, singletons-base, statistics

     

       60021
       60021
       -
            , tagged, tasty, tasty-ant-xml, tasty-discover, tasty-hedgehog

     

       60022
       60022
       -
            , tasty-hunit-compat, template-haskell, temporary, text, time

     

       60023
       60023
       -
            , with-utf8

     

       60165
       60165
       +
            , morley-client, morley-prelude, mtl, o-clock, optparse-applicative

     

       60166
       60166
       +
            , servant-client, servant-client-core, singletons, singletons-base

     

       60167
       60167
       +
            , some, statistics, tagged, tasty, tasty-ant-xml, tasty-discover

     

       60168
       60168
       +
            , tasty-hedgehog, tasty-hunit-compat, template-haskell, temporary

     

       60169
       60169
       +
            , text, time, with-utf8

     

       60024
       60170
        
            }:

     

       60025
       60171
        
            mkDerivation {

     

       60026
       60172
        
              pname = "cleveland";

     

       60027
       60027
       -
              version = "0.2.1";

     

       60028
       60028
       -
              sha256 = "1qqk1mld2wfckpgvsj48w8rh9pdkbqq1p36wkvrphf35hl0hr882";

     

       60173
       60173
       +
              version = "0.3.0";

     

       60174
       60174
       +
              sha256 = "1ahdijygria9rlmfr61vl8s924b29yq31594z1y0dc79asw6vhi1";

     

       60029
       60175
        
              libraryHaskellDepends = [

     

       60030
       60030
       -
                aeson base-noprelude bytestring constraints containers criterion

     

       60031
       60031
       -
                cryptonite data-default directory either exceptions file-embed fmt

     

       60032
       60032
       -
                hedgehog hex-text HUnit lens lorentz MonadRandom morley

     

       60033
       60033
       -
                morley-client morley-prelude mtl named o-clock optparse-applicative

     

       60034
       60034
       -
                safe-exceptions servant-client-core singletons singletons-base

     

       60035
       60035
       -
                statistics tagged tasty tasty-ant-xml tasty-hedgehog

     

       60036
       60036
       -
                tasty-hunit-compat template-haskell temporary text time with-utf8

     

       60176
       60176
       +
                aeson base-noprelude constraints containers criterion cryptonite

     

       60177
       60177
       +
                data-default dependent-map directory either exceptions file-embed

     

       60178
       60178
       +
                fmt hedgehog hex-text HUnit lens lorentz MonadRandom morley

     

       60179
       60179
       +
                morley-client morley-prelude mtl o-clock optparse-applicative

     

       60180
       60180
       +
                servant-client-core singletons singletons-base some statistics

     

       60181
       60181
       +
                tagged tasty tasty-ant-xml tasty-hedgehog tasty-hunit-compat

     

       60182
       60182
       +
                template-haskell temporary text time with-utf8

     

       60037
       60183
        
              ];

     

       60038
       60184
        
              testHaskellDepends = [

     

       60039
       60185
        
                base-noprelude either filepath fmt hedgehog hspec-expectations lens

     

       60040
       60040
       -
                lorentz morley morley-client morley-prelude named o-clock

     

       60041
       60041
       -
                servant-client tasty tasty-hedgehog tasty-hunit-compat text time

     

       60186
       60186
       +
                lorentz morley morley-client morley-prelude o-clock servant-client

     

       60187
       60187
       +
                tasty tasty-hedgehog tasty-hunit-compat text time

     

       60042
       60188
        
              ];

     

       60043
       60189
        
              testToolDepends = [ tasty-discover ];

     

       60044
       60190
        
              description = "Testing framework for Morley";

     
···

       62217
       62363
        
            }:

     

       62218
       62364
        
            mkDerivation {

     

       62219
       62365
        
              pname = "coinbase-pro";

     

       62220
       62220
       -
              version = "0.9.3.0";

     

       62221
       62221
       -
              sha256 = "0974snfkil4xmrkw38d81d85n5w78ld3jd0kbsn3s22jd36dzjlm";

     

       62366
       62366
       +
              version = "0.9.3.2";

     

       62367
       62367
       +
              sha256 = "06gzynckmdsdzzvlmf3kmkbc883pqjbgd4hxkrm47xykv2m64x6s";

     

       62222
       62368
        
              isLibrary = true;

     

       62223
       62369
        
              isExecutable = true;

     

       62224
       62370
        
              libraryHaskellDepends = [

     
···

       66026
       66172
        
              pname = "conferer";

     

       66027
       66173
        
              version = "1.1.0.0";

     

       66028
       66174
        
              sha256 = "1hkdrqxrac1mbzvd29f6ds4cbihdv0j0daai7yc282myv0varh09";

     

       66029
       66029
       -
              revision = "2";

     

       66030
       66030
       -
              editedCabalFile = "0j7q975kg4dchl7pn8cl26sf8945bmhw5mvy73s18ylxqx4qqkwb";

     

       66175
       66175
       +
              revision = "3";

     

       66176
       66176
       +
              editedCabalFile = "15gs9cv1i9j4qx6vnp32yhcjb5rjaf9g3jsfdzmi5v7i3b1gziwc";

     

       66031
       66177
        
              libraryHaskellDepends = [

     

       66032
       66178
        
                base bytestring containers directory filepath text

     

       66033
       66179
        
              ];

     
···

       66047
       66193
        
              pname = "conferer-aeson";

     

       66048
       66194
        
              version = "1.1.0.2";

     

       66049
       66195
        
              sha256 = "07rdal3smq1s14zmsn7g26vc6sqj21rsa2a1vcbrwrfgh9x36jkn";

     

       66050
       66050
       -
              revision = "1";

     

       66051
       66051
       -
              editedCabalFile = "19v6xla4vvhmhqh3z82inp1b6jzvprbvcmd9nbg1l65nsvqgq25a";

     

       66196
       66196
       +
              revision = "2";

     

       66197
       66197
       +
              editedCabalFile = "000fs57llk3f1x0rgdkxzbqzwzh5fx3mirpx0scmnj936byapp4c";

     

       66052
       66198
        
              libraryHaskellDepends = [

     

       66053
       66199
        
                aeson base bytestring conferer directory text unordered-containers

     

       66054
       66200
        
                vector

     
···

       66261
       66407
        
            }:

     

       66262
       66408
        
            mkDerivation {

     

       66263
       66409
        
              pname = "conferer-warp";

     

       66264
       66264
       -
              version = "1.1.0.0";

     

       66265
       66265
       -
              sha256 = "0zbgxq229jr7xwzw6q20rwnslbci07b1vk324izm8hxcp3kb76mj";

     

       66410
       66410
       +
              version = "1.1.0.1";

     

       66411
       66411
       +
              sha256 = "1dbqm1vb00d1dnm3fixw4p7xv1bwpmv0xfkdig0xlgc5b70xbjsh";

     

       66266
       66412
        
              libraryHaskellDepends = [ base conferer http-types text wai warp ];

     

       66267
       66413
        
              testHaskellDepends = [

     

       66268
       66414
        
                base conferer hspec http-types text wai warp

     
···

       69384
       69530
        
           ({ mkDerivation, base, containers, directory, parallel }:

     

       69385
       69531
        
            mkDerivation {

     

       69386
       69532
        
              pname = "cpsa";

     

       69387
       69387
       -
              version = "3.6.11";

     

       69388
       69388
       -
              sha256 = "1kqsr0vb9sxg2c5y14k66d381gx6779bns6ybjymgabw98asmm3k";

     

       69533
       69533
       +
              version = "4.4.1";

     

       69534
       69534
       +
              sha256 = "14g31626g72qljbrds08cpx670v2zgis05z3nkd5b7lim99ibhfh";

     

       69389
       69535
        
              isLibrary = false;

     

       69390
       69536
        
              isExecutable = true;

     

       69391
       69537
        
              enableSeparateDataOutput = true;

     
···

       78107
       78253
        
              license = lib.licenses.publicDomain;

     

       78108
       78254
        
            }) {};

     

       78109
       78255
        
       

     

       78110
       78110
       -
         "dependent-sum_0_7_1_1" = callPackage

     

       78256
       78256
       +
         "dependent-sum_0_7_2_0" = callPackage

     

       78111
       78257
        
           ({ mkDerivation, base, constraints-extras, some }:

     

       78112
       78258
        
            mkDerivation {

     

       78113
       78259
        
              pname = "dependent-sum";

     

       78114
       78114
       -
              version = "0.7.1.1";

     

       78115
       78115
       -
              sha256 = "1vyi15rk1hf7bc4gxl2y42wxayb3zv2a8macfc1vis856rzxm43n";

     

       78260
       78260
       +
              version = "0.7.2.0";

     

       78261
       78261
       +
              sha256 = "1frw5965v8i6xqdgs95gg8asgdqcqnmfahz0pmbwiaw5ybn62rc2";

     

       78116
       78262
        
              libraryHaskellDepends = [ base constraints-extras some ];

     

       78117
       78263
        
              description = "Dependent sum type";

     

       78118
       78264
        
              license = lib.licenses.publicDomain;

     
···

       78534
       78680
        
              license = lib.licenses.bsd3;

     

       78535
       78681
        
            }) {};

     

       78536
       78682
        
       

     

       78683
       78683
       +
         "deriving-openapi3" = callPackage

     

       78684
       78684
       +
           ({ mkDerivation, aeson, base, deriving-aeson, lens, openapi3, text

     

       78685
       78685
       +
            }:

     

       78686
       78686
       +
            mkDerivation {

     

       78687
       78687
       +
              pname = "deriving-openapi3";

     

       78688
       78688
       +
              version = "0.1.0.0";

     

       78689
       78689
       +
              sha256 = "16jl42hpk21pwzlnpwny57l1xv9ibransw65zk4z4scdi4ygg9xi";

     

       78690
       78690
       +
              libraryHaskellDepends = [

     

       78691
       78691
       +
                aeson base deriving-aeson lens openapi3 text

     

       78692
       78692
       +
              ];

     

       78693
       78693
       +
              description = "DerivingVia for OpenAPI 3";

     

       78694
       78694
       +
              license = lib.licenses.mit;

     

       78695
       78695
       +
              hydraPlatforms = lib.platforms.none;

     

       78696
       78696
       +
              broken = true;

     

       78697
       78697
       +
            }) {};

     

       78698
       78698
       +
       

     

       78537
       78699
        
         "deriving-show-simple" = callPackage

     

       78538
       78700
        
           ({ mkDerivation, base, HUnit }:

     

       78539
       78701
        
            mkDerivation {

     
···

       84392
       84554
        
              license = lib.licenses.mit;

     

       84393
       84555
        
            }) {};

     

       84394
       84556
        
       

     

       84557
       84557
       +
         "doctest-parallel_0_2_6" = callPackage

     

       84558
       84558
       +
           ({ mkDerivation, base, base-compat, Cabal, code-page, containers

     

       84559
       84559
       +
            , deepseq, directory, exceptions, extra, filepath, ghc, ghc-paths

     

       84560
       84560
       +
            , Glob, hspec, hspec-core, hspec-discover, HUnit, mockery, pretty

     

       84561
       84561
       +
            , process, QuickCheck, random, setenv, silently, stringbuilder, syb

     

       84562
       84562
       +
            , template-haskell, transformers, unordered-containers

     

       84563
       84563
       +
            }:

     

       84564
       84564
       +
            mkDerivation {

     

       84565
       84565
       +
              pname = "doctest-parallel";

     

       84566
       84566
       +
              version = "0.2.6";

     

       84567
       84567
       +
              sha256 = "13hjwhdjw8jrj07zxkrrfbzr0mrk8gwyis1rbdi4ld4jbq3rr1z7";

     

       84568
       84568
       +
              libraryHaskellDepends = [

     

       84569
       84569
       +
                base base-compat Cabal code-page containers deepseq directory

     

       84570
       84570
       +
                exceptions extra filepath ghc ghc-paths Glob pretty process random

     

       84571
       84571
       +
                syb template-haskell transformers unordered-containers

     

       84572
       84572
       +
              ];

     

       84573
       84573
       +
              testHaskellDepends = [

     

       84574
       84574
       +
                base base-compat code-page containers deepseq directory exceptions

     

       84575
       84575
       +
                filepath ghc ghc-paths hspec hspec-core hspec-discover HUnit

     

       84576
       84576
       +
                mockery process QuickCheck setenv silently stringbuilder syb

     

       84577
       84577
       +
                transformers

     

       84578
       84578
       +
              ];

     

       84579
       84579
       +
              testToolDepends = [ hspec-discover ];

     

       84580
       84580
       +
              doHaddock = false;

     

       84581
       84581
       +
              description = "Test interactive Haskell examples";

     

       84582
       84582
       +
              license = lib.licenses.mit;

     

       84583
       84583
       +
              hydraPlatforms = lib.platforms.none;

     

       84584
       84584
       +
            }) {};

     

       84585
       84585
       +
       

     

       84395
       84586
        
         "doctest-prop" = callPackage

     

       84396
       84587
        
           ({ mkDerivation, base, doctest, HUnit, QuickCheck }:

     

       84397
       84588
        
            mkDerivation {

     
···

       86416
       86607
        
              maintainers = [ lib.maintainers.turion ];

     

       86417
       86608
        
            }) {};

     

       86418
       86609
        
       

     

       86610
       86610
       +
         "dunai_0_9_2" = callPackage

     

       86611
       86611
       +
           ({ mkDerivation, base, MonadRandom, simple-affine-space, tasty

     

       86612
       86612
       +
            , tasty-hunit, transformers, transformers-base

     

       86613
       86613
       +
            }:

     

       86614
       86614
       +
            mkDerivation {

     

       86615
       86615
       +
              pname = "dunai";

     

       86616
       86616
       +
              version = "0.9.2";

     

       86617
       86617
       +
              sha256 = "08skmwkfwiyy83s764fcpa9i8zny10bdbpv9wha6fjqr1b80i80f";

     

       86618
       86618
       +
              libraryHaskellDepends = [

     

       86619
       86619
       +
                base MonadRandom simple-affine-space transformers transformers-base

     

       86620
       86620
       +
              ];

     

       86621
       86621
       +
              testHaskellDepends = [ base tasty tasty-hunit transformers ];

     

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

     

       86623
       86623
       +
              license = lib.licenses.bsd3;

     

       86624
       86624
       +
              hydraPlatforms = lib.platforms.none;

     

       86625
       86625
       +
              maintainers = [ lib.maintainers.turion ];

     

       86626
       86626
       +
            }) {};

     

       86627
       86627
       +
       

     

       86419
       86628
        
         "dunai-core" = callPackage

     

       86420
       86629
        
           ({ mkDerivation, base, MonadRandom, transformers, transformers-base

     

       86421
       86630
        
            }:

     
···

       86436
       86645
        
           ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }:

     

       86437
       86646
        
            mkDerivation {

     

       86438
       86647
        
              pname = "dunai-test";

     

       86439
       86439
       -
              version = "0.9.1";

     

       86440
       86440
       -
              sha256 = "0p78yvn98vp3qjd6dx23nwwzq6v6sks2gp9cycmcnjk3yn8470j9";

     

       86648
       86648
       +
              version = "0.9.2";

     

       86649
       86649
       +
              sha256 = "0ghc1sg1s31qg1z1sg1mzm9qad39ggrkr064mwbwsl2b5xlsnlr4";

     

       86441
       86650
        
              libraryHaskellDepends = [

     

       86442
       86651
        
                base dunai normaldistribution QuickCheck

     

       86443
       86652
        
              ];

     
···

       89231
       89440
        
              description = "Dependently typed elimination functions using singletons";

     

       89232
       89441
        
              license = lib.licenses.bsd3;

     

       89233
       89442
        
              hydraPlatforms = lib.platforms.none;

     

       89443
       89443
       +
              broken = true;

     

       89234
       89444
        
            }) {};

     

       89235
       89445
        
       

     

       89236
       89446
        
         "eliminators_0_9_1" = callPackage

     
···

       89251
       89461
        
              description = "Dependently typed elimination functions using singletons";

     

       89252
       89462
        
              license = lib.licenses.bsd3;

     

       89253
       89463
        
              hydraPlatforms = lib.platforms.none;

     

       89464
       89464
       +
              broken = true;

     

       89254
       89465
        
            }) {};

     

       89255
       89466
        
       

     

       89256
       89467
        
         "elision" = callPackage

     
···

       92272
       92483
        
              broken = true;

     

       92273
       92484
        
            }) {};

     

       92274
       92485
        
       

     

       92486
       92486
       +
         "essence-of-live-coding_0_2_7" = callPackage

     

       92487
       92487
       +
           ({ mkDerivation, base, containers, foreign-store, HUnit, mmorph

     

       92488
       92488
       +
            , mtl, QuickCheck, syb, test-framework, test-framework-hunit

     

       92489
       92489
       +
            , test-framework-quickcheck2, time, transformers, vector-sized

     

       92490
       92490
       +
            }:

     

       92491
       92491
       +
            mkDerivation {

     

       92492
       92492
       +
              pname = "essence-of-live-coding";

     

       92493
       92493
       +
              version = "0.2.7";

     

       92494
       92494
       +
              sha256 = "1vg10x8radvr8ysqfzf1cngp2hnqy8g139x07pwqwycj9zwwnbl4";

     

       92495
       92495
       +
              isLibrary = true;

     

       92496
       92496
       +
              isExecutable = true;

     

       92497
       92497
       +
              libraryHaskellDepends = [

     

       92498
       92498
       +
                base containers foreign-store mmorph syb time transformers

     

       92499
       92499
       +
                vector-sized

     

       92500
       92500
       +
              ];

     

       92501
       92501
       +
              executableHaskellDepends = [ base transformers ];

     

       92502
       92502
       +
              testHaskellDepends = [

     

       92503
       92503
       +
                base containers HUnit mtl QuickCheck syb test-framework

     

       92504
       92504
       +
                test-framework-hunit test-framework-quickcheck2 transformers

     

       92505
       92505
       +
              ];

     

       92506
       92506
       +
              description = "General purpose live coding framework";

     

       92507
       92507
       +
              license = lib.licenses.bsd3;

     

       92508
       92508
       +
              hydraPlatforms = lib.platforms.none;

     

       92509
       92509
       +
              maintainers = [ lib.maintainers.turion ];

     

       92510
       92510
       +
              broken = true;

     

       92511
       92511
       +
            }) {};

     

       92512
       92512
       +
       

     

       92275
       92513
        
         "essence-of-live-coding-PortMidi" = callPackage

     

       92276
       92514
        
           ({ mkDerivation, base, essence-of-live-coding, PortMidi

     

       92277
       92515
        
            , transformers

     

       92278
       92516
        
            }:

     

       92279
       92517
        
            mkDerivation {

     

       92280
       92518
        
              pname = "essence-of-live-coding-PortMidi";

     

       92281
       92281
       -
              version = "0.2.6";

     

       92282
       92282
       -
              sha256 = "0n5bivhffrxp8kwhf42r3yf485y3mnxl4r3pzwp2l89h7l380q8z";

     

       92519
       92519
       +
              version = "0.2.7";

     

       92520
       92520
       +
              sha256 = "1qqswld88yvqa1z8h9rdxqqvjikhkdb67xp2sph6xb231k9710qy";

     

       92283
       92521
        
              libraryHaskellDepends = [

     

       92284
       92522
        
                base essence-of-live-coding PortMidi transformers

     

       92285
       92523
        
              ];

     
···

       92306
       92544
        
              maintainers = [ lib.maintainers.turion ];

     

       92307
       92545
        
            }) {};

     

       92308
       92546
        
       

     

       92547
       92547
       +
         "essence-of-live-coding-gloss_0_2_7" = callPackage

     

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

     

       92549
       92549
       +
            , syb, transformers

     

       92550
       92550
       +
            }:

     

       92551
       92551
       +
            mkDerivation {

     

       92552
       92552
       +
              pname = "essence-of-live-coding-gloss";

     

       92553
       92553
       +
              version = "0.2.7";

     

       92554
       92554
       +
              sha256 = "0iv5wgzfxy1k80dh6c6hrzh4jcjy3ak4l3l004jm3wpfm7fm0lmx";

     

       92555
       92555
       +
              libraryHaskellDepends = [

     

       92556
       92556
       +
                base essence-of-live-coding foreign-store gloss syb transformers

     

       92557
       92557
       +
              ];

     

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

     

       92559
       92559
       +
              license = lib.licenses.bsd3;

     

       92560
       92560
       +
              hydraPlatforms = lib.platforms.none;

     

       92561
       92561
       +
              maintainers = [ lib.maintainers.turion ];

     

       92562
       92562
       +
            }) {};

     

       92563
       92563
       +
       

     

       92309
       92564
        
         "essence-of-live-coding-gloss-example" = callPackage

     

       92310
       92565
        
           ({ mkDerivation, base, essence-of-live-coding

     

       92311
       92566
        
            , essence-of-live-coding-gloss, gloss, syb, transformers

     
···

       92343
       92598
        
              maintainers = [ lib.maintainers.turion ];

     

       92344
       92599
        
            }) {};

     

       92345
       92600
        
       

     

       92601
       92601
       +
         "essence-of-live-coding-pulse_0_2_7" = callPackage

     

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

     

       92603
       92603
       +
            , pulse-simple, transformers

     

       92604
       92604
       +
            }:

     

       92605
       92605
       +
            mkDerivation {

     

       92606
       92606
       +
              pname = "essence-of-live-coding-pulse";

     

       92607
       92607
       +
              version = "0.2.7";

     

       92608
       92608
       +
              sha256 = "0bmnc7901zgak223kfm29md0w5fd9lfv4dxc8c27cdcrdqnqfc2p";

     

       92609
       92609
       +
              libraryHaskellDepends = [

     

       92610
       92610
       +
                base essence-of-live-coding foreign-store pulse-simple transformers

     

       92611
       92611
       +
              ];

     

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

     

       92613
       92613
       +
              license = lib.licenses.bsd3;

     

       92614
       92614
       +
              hydraPlatforms = lib.platforms.none;

     

       92615
       92615
       +
              maintainers = [ lib.maintainers.turion ];

     

       92616
       92616
       +
            }) {};

     

       92617
       92617
       +
       

     

       92346
       92618
        
         "essence-of-live-coding-pulse-example" = callPackage

     

       92347
       92619
        
           ({ mkDerivation, base, essence-of-live-coding

     

       92348
       92620
        
            , essence-of-live-coding-pulse, pulse-simple, transformers, vector

     
···

       92381
       92653
        
              maintainers = [ lib.maintainers.turion ];

     

       92382
       92654
        
            }) {};

     

       92383
       92655
        
       

     

       92656
       92656
       +
         "essence-of-live-coding-quickcheck_0_2_7" = callPackage

     

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

     

       92658
       92658
       +
            , QuickCheck, syb, transformers

     

       92659
       92659
       +
            }:

     

       92660
       92660
       +
            mkDerivation {

     

       92661
       92661
       +
              pname = "essence-of-live-coding-quickcheck";

     

       92662
       92662
       +
              version = "0.2.7";

     

       92663
       92663
       +
              sha256 = "0jn5bz7xq8jmlkhrrbn5mj3ywh8288gpx43n8fkjzmzdk233kbvp";

     

       92664
       92664
       +
              libraryHaskellDepends = [

     

       92665
       92665
       +
                base boltzmann-samplers essence-of-live-coding QuickCheck syb

     

       92666
       92666
       +
                transformers

     

       92667
       92667
       +
              ];

     

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

     

       92669
       92669
       +
              license = lib.licenses.bsd3;

     

       92670
       92670
       +
              hydraPlatforms = lib.platforms.none;

     

       92671
       92671
       +
              maintainers = [ lib.maintainers.turion ];

     

       92672
       92672
       +
            }) {};

     

       92673
       92673
       +
       

     

       92384
       92674
        
         "essence-of-live-coding-vivid" = callPackage

     

       92385
       92675
        
           ({ mkDerivation, base, essence-of-live-coding, vivid }:

     

       92386
       92676
        
            mkDerivation {

     

       92387
       92677
        
              pname = "essence-of-live-coding-vivid";

     

       92388
       92388
       -
              version = "0.2.6";

     

       92389
       92389
       -
              sha256 = "1vw4bjxnqd58h5lrw7wqd1w3026skcnz9vrnwmfxcsbyc09bnyvw";

     

       92678
       92678
       +
              version = "0.2.7";

     

       92679
       92679
       +
              sha256 = "03j5kmp824s8b2x1n8dp86lh7ac8ccxh54dg0sx7v98j9lflbcqq";

     

       92390
       92680
        
              libraryHaskellDepends = [ base essence-of-live-coding vivid ];

     

       92391
       92681
        
              description = "General purpose live coding framework - vivid backend";

     

       92392
       92682
        
              license = lib.licenses.bsd3;

     
···

       92401
       92691
        
              pname = "essence-of-live-coding-warp";

     

       92402
       92692
        
              version = "0.2.6";

     

       92403
       92693
        
              sha256 = "0x18jxw0xwqvbwdalbrz4lp2lq9pyl4a5r9vnky5hc5wcwqm2f4m";

     

       92694
       92694
       +
              libraryHaskellDepends = [

     

       92695
       92695
       +
                base essence-of-live-coding http-types wai warp

     

       92696
       92696
       +
              ];

     

       92697
       92697
       +
              testHaskellDepends = [

     

       92698
       92698
       +
                base bytestring essence-of-live-coding http-client

     

       92699
       92699
       +
              ];

     

       92700
       92700
       +
              description = "General purpose live coding framework";

     

       92701
       92701
       +
              license = lib.licenses.bsd3;

     

       92702
       92702
       +
              hydraPlatforms = lib.platforms.none;

     

       92703
       92703
       +
              maintainers = [ lib.maintainers.turion ];

     

       92704
       92704
       +
            }) {};

     

       92705
       92705
       +
       

     

       92706
       92706
       +
         "essence-of-live-coding-warp_0_2_7" = callPackage

     

       92707
       92707
       +
           ({ mkDerivation, base, bytestring, essence-of-live-coding

     

       92708
       92708
       +
            , http-client, http-types, wai, warp

     

       92709
       92709
       +
            }:

     

       92710
       92710
       +
            mkDerivation {

     

       92711
       92711
       +
              pname = "essence-of-live-coding-warp";

     

       92712
       92712
       +
              version = "0.2.7";

     

       92713
       92713
       +
              sha256 = "1zykg5qik61xr4ri6d9r04w5rj7wm0wqmnzm6nipwpixal3gdxqa";

     

       92404
       92714
        
              libraryHaskellDepends = [

     

       92405
       92715
        
                base essence-of-live-coding http-types wai warp

     

       92406
       92716
        
              ];

     
···

       93453
       93763
        
            }) {};

     

       93454
       93764
        
       

     

       93455
       93765
        
         "eventuo11y" = callPackage

     

       93456
       93456
       -
           ({ mkDerivation, base, exceptions, primitive, resourcet

     

       93457
       93457
       -
            , safe-exceptions, transformers, unliftio-core

     

       93766
       93766
       +
           ({ mkDerivation, base, exceptions, general-allocate, monad-control

     

       93767
       93767
       +
            , mtl, primitive, transformers, transformers-base, unliftio-core

     

       93458
       93768
        
            }:

     

       93459
       93769
        
            mkDerivation {

     

       93460
       93770
        
              pname = "eventuo11y";

     

       93461
       93461
       -
              version = "0.5.0.0";

     

       93462
       93462
       -
              sha256 = "19rsw7xs8hy1yl145fgsfd3rddvpxjgxv05kd557hgv35ipkklmz";

     

       93771
       93771
       +
              version = "0.6.0.0";

     

       93772
       93772
       +
              sha256 = "1zk49cfg2cab5h5xy2bghk643aq6p0zi937linnxgl53c21br1li";

     

       93463
       93773
        
              libraryHaskellDepends = [

     

       93464
       93464
       -
                base exceptions primitive resourcet safe-exceptions transformers

     

       93465
       93465
       -
                unliftio-core

     

       93774
       93774
       +
                base exceptions general-allocate monad-control mtl primitive

     

       93775
       93775
       +
                transformers transformers-base unliftio-core

     

       93466
       93776
        
              ];

     

       93467
       93777
        
              description = "An event-oriented observability library";

     

       93468
       93778
        
              license = lib.licenses.asl20;

     

       93779
       93779
       +
              hydraPlatforms = lib.platforms.none;

     

       93469
       93780
        
            }) {};

     

       93470
       93781
        
       

     

       93471
       93782
        
         "eventuo11y-batteries" = callPackage

     

       93472
       93783
        
           ({ mkDerivation, aeson, base, binary, bytestring, case-insensitive

     

       93473
       93473
       -
            , containers, eventuo11y, eventuo11y-json, http-media, http-types

     

       93474
       93474
       -
            , monad-control, mtl, network, safe-exceptions, semigroupoids

     

       93475
       93475
       -
            , servant-client, servant-client-core, text, transformers-base, wai

     

       93784
       93784
       +
            , containers, eventuo11y, eventuo11y-json, general-allocate

     

       93785
       93785
       +
            , http-media, http-types, monad-control, mtl, network

     

       93786
       93786
       +
            , safe-exceptions, semigroupoids, servant-client

     

       93787
       93787
       +
            , servant-client-core, text, transformers-base, unliftio-core, wai

     

       93476
       93788
        
            , warp

     

       93477
       93789
        
            }:

     

       93478
       93790
        
            mkDerivation {

     

       93479
       93791
        
              pname = "eventuo11y-batteries";

     

       93480
       93480
       -
              version = "0.2.1.1";

     

       93481
       93481
       -
              sha256 = "1s3mwr9cnfsn1kh63dq6djwvvj4sx256w47r9s6wsii9ibgqig8v";

     

       93792
       93792
       +
              version = "0.3.0.0";

     

       93793
       93793
       +
              sha256 = "12agwfk89jxsa2hdy5ghvkjddp2xs58973r4zi5zsf3zzx7nlx56";

     

       93482
       93794
        
              libraryHaskellDepends = [

     

       93483
       93795
        
                aeson base binary bytestring case-insensitive containers eventuo11y

     

       93484
       93484
       -
                eventuo11y-json http-media http-types monad-control mtl network

     

       93485
       93485
       -
                safe-exceptions semigroupoids servant-client servant-client-core

     

       93486
       93486
       -
                text transformers-base wai warp

     

       93796
       93796
       +
                eventuo11y-json general-allocate http-media http-types

     

       93797
       93797
       +
                monad-control mtl network safe-exceptions semigroupoids

     

       93798
       93798
       +
                servant-client servant-client-core text transformers-base

     

       93799
       93799
       +
                unliftio-core wai warp

     

       93487
       93800
        
              ];

     

       93488
       93801
        
              description = "Grab bag of eventuo11y-enriched functionality";

     

       93489
       93802
        
              license = lib.licenses.asl20;

     

       93803
       93803
       +
              hydraPlatforms = lib.platforms.none;

     

       93490
       93804
        
            }) {};

     

       93491
       93805
        
       

     

       93492
       93806
        
         "eventuo11y-dsl" = callPackage

     

       93493
       93493
       -
           ({ mkDerivation, base, template-haskell, th-compat }:

     

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

     

       93494
       93808
        
            mkDerivation {

     

       93495
       93809
        
              pname = "eventuo11y-dsl";

     

       93496
       93496
       -
              version = "0.1.0.0";

     

       93497
       93497
       -
              sha256 = "0nm0q8p5qbnx56gvpsbzz5vwkx08sn8wcdyb6hli4ihq407ml8qz";

     

       93498
       93498
       -
              libraryHaskellDepends = [ base template-haskell th-compat ];

     

       93810
       93810
       +
              version = "0.2.0.0";

     

       93811
       93811
       +
              sha256 = "0qa5csjkm25278h1vf59aws9am59gyha7zi1yjq7wag1ivhdfa9w";

     

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

     

       93499
       93813
        
              description = "DSL for defining eventuo11y fields and selectors";

     

       93500
       93814
        
              license = lib.licenses.asl20;

     

       93501
       93815
        
            }) {};

     

       93502
       93816
        
       

     

       93503
       93817
        
         "eventuo11y-json" = callPackage

     

       93504
       93818
        
           ({ mkDerivation, aeson, base, bytestring, eventuo11y

     

       93505
       93505
       -
            , eventuo11y-dsl, template-haskell, text, th-compat, time, uuid

     

       93819
       93819
       +
            , eventuo11y-dsl, template-haskell, text, time, uuid

     

       93506
       93820
        
            }:

     

       93507
       93821
        
            mkDerivation {

     

       93508
       93822
        
              pname = "eventuo11y-json";

     

       93509
       93509
       -
              version = "0.1.0.0";

     

       93510
       93510
       -
              sha256 = "1bl4lqxq38nvwnm6s9w27ja4x571y6lvjvx7amc2i498i3mr5jzq";

     

       93823
       93823
       +
              version = "0.2.0.0";

     

       93824
       93824
       +
              sha256 = "132dkvsp1p5lj103amsfkn9grc4rx7qgs2nh5506mybykhhhzzg5";

     

       93511
       93825
        
              libraryHaskellDepends = [

     

       93512
       93826
        
                aeson base bytestring eventuo11y eventuo11y-dsl template-haskell

     

       93513
       93513
       -
                text th-compat time uuid

     

       93827
       93827
       +
                text time uuid

     

       93514
       93828
        
              ];

     

       93515
       93829
        
              description = "aeson-based rendering for eventuo11y";

     

       93516
       93830
        
              license = lib.licenses.asl20;

     

       93831
       93831
       +
              hydraPlatforms = lib.platforms.none;

     

       93517
       93832
        
            }) {};

     

       93518
       93833
        
       

     

       93519
       93834
        
         "every" = callPackage

     
···

       93732
       94047
        
              libraryHaskellDepends = [ base template-haskell ];

     

       93733
       94048
        
              description = "Exception type hierarchy with TemplateHaskell";

     

       93734
       94049
        
              license = lib.licenses.bsd3;

     

       94050
       94050
       +
            }) {};

     

       94051
       94051
       +
       

     

       94052
       94052
       +
         "exception-hierarchy_0_1_0_8" = callPackage

     

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

     

       94054
       94054
       +
            mkDerivation {

     

       94055
       94055
       +
              pname = "exception-hierarchy";

     

       94056
       94056
       +
              version = "0.1.0.8";

     

       94057
       94057
       +
              sha256 = "17wx40kic0gw5lbz1nr094ps612i0j0pbf0wfj4kgzsl6cj80hih";

     

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

     

       94059
       94059
       +
              description = "Exception type hierarchy with TemplateHaskell";

     

       94060
       94060
       +
              license = lib.licenses.bsd3;

     

       94061
       94061
       +
              hydraPlatforms = lib.platforms.none;

     

       93735
       94062
        
            }) {};

     

       93736
       94063
        
       

     

       93737
       94064
        
         "exception-mailer" = callPackage

     
···

       99304
       99631
        
              mainProgram = "fix-whitespace";

     

       99305
       99632
        
            }) {};

     

       99306
       99633
        
       

     

       99634
       99634
       +
         "fix-whitespace_0_0_11" = callPackage

     

       99635
       99635
       +
           ({ mkDerivation, base, directory, extra, filepath, filepattern

     

       99636
       99636
       +
            , text, yaml

     

       99637
       99637
       +
            }:

     

       99638
       99638
       +
            mkDerivation {

     

       99639
       99639
       +
              pname = "fix-whitespace";

     

       99640
       99640
       +
              version = "0.0.11";

     

       99641
       99641
       +
              sha256 = "0q36vr3pfk1x14hl86g4g557299ih0510j7cf37h8n5nv8bs8gq2";

     

       99642
       99642
       +
              isLibrary = false;

     

       99643
       99643
       +
              isExecutable = true;

     

       99644
       99644
       +
              executableHaskellDepends = [

     

       99645
       99645
       +
                base directory extra filepath filepattern text yaml

     

       99646
       99646
       +
              ];

     

       99647
       99647
       +
              description = "Fixes whitespace issues";

     

       99648
       99648
       +
              license = "unknown";

     

       99649
       99649
       +
              hydraPlatforms = lib.platforms.none;

     

       99650
       99650
       +
              mainProgram = "fix-whitespace";

     

       99651
       99651
       +
            }) {};

     

       99652
       99652
       +
       

     

       99307
       99653
        
         "fixed" = callPackage

     

       99308
       99654
        
           ({ mkDerivation, base }:

     

       99309
       99655
        
            mkDerivation {

     
···

       101421
       101767
        
              broken = true;

     

       101422
       101768
        
            }) {};

     

       101423
       101769
        
       

     

       101770
       101770
       +
         "fontconfig-pure" = callPackage

     

       101771
       101771
       +
           ({ mkDerivation, base, containers, css-syntax, fontconfig

     

       101772
       101772
       +
            , freetype2, hashable, hspec, linear, QuickCheck, scientific

     

       101773
       101773
       +
            , stylist-traits, text

     

       101774
       101774
       +
            }:

     

       101775
       101775
       +
            mkDerivation {

     

       101776
       101776
       +
              pname = "fontconfig-pure";

     

       101777
       101777
       +
              version = "0.1.0.0";

     

       101778
       101778
       +
              sha256 = "0rnx9s5kj5lr70gp4454qy3h4lfndf9f976h331jp0f4y47c2d42";

     

       101779
       101779
       +
              isLibrary = true;

     

       101780
       101780
       +
              isExecutable = true;

     

       101781
       101781
       +
              libraryHaskellDepends = [

     

       101782
       101782
       +
                base containers css-syntax freetype2 hashable linear scientific

     

       101783
       101783
       +
                stylist-traits text

     

       101784
       101784
       +
              ];

     

       101785
       101785
       +
              libraryPkgconfigDepends = [ fontconfig ];

     

       101786
       101786
       +
              executableHaskellDepends = [ base ];

     

       101787
       101787
       +
              testHaskellDepends = [ base hspec QuickCheck ];

     

       101788
       101788
       +
              description = "Pure-functional language bindings to FontConfig";

     

       101789
       101789
       +
              license = lib.licenses.mit;

     

       101790
       101790
       +
              hydraPlatforms = lib.platforms.none;

     

       101791
       101791
       +
              mainProgram = "fontconfig-pure";

     

       101792
       101792
       +
            }) {inherit (pkgs) fontconfig;};

     

       101793
       101793
       +
       

     

       101424
       101794
        
         "foo" = callPackage

     

       101425
       101795
        
           ({ mkDerivation, base, containers, GLUT, haskell98, OpenGL }:

     

       101426
       101796
        
            mkDerivation {

     
···

       102026
       102396
        
              testToolDepends = [ hspec-discover ];

     

       102027
       102397
        
              description = "Parsers and analyses for Fortran standards 66, 77, 90, 95 and 2003 (partial)";

     

       102028
       102398
        
              license = lib.licenses.asl20;

     

       102029
       102029
       -
              hydraPlatforms = lib.platforms.none;

     

       102030
       102399
        
              mainProgram = "fortran-src";

     

       102031
       102400
        
            }) {};

     

       102032
       102401
        
       

     
···

       102058
       102427
        
              license = lib.licenses.asl20;

     

       102059
       102428
        
              hydraPlatforms = lib.platforms.none;

     

       102060
       102429
        
              mainProgram = "fortran-src-extras";

     

       102430
       102430
       +
              broken = true;

     

       102061
       102431
        
            }) {};

     

       102062
       102432
        
       

     

       102063
       102433
        
         "fortran-vars" = callPackage

     
···

       102978
       103348
        
            }) {};

     

       102979
       103349
        
       

     

       102980
       103350
        
         "free-theorems" = callPackage

     

       102981
       102981
       -
           ({ mkDerivation, base, containers, haskell-src, haskell-src-exts

     

       102982
       102982
       -
            , mtl, pretty, syb

     

       102983
       102983
       -
            }:

     

       103351
       103351
       +
           ({ mkDerivation, base, containers, haskell-src, mtl, pretty, syb }:

     

       102984
       103352
        
            mkDerivation {

     

       102985
       103353
        
              pname = "free-theorems";

     

       102986
       102986
       -
              version = "0.3.2.0";

     

       102987
       102987
       -
              sha256 = "1r0qz8h8fjb9akkhd3impr30gd0s5ky51dj667x0pf155b4lvx2w";

     

       103354
       103354
       +
              version = "0.3.2.1";

     

       103355
       103355
       +
              sha256 = "0skifd09ccbr950wjm9z9l0adzl9yqrqs73xlhcx24xsy16gn2h8";

     

       102988
       103356
        
              libraryHaskellDepends = [

     

       102989
       102989
       -
                base containers haskell-src haskell-src-exts mtl pretty syb

     

       103357
       103357
       +
                base containers haskell-src mtl pretty syb

     

       102990
       103358
        
              ];

     

       102991
       103359
        
              description = "Automatic generation of free theorems";

     

       102992
       103360
        
              license = lib.licenses.publicDomain;

     
···

       106729
       107097
        
            }:

     

       106730
       107098
        
            mkDerivation {

     

       106731
       107099
        
              pname = "general-allocate";

     

       106732
       106732
       -
              version = "0.1.0.0";

     

       106733
       106733
       -
              sha256 = "1w9dv6fphf64sh1c8azk7r6yb19mw4g1rbw4zy0rz69fskgia5sv";

     

       107100
       107100
       +
              version = "0.2.0.0";

     

       107101
       107101
       +
              sha256 = "1i388gvnk4brc49pp44xaayddcpg78ii1yv0n4r09nl4iicggsyc";

     

       106734
       107102
        
              libraryHaskellDepends = [

     

       106735
       107103
        
                base containers mtl primitive resourcet safe-exceptions

     

       106736
       107104
        
                transformers

     
···

       119572
       119940
        
            }:

     

       119573
       119941
        
            mkDerivation {

     

       119574
       119942
        
              pname = "graphmod";

     

       119575
       119575
       -
              version = "1.4.4";

     

       119576
       119576
       -
              sha256 = "12q9kkxyyma23dgzpdnlsrklk20isr4jf2yslkzyb6ny5xmfxsac";

     

       119577
       119577
       -
              isLibrary = false;

     

       119943
       119943
       +
              version = "1.4.5.1";

     

       119944
       119944
       +
              sha256 = "1k1nji14wfn36jym0fqc3yfiwd6gimyk109njrp7b1ds8zfp0ayp";

     

       119945
       119945
       +
              isLibrary = true;

     

       119578
       119946
        
              isExecutable = true;

     

       119579
       119579
       -
              executableHaskellDepends = [

     

       119947
       119947
       +
              libraryHaskellDepends = [

     

       119580
       119948
        
                base Cabal containers directory dotgen filepath haskell-lexer

     

       119581
       119949
        
                pretty

     

       119582
       119950
        
              ];

     

       119951
       119951
       +
              executableHaskellDepends = [ base ];

     

       119583
       119952
        
              description = "Present the module dependencies of a program as a \"dot\" graph";

     

       119584
       119953
        
              license = lib.licenses.bsd3;

     

       119585
       119954
        
              hydraPlatforms = lib.platforms.none;

     
···

       121818
       122187
        
            }:

     

       121819
       122188
        
            mkDerivation {

     

       121820
       122189
        
              pname = "h-raylib";

     

       121821
       121821
       -
              version = "4.5.0.8";

     

       121822
       121822
       -
              sha256 = "0v2aclbqjw98wa6vwv0165b28pc6n9mvbsppxnn3y1nxsjn6nwdf";

     

       122190
       122190
       +
              version = "4.5.0.9";

     

       122191
       122191
       +
              sha256 = "0mlpdfvg8vqylkl64czzc4w397zi3fmm81jvax0l3chjg3bx5i02";

     

       121823
       122192
        
              libraryHaskellDepends = [ base ];

     

       121824
       122193
        
              librarySystemDepends = [

     

       121825
       122194
        
                c libGL libX11 libXcursor libXi libXinerama libXrandr

     
···

       123346
       123715
        
       

     

       123347
       123716
        
         "hackport" = callPackage

     

       123348
       123717
        
           ({ mkDerivation, array, async, base, base16-bytestring

     

       123349
       123349
       -
            , base64-bytestring, binary, bytestring, containers

     

       123718
       123718
       +
            , base64-bytestring, binary, bytestring, cabal-install, containers

     

       123350
       123719
        
            , cryptohash-sha256, deepseq, directory, doctest, echo, ed25519

     

       123351
       123720
        
            , edit-distance, extensible-exceptions, filepath, ghc-prim

     

       123352
       123721
        
            , hashable, hspec, hspec-discover, HTTP, lifted-base, monad-control

     
···

       123357
       123726
        
            }:

     

       123358
       123727
        
            mkDerivation {

     

       123359
       123728
        
              pname = "hackport";

     

       123360
       123360
       -
              version = "0.7.3.0";

     

       123361
       123361
       -
              sha256 = "0166ybpnb0ajp2afgi70lwwmkwbbgavj8mfpcksyaysbpa6zpl4m";

     

       123729
       123729
       +
              version = "0.7.3.1";

     

       123730
       123730
       +
              sha256 = "1wfsl5ybbmxvj29hr39xp35fqyairm3mkb1q7xad8i2xmn76rvmp";

     

       123362
       123731
        
              isLibrary = false;

     

       123363
       123732
        
              isExecutable = true;

     

       123364
       123733
        
              libraryHaskellDepends = [

     
···

       123379
       123748
        
                extensible-exceptions filepath hspec network-uri parallel parsec

     

       123380
       123749
        
                pretty process QuickCheck split text time xml

     

       123381
       123750
        
              ];

     

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

     

       123751
       123751
       +
              testToolDepends = [ cabal-install doctest hspec-discover ];

     

       123383
       123752
        
              doHaddock = false;

     

       123384
       123753
        
              description = "Hackage and Portage integration tool";

     

       123385
       123754
        
              license = lib.licenses.gpl3Plus;

     
···

       127545
       127914
        
              description = "Utility functions for testing Megaparsec parsers with Hspec";

     

       127546
       127915
        
              version = "0.8.2";

     

       127547
       127916
        
              description = "Utility functions for testing Megaparsec parsers with Hspec";

     

       127548
       127548
       -
              revision = "2";

     

       127549
       127549
       -
              description = "Utility functions for testing Megaparsec parsers with Hspec";

     

       127917
       127917
       +
              revision = "3";

     

       127918
       127918
       +
              editedCabalFile = "101qavk0fmc4c6qa307kswz3345psskxqyxhk6hmykynjm05jjrv";

     

       127550
       127919
        
              description = "Utility functions for testing Megaparsec parsers with Hspec";

     

       127551
       127920
        
              isLibrary = true;

     

       127552
       127921
        
              isExecutable = true;

     
···

       136361
       136730
        
            }) {};

     

       136362
       136731
        
       

     

       136363
       136732
        
         "hevm" = callPackage

     

       136364
       136364
       -
           ({ mkDerivation, abstract-par, aeson, ansi-wl-pprint, async, base

     

       136365
       136365
       -
            , base16-bytestring, binary, brick, bytestring, cereal, containers

     

       136366
       136366
       -
            , cryptonite, data-dword, Decimal, deepseq, directory, fgl

     

       136367
       136367
       -
            , filepath, free, haskeline, here, HUnit, lens, lens-aeson, libff

     

       136368
       136368
       -
            , megaparsec, memory, monad-par, mtl, multiset, operational

     

       136369
       136369
       -
            , optparse-generic, process, QuickCheck, quickcheck-text

     

       136370
       136370
       -
            , regex-tdfa, restless-git, rosezipper, s-cargot, sbv, scientific

     

       136371
       136371
       -
            , secp256k1, semver-range, tasty, tasty-hunit, tasty-quickcheck

     

       136372
       136372
       -
            , temporary, text, text-format, time, transformers, tree-view

     

       136373
       136373
       -
            , unordered-containers, vector, vty, witherable, wreq

     

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

     

       136734
       136734
       +
            , base, base16-bytestring, binary, brick, bytestring, cereal

     

       136735
       136735
       +
            , containers, cryptonite, data-dword, Decimal, deepseq, directory

     

       136736
       136736
       +
            , fgl, filepath, free, haskeline, here, HUnit, lens, lens-aeson

     

       136737
       136737
       +
            , libff, megaparsec, memory, monad-par, mtl, multiset, operational

     

       136738
       136738
       +
            , optparse-generic, parsec, process, QuickCheck

     

       136739
       136739
       +
            , quickcheck-instances, quickcheck-text, regex, regex-tdfa

     

       136740
       136740
       +
            , restless-git, rosezipper, s-cargot, scientific, secp256k1

     

       136741
       136741
       +
            , semver-range, smt2-parser, spool, tasty, tasty-expected-failure

     

       136742
       136742
       +
            , tasty-hunit, tasty-quickcheck, temporary, text, time

     

       136743
       136743
       +
            , transformers, tree-view, tuple, unordered-containers, vector, vty

     

       136744
       136744
       +
            , witherable, word-wrap, wreq

     

       136374
       136745
        
            }:

     

       136375
       136746
        
            mkDerivation {

     

       136376
       136747
        
              pname = "hevm";

     

       136377
       136377
       -
              version = "0.49.0";

     

       136378
       136378
       -
              sha256 = "1plkfzx0r5k77ymlkrg694vgx58jil5wx2m43ggs9ixnph0q3ysx";

     

       136748
       136748
       +
              version = "0.50.0";

     

       136749
       136749
       +
              sha256 = "0wdp7vl1aq79k8sw7n4mf6wv184as0pmprdffzklzkcskvs9yjmb";

     

       136379
       136750
        
              isLibrary = true;

     

       136380
       136751
        
              isExecutable = true;

     

       136381
       136752
        
              enableSeparateDataOutput = true;

     

       136382
       136753
        
              libraryHaskellDepends = [

     

       136383
       136383
       -
                abstract-par aeson ansi-wl-pprint base base16-bytestring binary

     

       136384
       136384
       -
                brick bytestring cereal containers cryptonite data-dword Decimal

     

       136385
       136385
       -
                deepseq directory fgl filepath free haskeline here lens lens-aeson

     

       136386
       136386
       -
                megaparsec memory monad-par mtl multiset operational

     

       136387
       136387
       -
                optparse-generic process QuickCheck quickcheck-text regex-tdfa

     

       136388
       136388
       -
                restless-git rosezipper s-cargot sbv scientific semver-range

     

       136389
       136389
       -
                temporary text text-format time transformers tree-view

     

       136390
       136390
       -
                unordered-containers vector vty witherable wreq

     

       136754
       136754
       +
                abstract-par aeson ansi-wl-pprint array async base

     

       136755
       136755
       +
                base16-bytestring binary brick bytestring cereal containers

     

       136756
       136756
       +
                cryptonite data-dword Decimal deepseq directory fgl filepath free

     

       136757
       136757
       +
                haskeline here HUnit lens lens-aeson megaparsec memory monad-par

     

       136758
       136758
       +
                mtl multiset operational optparse-generic parsec process QuickCheck

     

       136759
       136759
       +
                quickcheck-instances quickcheck-text regex regex-tdfa restless-git

     

       136760
       136760
       +
                rosezipper s-cargot scientific semver-range smt2-parser spool tasty

     

       136761
       136761
       +
                tasty-expected-failure tasty-hunit tasty-quickcheck temporary text

     

       136762
       136762
       +
                time transformers tree-view tuple unordered-containers vector vty

     

       136763
       136763
       +
                witherable word-wrap wreq

     

       136391
       136764
        
              ];

     

       136392
       136765
        
              librarySystemDepends = [ libff secp256k1 ];

     

       136393
       136766
        
              executableHaskellDepends = [

     

       136394
       136767
        
                aeson ansi-wl-pprint async base base16-bytestring binary brick

     

       136395
       136768
        
                bytestring containers cryptonite data-dword deepseq directory

     

       136396
       136769
        
                filepath free lens lens-aeson memory mtl operational

     

       136397
       136397
       -
                optparse-generic process QuickCheck quickcheck-text regex-tdfa sbv

     

       136398
       136398
       -
                temporary text text-format unordered-containers vector vty

     

       136770
       136770
       +
                optparse-generic process QuickCheck quickcheck-text regex-tdfa

     

       136771
       136771
       +
                temporary text unordered-containers vector vty

     

       136399
       136772
        
              ];

     

       136400
       136773
        
              testHaskellDepends = [

     

       136401
       136401
       -
                base base16-bytestring binary bytestring containers free here HUnit

     

       136402
       136402
       -
                lens mtl QuickCheck sbv tasty tasty-hunit tasty-quickcheck text

     

       136403
       136403
       -
                vector

     

       136774
       136774
       +
                array base base16-bytestring binary bytestring containers

     

       136775
       136775
       +
                data-dword directory here HUnit lens mtl process QuickCheck

     

       136776
       136776
       +
                quickcheck-instances regex regex-tdfa smt2-parser tasty

     

       136777
       136777
       +
                tasty-expected-failure tasty-hunit tasty-quickcheck temporary text

     

       136778
       136778
       +
                time vector

     

       136404
       136779
        
              ];

     

       136405
       136780
        
              testSystemDepends = [ secp256k1 ];

     

       136781
       136781
       +
              doHaddock = false;

     

       136406
       136782
        
              description = "Ethereum virtual machine evaluator";

     

       136407
       136783
        
              license = lib.licenses.agpl3Only;

     

       136408
       136784
        
              hydraPlatforms = lib.platforms.none;

     

       136409
       136785
        
              mainProgram = "hevm";

     

       136410
       136786
        
              maintainers = [ lib.maintainers.arturcygan ];

     

       136787
       136787
       +
              broken = true;

     

       136411
       136788
        
            }) {inherit (pkgs) libff; inherit (pkgs) secp256k1;};

     

       136412
       136789
        
       

     

       136413
       136790
        
         "hevolisa" = callPackage

     
···

       149386
       149763
        
              license = lib.licenses.mit;

     

       149387
       149764
        
            }) {};

     

       149388
       149765
        
       

     

       149389
       149389
       -
         "hspec_2_10_7" = callPackage

     

       149766
       149766
       +
         "hspec_2_10_8" = callPackage

     

       149390
       149767
        
           ({ mkDerivation, base, hspec-core, hspec-discover

     

       149391
       149768
        
            , hspec-expectations, QuickCheck

     

       149392
       149769
        
            }:

     

       149393
       149770
        
            mkDerivation {

     

       149394
       149771
        
              pname = "hspec";

     

       149395
       149395
       -
              version = "2.10.7";

     

       149396
       149396
       -
              sha256 = "136icn9f0prl4p1yphaf2yzaq9zc8vaiq9xv5v76c5j95agvp9rr";

     

       149772
       149772
       +
              version = "2.10.8";

     

       149773
       149773
       +
              sha256 = "13g46fk7hcnk3058pb2wwq257pi8628qaa9md9sfw5rlw878z25r";

     

       149397
       149774
        
              libraryHaskellDepends = [

     

       149398
       149775
        
                base hspec-core hspec-discover hspec-expectations QuickCheck

     

       149399
       149776
        
              ];

     
···

       149516
       149893
        
              license = lib.licenses.mit;

     

       149517
       149894
        
            }) {};

     

       149518
       149895
        
       

     

       149519
       149519
       -
         "hspec-core_2_10_7" = callPackage

     

       149896
       149896
       +
         "hspec-core_2_10_8" = callPackage

     

       149520
       149897
        
           ({ mkDerivation, ansi-terminal, array, base, base-orphans

     

       149521
       149898
        
            , call-stack, deepseq, directory, filepath, haskell-lexer

     

       149522
       149899
        
            , hspec-expectations, hspec-meta, HUnit, process, QuickCheck

     
···

       149525
       149902
        
            }:

     

       149526
       149903
        
            mkDerivation {

     

       149527
       149904
        
              pname = "hspec-core";

     

       149528
       149528
       -
              version = "2.10.7";

     

       149529
       149529
       -
              sha256 = "01ikjgdc5fpblw7y1h50j0dbgw3drjz26slcalzhvqza7523jn2g";

     

       149905
       149905
       +
              version = "2.10.8";

     

       149906
       149906
       +
              sha256 = "0bka7r8b2qh82sxnz5mcfw2swl4k2v3q97yb0n1rhs1g444lfcqn";

     

       149530
       149907
        
              libraryHaskellDepends = [

     

       149531
       149908
        
                ansi-terminal array base call-stack deepseq directory filepath

     

       149532
       149909
        
                haskell-lexer hspec-expectations HUnit process QuickCheck

     
···

       149607
       149984
        
              maintainers = [ lib.maintainers.maralorn ];

     

       149608
       149985
        
            }) {};

     

       149609
       149986
        
       

     

       149610
       149610
       -
         "hspec-discover_2_10_7" = callPackage

     

       149987
       149987
       +
         "hspec-discover_2_10_8" = callPackage

     

       149611
       149988
        
           ({ mkDerivation, base, directory, filepath, hspec-meta, mockery

     

       149612
       149989
        
            , QuickCheck

     

       149613
       149990
        
            }:

     

       149614
       149991
        
            mkDerivation {

     

       149615
       149992
        
              pname = "hspec-discover";

     

       149616
       149616
       -
              version = "2.10.7";

     

       149617
       149617
       -
              sha256 = "0xx38v8b8xplqi2jazng57z4xfm9lzb21ldpm428s28kl71br1vd";

     

       149993
       149993
       +
              version = "2.10.8";

     

       149994
       149994
       +
              sha256 = "032s5mfr9sw2bgdi2l6fy8jdwm79nr896dw1ha16m94m8596vmph";

     

       149618
       149995
        
              isLibrary = true;

     

       149619
       149996
        
              isExecutable = true;

     

       149620
       149997
        
              libraryHaskellDepends = [ base directory filepath ];

     
···

       154876
       155253
        
              mainProgram = "hw-json-simd";

     

       154877
       155254
        
            }) {};

     

       154878
       155255
        
       

     

       155256
       155256
       +
         "hw-json-simd_0_1_1_2" = callPackage

     

       155257
       155257
       +
           ({ mkDerivation, base, bytestring, c2hs, doctest, doctest-discover

     

       155258
       155258
       +
            , hw-prim, lens, optparse-applicative, transformers, vector

     

       155259
       155259
       +
            }:

     

       155260
       155260
       +
            mkDerivation {

     

       155261
       155261
       +
              pname = "hw-json-simd";

     

       155262
       155262
       +
              version = "0.1.1.2";

     

       155263
       155263
       +
              sha256 = "03g2gwmkp6v7b0vf4x8bh4qk91ghr0av5x3c9paj3rp3igycccd6";

     

       155264
       155264
       +
              isLibrary = true;

     

       155265
       155265
       +
              isExecutable = true;

     

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

     

       155267
       155267
       +
              libraryToolDepends = [ c2hs ];

     

       155268
       155268
       +
              executableHaskellDepends = [

     

       155269
       155269
       +
                base bytestring hw-prim lens optparse-applicative vector

     

       155270
       155270
       +
              ];

     

       155271
       155271
       +
              testHaskellDepends = [

     

       155272
       155272
       +
                base bytestring doctest doctest-discover hw-prim lens transformers

     

       155273
       155273
       +
                vector

     

       155274
       155274
       +
              ];

     

       155275
       155275
       +
              testToolDepends = [ doctest-discover ];

     

       155276
       155276
       +
              description = "SIMD-based JSON semi-indexer";

     

       155277
       155277
       +
              license = lib.licenses.bsd3;

     

       155278
       155278
       +
              hydraPlatforms = lib.platforms.none;

     

       155279
       155279
       +
              mainProgram = "hw-json-simd";

     

       155280
       155280
       +
            }) {};

     

       155281
       155281
       +
       

     

       154879
       155282
        
         "hw-json-simple-cursor" = callPackage

     

       154880
       155283
        
           ({ mkDerivation, base, bytestring, criterion, directory, doctest

     

       154881
       155284
        
            , doctest-discover, generic-lens, hedgehog, hspec, hspec-discover

     
···

       155323
       155726
        
              license = lib.licenses.bsd3;

     

       155324
       155727
        
            }) {};

     

       155325
       155728
        
       

     

       155729
       155729
       +
         "hw-simd_0_1_2_2" = callPackage

     

       155730
       155730
       +
           ({ mkDerivation, base, bits-extra, bytestring, c2hs, cassava

     

       155731
       155731
       +
            , containers, criterion, deepseq, directory, doctest

     

       155732
       155732
       +
            , doctest-discover, hedgehog, hspec, hspec-discover, hw-bits

     

       155733
       155733
       +
            , hw-hedgehog, hw-hspec-hedgehog, hw-prim, hw-rankselect

     

       155734
       155734
       +
            , hw-rankselect-base, lens, mmap, text, transformers, vector

     

       155735
       155735
       +
            }:

     

       155736
       155736
       +
            mkDerivation {

     

       155737
       155737
       +
              pname = "hw-simd";

     

       155738
       155738
       +
              version = "0.1.2.2";

     

       155739
       155739
       +
              sha256 = "0ipcrv19xwmq6znbmwmzrjahmymmcmpbs7hpx0183hrwbx2hyhqx";

     

       155740
       155740
       +
              libraryHaskellDepends = [

     

       155741
       155741
       +
                base bits-extra bytestring deepseq hw-bits hw-prim hw-rankselect

     

       155742
       155742
       +
                hw-rankselect-base transformers vector

     

       155743
       155743
       +
              ];

     

       155744
       155744
       +
              libraryToolDepends = [ c2hs ];

     

       155745
       155745
       +
              testHaskellDepends = [

     

       155746
       155746
       +
                base bits-extra bytestring deepseq directory doctest

     

       155747
       155747
       +
                doctest-discover hedgehog hspec hw-bits hw-hedgehog

     

       155748
       155748
       +
                hw-hspec-hedgehog hw-prim hw-rankselect hw-rankselect-base lens

     

       155749
       155749
       +
                text vector

     

       155750
       155750
       +
              ];

     

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

     

       155752
       155752
       +
              benchmarkHaskellDepends = [

     

       155753
       155753
       +
                base bits-extra bytestring cassava containers criterion deepseq

     

       155754
       155754
       +
                directory hw-bits hw-prim hw-rankselect hw-rankselect-base mmap

     

       155755
       155755
       +
                transformers vector

     

       155756
       155756
       +
              ];

     

       155757
       155757
       +
              description = "SIMD library";

     

       155758
       155758
       +
              license = lib.licenses.bsd3;

     

       155759
       155759
       +
              hydraPlatforms = lib.platforms.none;

     

       155760
       155760
       +
            }) {};

     

       155761
       155761
       +
       

     

       155326
       155762
        
         "hw-simd-cli" = callPackage

     

       155327
       155763
        
           ({ mkDerivation, base, bits-extra, bytestring, containers, deepseq

     

       155328
       155764
        
            , directory, doctest, doctest-discover, generic-lens, hw-bits

     
···

       158810
       159246
        
            }:

     

       158811
       159247
        
            mkDerivation {

     

       158812
       159248
        
              pname = "implicit-hie";

     

       158813
       158813
       -
              version = "0.1.2.7";

     

       158814
       158814
       -
              sha256 = "0yb457n26455kbq6kv8g48q66pmmaxcpikmpg9gm00sd6adgq6gl";

     

       159249
       159249
       +
              version = "0.1.4.0";

     

       159250
       159250
       +
              sha256 = "08ggdlh5j1ya5rjhvcp1k1iyd5bvrgm865qnaxnqz7xvq7b1864k";

     

       158815
       159251
        
              isLibrary = true;

     

       158816
       159252
        
              isExecutable = true;

     

       158817
       159253
        
              libraryHaskellDepends = [

     
···

       159898
       160334
        
              description = "Type inference and checker for JavaScript (experimental)";

     

       159899
       160335
        
              license = lib.licenses.gpl2Only;

     

       159900
       160336
        
              hydraPlatforms = lib.platforms.none;

     

       160337
       160337
       +
            }) {};

     

       160338
       160338
       +
       

     

       160339
       160339
       +
         "infinite-list" = callPackage

     

       160340
       160340
       +
           ({ mkDerivation, base, QuickCheck, tasty, tasty-bench

     

       160341
       160341
       +
            , tasty-expected-failure, tasty-inspection-testing

     

       160342
       160342
       +
            , tasty-quickcheck

     

       160343
       160343
       +
            }:

     

       160344
       160344
       +
            mkDerivation {

     

       160345
       160345
       +
              pname = "infinite-list";

     

       160346
       160346
       +
              version = "0.1";

     

       160347
       160347
       +
              sha256 = "0imayklahbpsiciflwvwj3fxjhg461lw6x4515wxr39hgpb18di1";

     

       160348
       160348
       +
              libraryHaskellDepends = [ base ];

     

       160349
       160349
       +
              testHaskellDepends = [

     

       160350
       160350
       +
                base QuickCheck tasty tasty-expected-failure

     

       160351
       160351
       +
                tasty-inspection-testing tasty-quickcheck

     

       160352
       160352
       +
              ];

     

       160353
       160353
       +
              benchmarkHaskellDepends = [ base tasty-bench ];

     

       160354
       160354
       +
              description = "Infinite lists";

     

       160355
       160355
       +
              license = lib.licenses.bsd3;

     

       159901
       160356
        
            }) {};

     

       159902
       160357
        
       

     

       159903
       160358
        
         "infinite-search" = callPackage

     
···

       181940
       182395
        
            , constraints, containers, cryptonite, data-default

     

       181941
       182396
        
            , first-class-families, fmt, lens, morley, morley-prelude, mtl

     

       181942
       182397
        
            , named, optparse-applicative, singletons, singletons-base

     

       181943
       181943
       -
            , template-haskell, text, text-manipulate, unordered-containers

     

       181944
       181944
       -
            , vinyl, with-utf8

     

       182398
       182398
       +
            , template-haskell, text, text-manipulate, type-errors

     

       182399
       182399
       +
            , unordered-containers, vinyl, with-utf8

     

       181945
       182400
        
            }:

     

       181946
       182401
        
            mkDerivation {

     

       181947
       182402
        
              pname = "lorentz";

     

       181948
       181948
       -
              version = "0.14.1";

     

       181949
       181949
       -
              sha256 = "0qvg3b0hmnjwarmvsynz7f2y362r6wszzm46168154xwmgyrkb3h";

     

       182403
       182403
       +
              version = "0.15.0";

     

       182404
       182404
       +
              sha256 = "10nppxymkp7b5vqcrkrm7jd5xg84hvczvvrrh2digdawqmxrakgl";

     

       181950
       182405
        
              libraryHaskellDepends = [

     

       181951
       182406
        
                aeson-pretty base-noprelude bimap bytestring constraints containers

     

       181952
       182407
        
                cryptonite data-default first-class-families fmt lens morley

     

       181953
       182408
        
                morley-prelude mtl named optparse-applicative singletons

     

       181954
       181954
       -
                singletons-base template-haskell text text-manipulate

     

       182409
       182409
       +
                singletons-base template-haskell text text-manipulate type-errors

     

       181955
       182410
        
                unordered-containers vinyl with-utf8

     

       181956
       182411
        
              ];

     

       181957
       182412
        
              description = "EDSL for the Michelson Language";

     
···

       187592
       188047
        
              description = "An Elf parser";

     

       187593
       188048
        
              license = lib.licenses.bsd3;

     

       187594
       188049
        
              hydraPlatforms = lib.platforms.none;

     

       188050
       188050
       +
              broken = true;

     

       187595
       188051
        
            }) {};

     

       187596
       188052
        
       

     

       187597
       188053
        
         "mellon-core" = callPackage

     
···

       192467
       192923
        
              pname = "monad-logger";

     

       192468
       192924
        
              version = "0.3.37";

     

       192469
       192925
        
              sha256 = "1z275a428zcj73zz0cpfha2adwiwqqqp7klx3kbd3i9rl20xa106";

     

       192470
       192470
       -
              revision = "2";

     

       192471
       192471
       -
              editedCabalFile = "1kkw07kk8gv7d9iarradqcqzjpdfh5shjlhfbf2v25mmcpchp6hd";

     

       192926
       192926
       +
              revision = "3";

     

       192927
       192927
       +
              editedCabalFile = "1dzkw08b4ijacdw0vcfxlr13rd819x2yj7b6sr9jrrwicd45zm1z";

     

       192472
       192928
        
              libraryHaskellDepends = [

     

       192473
       192929
        
                base bytestring conduit conduit-extra exceptions fast-logger

     

       192474
       192930
        
                lifted-base monad-control monad-loops mtl resourcet stm stm-chans

     
···

       193914
       194370
        
              license = lib.licenses.bsd3;

     

       193915
       194371
        
            }) {};

     

       193916
       194372
        
       

     

       194373
       194373
       +
         "monoid-extras_0_6_2" = callPackage

     

       194374
       194374
       +
           ({ mkDerivation, base, criterion, groups, semigroupoids, semigroups

     

       194375
       194375
       +
            }:

     

       194376
       194376
       +
            mkDerivation {

     

       194377
       194377
       +
              pname = "monoid-extras";

     

       194378
       194378
       +
              version = "0.6.2";

     

       194379
       194379
       +
              sha256 = "1qaxp0cf2cvzvfpk7x9mjz1zmlpjfzxij8v2n45w89s7bq9ckvlw";

     

       194380
       194380
       +
              libraryHaskellDepends = [ base groups semigroupoids ];

     

       194381
       194381
       +
              benchmarkHaskellDepends = [ base criterion semigroups ];

     

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

     

       194383
       194383
       +
              license = lib.licenses.bsd3;

     

       194384
       194384
       +
              hydraPlatforms = lib.platforms.none;

     

       194385
       194385
       +
            }) {};

     

       194386
       194386
       +
       

     

       193917
       194387
        
         "monoid-map" = callPackage

     

       193918
       194388
        
           ({ mkDerivation, base, commutative-semigroups, monoidal-containers

     

       193919
       194389
        
            , patch, reflex, witherable

     
···

       194460
       194930
        
         "morley" = callPackage

     

       194461
       194931
        
           ({ mkDerivation, aeson, aeson-casing, aeson-pretty, base-noprelude

     

       194462
       194932
        
            , base58-bytestring, bimap, binary, bytestring, constraints

     

       194463
       194463
       -
            , containers, crypto-sodium, cryptonite, data-default, Diff

     

       194464
       194464
       -
            , elliptic-curve, first-class-families, fmt, galois-field

     

       194465
       194465
       -
            , generic-deriving, gitrev, haskeline, hex-text, lens, megaparsec

     

       194466
       194466
       -
            , memory, MonadRandom, morley-prelude, mtl, named

     

       194467
       194467
       -
            , optparse-applicative, pairing, parser-combinators, scientific

     

       194468
       194468
       -
            , semigroups, show-type, singletons, singletons-base, syb

     

       194469
       194469
       -
            , template-haskell, text, text-manipulate, th-lift-instances

     

       194470
       194470
       -
            , th-reify-many, time, timerep, uncaught-exception

     

       194471
       194471
       -
            , unordered-containers, vector, vinyl, with-utf8, wl-pprint-text

     

       194933
       194933
       +
            , constraints-extras, containers, crypto-sodium, cryptonite

     

       194934
       194934
       +
            , data-default, dependent-sum-template, Diff, elliptic-curve

     

       194935
       194935
       +
            , first-class-families, fmt, galois-field, generic-deriving, gitrev

     

       194936
       194936
       +
            , haskeline, hex-text, lens, megaparsec, memory, MonadRandom

     

       194937
       194937
       +
            , morley-prelude, mtl, named, optparse-applicative, pairing

     

       194938
       194938
       +
            , parser-combinators, scientific, semigroups, show-type, singletons

     

       194939
       194939
       +
            , singletons-base, some, syb, template-haskell, text

     

       194940
       194940
       +
            , text-manipulate, th-lift-instances, th-reify-many, time, timerep

     

       194941
       194941
       +
            , type-errors, uncaught-exception, unordered-containers, vector

     

       194942
       194942
       +
            , vinyl, with-utf8, wl-pprint-text

     

       194472
       194943
        
            }:

     

       194473
       194944
        
            mkDerivation {

     

       194474
       194945
        
              pname = "morley";

     

       194475
       194475
       -
              version = "1.18.0";

     

       194476
       194476
       -
              sha256 = "0kv4rcq8yqdnmf14dsf03196nc717cih2pd574cc7qvfv2frwgh7";

     

       194946
       194946
       +
              version = "1.19.0";

     

       194947
       194947
       +
              sha256 = "12rps1k1bky7bkx0zl17j9vs07w8fll0576ip02jd6sn1i6541fg";

     

       194477
       194948
        
              isLibrary = true;

     

       194478
       194949
        
              isExecutable = true;

     

       194479
       194950
        
              libraryHaskellDepends = [

     

       194480
       194951
        
                aeson aeson-casing aeson-pretty base-noprelude base58-bytestring

     

       194481
       194481
       -
                bimap binary bytestring constraints containers crypto-sodium

     

       194482
       194482
       -
                cryptonite data-default Diff elliptic-curve first-class-families

     

       194483
       194483
       -
                fmt galois-field generic-deriving gitrev hex-text lens megaparsec

     

       194484
       194484
       -
                memory MonadRandom morley-prelude mtl named optparse-applicative

     

       194485
       194485
       -
                pairing parser-combinators scientific semigroups show-type

     

       194486
       194486
       -
                singletons singletons-base syb template-haskell text

     

       194487
       194487
       -
                text-manipulate th-lift-instances th-reify-many time timerep

     

       194952
       194952
       +
                bimap binary bytestring constraints constraints-extras containers

     

       194953
       194953
       +
                crypto-sodium cryptonite data-default dependent-sum-template Diff

     

       194954
       194954
       +
                elliptic-curve first-class-families fmt galois-field

     

       194955
       194955
       +
                generic-deriving gitrev hex-text lens megaparsec memory MonadRandom

     

       194956
       194956
       +
                morley-prelude mtl named optparse-applicative pairing

     

       194957
       194957
       +
                parser-combinators scientific semigroups show-type singletons

     

       194958
       194958
       +
                singletons-base some syb template-haskell text text-manipulate

     

       194959
       194959
       +
                th-lift-instances th-reify-many time timerep type-errors

     

       194488
       194960
        
                uncaught-exception unordered-containers vector vinyl with-utf8

     

       194489
       194961
        
                wl-pprint-text

     

       194490
       194962
        
              ];

     

       194491
       194963
        
              executableHaskellDepends = [

     

       194492
       194964
        
                aeson base-noprelude base58-bytestring bytestring fmt haskeline

     

       194493
       194493
       -
                hex-text megaparsec MonadRandom morley-prelude named

     

       194494
       194494
       -
                optparse-applicative singletons text vinyl with-utf8

     

       194965
       194965
       +
                hex-text megaparsec MonadRandom morley-prelude optparse-applicative

     

       194966
       194966
       +
                singletons text vinyl with-utf8

     

       194495
       194967
        
              ];

     

       194496
       194968
        
              description = "Developer tools for the Michelson Language";

     

       194497
       194969
        
              license = lib.licenses.mit;

     
···

       194505
       194977
        
            , containers, data-default, exceptions, fmt, hex-text

     

       194506
       194978
        
            , hspec-expectations, http-client, http-client-tls, http-types

     

       194507
       194979
        
            , HUnit, lens, lorentz, megaparsec, memory, morley, morley-prelude

     

       194508
       194508
       -
            , mtl, named, optparse-applicative, process, random

     

       194509
       194509
       -
            , safe-exceptions, scientific, servant, servant-client

     

       194510
       194510
       -
            , servant-client-core, singletons, syb, tasty, tasty-ant-xml

     

       194511
       194511
       -
            , tasty-discover, tasty-hunit-compat, text, time, universum

     

       194512
       194512
       -
            , unliftio

     

       194980
       194980
       +
            , mtl, optparse-applicative, process, random, safe-exceptions

     

       194981
       194981
       +
            , scientific, servant, servant-client, servant-client-core

     

       194982
       194982
       +
            , singletons, syb, tasty, tasty-ant-xml, tasty-discover

     

       194983
       194983
       +
            , tasty-hunit-compat, text, time, unliftio

     

       194513
       194984
        
            }:

     

       194514
       194985
        
            mkDerivation {

     

       194515
       194986
        
              pname = "morley-client";

     

       194516
       194516
       -
              version = "0.2.1";

     

       194517
       194517
       -
              sha256 = "0a55lmbk1b2h7469hv084a0gyp48w57hjz05wlpc4npm0gp1ijxw";

     

       194987
       194987
       +
              version = "0.3.0";

     

       194988
       194988
       +
              sha256 = "0wb6pgds6bijs2bfwdwzkpmhlbwfpx5lwxj4xj2pvd47410lzjfz";

     

       194518
       194989
        
              isLibrary = true;

     

       194519
       194990
        
              isExecutable = true;

     

       194520
       194991
        
              libraryHaskellDepends = [

     

       194521
       194992
        
                aeson aeson-casing base-noprelude binary bytestring co-log

     

       194522
       194993
        
                co-log-core colourista constraints containers data-default fmt

     

       194523
       194994
        
                hex-text http-client http-client-tls http-types lens lorentz

     

       194524
       194524
       -
                megaparsec memory morley morley-prelude mtl named

     

       194525
       194525
       -
                optparse-applicative process random safe-exceptions scientific

     

       194526
       194526
       -
                servant servant-client servant-client-core singletons syb text time

     

       194527
       194527
       -
                universum unliftio

     

       194995
       194995
       +
                megaparsec memory morley morley-prelude mtl optparse-applicative

     

       194996
       194996
       +
                process random scientific servant servant-client

     

       194997
       194997
       +
                servant-client-core singletons syb text time unliftio

     

       194528
       194998
        
              ];

     

       194529
       194999
        
              executableHaskellDepends = [

     

       194530
       195000
        
                aeson base-noprelude data-default fmt morley morley-prelude

     
···

       199172
       199642
        
              license = lib.licenses.mit;

     

       199173
       199643
        
              hydraPlatforms = lib.platforms.none;

     

       199174
       199644
        
              broken = true;

     

       199645
       199645
       +
            }) {};

     

       199646
       199646
       +
       

     

       199647
       199647
       +
         "named-text" = callPackage

     

       199648
       199648
       +
           ({ mkDerivation, base, deepseq, hashable, prettyprinter, sayable

     

       199649
       199649
       +
            , text

     

       199650
       199650
       +
            }:

     

       199651
       199651
       +
            mkDerivation {

     

       199652
       199652
       +
              pname = "named-text";

     

       199653
       199653
       +
              version = "1.0.1.0";

     

       199654
       199654
       +
              sha256 = "05v79ry6rlrpfvf36nkzf6l4xm2kzgpdrvaivg878nxcrni1gr78";

     

       199655
       199655
       +
              libraryHaskellDepends = [

     

       199656
       199656
       +
                base deepseq hashable prettyprinter sayable text

     

       199657
       199657
       +
              ];

     

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

     

       199659
       199659
       +
              license = lib.licenses.isc;

     

       199175
       199660
        
            }) {};

     

       199176
       199661
        
       

     

       199177
       199662
        
         "namelist" = callPackage

     
···

       208114
       208599
        
              mainProgram = "example";

     

       208115
       208600
        
            }) {};

     

       208116
       208601
        
       

     

       208602
       208602
       +
         "openapi3_3_2_3" = callPackage

     

       208603
       208603
       +
           ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries

     

       208604
       208604
       +
            , bytestring, Cabal, cabal-doctest, containers, cookie, doctest

     

       208605
       208605
       +
            , generics-sop, Glob, hashable, hspec, hspec-discover, http-media

     

       208606
       208606
       +
            , HUnit, insert-ordered-containers, lens, mtl, optics-core

     

       208607
       208607
       +
            , optics-th, QuickCheck, quickcheck-instances, scientific

     

       208608
       208608
       +
            , template-haskell, text, time, transformers, unordered-containers

     

       208609
       208609
       +
            , utf8-string, uuid-types, vector

     

       208610
       208610
       +
            }:

     

       208611
       208611
       +
            mkDerivation {

     

       208612
       208612
       +
              pname = "openapi3";

     

       208613
       208613
       +
              version = "3.2.3";

     

       208614
       208614
       +
              sha256 = "0svkzafxfmhjakv4h57p5sw59ksbxz1hn1y3fbg6zimwal4mgr6l";

     

       208615
       208615
       +
              isLibrary = true;

     

       208616
       208616
       +
              isExecutable = true;

     

       208617
       208617
       +
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       208618
       208618
       +
              libraryHaskellDepends = [

     

       208619
       208619
       +
                aeson aeson-pretty base base-compat-batteries bytestring containers

     

       208620
       208620
       +
                cookie generics-sop hashable http-media insert-ordered-containers

     

       208621
       208621
       +
                lens mtl optics-core optics-th QuickCheck scientific

     

       208622
       208622
       +
                template-haskell text time transformers unordered-containers

     

       208623
       208623
       +
                uuid-types vector

     

       208624
       208624
       +
              ];

     

       208625
       208625
       +
              executableHaskellDepends = [ aeson base lens text ];

     

       208626
       208626
       +
              testHaskellDepends = [

     

       208627
       208627
       +
                aeson base base-compat-batteries bytestring containers doctest Glob

     

       208628
       208628
       +
                hashable hspec HUnit insert-ordered-containers lens mtl QuickCheck

     

       208629
       208629
       +
                quickcheck-instances template-haskell text time

     

       208630
       208630
       +
                unordered-containers utf8-string vector

     

       208631
       208631
       +
              ];

     

       208632
       208632
       +
              testToolDepends = [ hspec-discover ];

     

       208633
       208633
       +
              description = "OpenAPI 3.0 data model";

     

       208634
       208634
       +
              license = lib.licenses.bsd3;

     

       208635
       208635
       +
              hydraPlatforms = lib.platforms.none;

     

       208636
       208636
       +
              mainProgram = "example";

     

       208637
       208637
       +
            }) {};

     

       208638
       208638
       +
       

     

       208117
       208639
        
         "openapi3-code-generator" = callPackage

     

       208118
       208640
        
           ({ mkDerivation, aeson, autodocodec, autodocodec-yaml, base

     

       208119
       208641
        
            , bytestring, containers, directory, filepath, genvalidity

     
···

       209793
       210315
        
              ];

     

       209794
       210316
        
              description = "Types and functions for Kepler orbits";

     

       209795
       210317
        
              license = lib.licenses.bsd3;

     

       209796
       209796
       -
              hydraPlatforms = lib.platforms.none;

     

       209797
       210318
        
              maintainers = [ lib.maintainers.expipiplus1 ];

     

       209798
       210319
        
            }) {};

     

       209799
       210320
        
       

     
···

       213229
       213750
        
            }:

     

       213230
       213751
        
            mkDerivation {

     

       213231
       213752
        
              pname = "parameterized-utils";

     

       213232
       213232
       -
              version = "2.1.5.0";

     

       213233
       213233
       -
              sha256 = "1w0r09kqqdwlj13xq5swzci0crmarxz49bc01vyb92xzrsmjkhss";

     

       213753
       213753
       +
              version = "2.1.6.0";

     

       213754
       213754
       +
              sha256 = "118inzvvr72bfr1pzgxglrpd2fsz0kn9hk791imygl0fv1258rb6";

     

       213234
       213755
        
              libraryHaskellDepends = [

     

       213235
       213756
        
                base base-orphans constraints containers deepseq ghc-prim hashable

     

       213236
       213757
        
                hashtables indexed-traversable lens mtl profunctors

     
···

       214610
       215131
        
            }:

     

       214611
       215132
        
            mkDerivation {

     

       214612
       215133
        
              pname = "patch";

     

       214613
       214613
       -
              version = "0.0.8.0";

     

       214614
       214614
       -
              sha256 = "1yxw960j78lx35i2ncipg33n6xdc1jmcmc64kyppygpzn20k3j68";

     

       215134
       215134
       +
              version = "0.0.8.1";

     

       215135
       215135
       +
              sha256 = "06hdh1x5lilz1w4gakixwf9r0x4x13a2cijgim8zjf7lq5irlmw5";

     

       214615
       215136
        
              libraryHaskellDepends = [

     

       214616
       215137
        
                base commutative-semigroups constraints-extras containers

     

       214617
       215138
        
                dependent-map dependent-sum indexed-traversable lens

     
···

       217124
       217645
        
              pname = "persistent-mongoDB";

     

       217125
       217646
        
              version = "2.13.0.1";

     

       217126
       217647
        
              sha256 = "1ck74kpzkz623c43qb8r1cjq8chi2p721vx95zrpciz8jm496235";

     

       217127
       217127
       -
              revision = "1";

     

       217128
       217128
       -
              editedCabalFile = "1h007vh9cx0y963xacxhf3rn2wjnc22ygil9c0z13mljmqssf5h6";

     

       217648
       217648
       +
              revision = "2";

     

       217649
       217649
       +
              editedCabalFile = "169wvga2zkgq0znvpnmpcyz0wy92sspjsrg48vyj2fr58yvvhbz5";

     

       217129
       217650
        
              libraryHaskellDepends = [

     

       217130
       217651
        
                aeson base bson bytestring cereal conduit http-api-data mongoDB

     

       217131
       217652
        
                network path-pieces persistent resource-pool resourcet text time

     
···

       222823
       223344
        
              license = lib.licenses.bsd3;

     

       222824
       223345
        
            }) {};

     

       222825
       223346
        
       

     

       223347
       223347
       +
         "polysemy_1_8_0_0" = callPackage

     

       223348
       223348
       +
           ({ mkDerivation, async, base, Cabal, cabal-doctest, containers

     

       223349
       223349
       +
            , doctest, first-class-families, hspec, hspec-discover

     

       223350
       223350
       +
            , inspection-testing, mtl, stm, syb, template-haskell

     

       223351
       223351
       +
            , th-abstraction, transformers, type-errors, unagi-chan

     

       223352
       223352
       +
            }:

     

       223353
       223353
       +
            mkDerivation {

     

       223354
       223354
       +
              pname = "polysemy";

     

       223355
       223355
       +
              version = "1.8.0.0";

     

       223356
       223356
       +
              sha256 = "1fyysldfnirhk8nfgiji248rc35c97r0hm4hk6j1n12ynhxcaiwb";

     

       223357
       223357
       +
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       223358
       223358
       +
              libraryHaskellDepends = [

     

       223359
       223359
       +
                async base containers first-class-families mtl stm syb

     

       223360
       223360
       +
                template-haskell th-abstraction transformers type-errors unagi-chan

     

       223361
       223361
       +
              ];

     

       223362
       223362
       +
              testHaskellDepends = [

     

       223363
       223363
       +
                async base containers doctest first-class-families hspec

     

       223364
       223364
       +
                hspec-discover inspection-testing mtl stm syb template-haskell

     

       223365
       223365
       +
                th-abstraction transformers type-errors unagi-chan

     

       223366
       223366
       +
              ];

     

       223367
       223367
       +
              testToolDepends = [ hspec-discover ];

     

       223368
       223368
       +
              description = "Higher-order, low-boilerplate free monads";

     

       223369
       223369
       +
              license = lib.licenses.bsd3;

     

       223370
       223370
       +
              hydraPlatforms = lib.platforms.none;

     

       223371
       223371
       +
            }) {};

     

       223372
       223372
       +
       

     

       222826
       223373
        
         "polysemy-RandomFu" = callPackage

     

       222827
       223374
        
           ({ mkDerivation, base, hspec, hspec-discover, mtl, polysemy

     

       222828
       223375
        
            , polysemy-plugin, polysemy-zoo, random, random-fu, random-source

     
···

       222853
       223400
        
            }:

     

       222854
       223401
        
            mkDerivation {

     

       222855
       223402
        
              pname = "polysemy-check";

     

       222856
       222856
       -
              version = "0.9.0.0";

     

       222857
       222857
       -
              sha256 = "092p92aavd3jqq7kjp3n2kx3zyg6k49zd99rliaw4gvgn6zk8k0l";

     

       223403
       223403
       +
              version = "0.9.0.1";

     

       223404
       223404
       +
              sha256 = "0zv6sf379pcnrj39hzmgmw0r0d4nsfizcsgl00c6c5f7n17cc53b";

     

       222858
       223405
        
              libraryHaskellDepends = [

     

       222859
       223406
        
                base containers kind-generics kind-generics-th polysemy QuickCheck

     

       222860
       223407
        
              ];

     
···

       228183
       228730
        
           ({ mkDerivation, base, containers, hspec, random }:

     

       228184
       228731
        
            mkDerivation {

     

       228185
       228732
        
              pname = "prob";

     

       228186
       228186
       -
              version = "0.1.0.0";

     

       228187
       228187
       -
              sha256 = "1y0xfcjpkg72nj3rp6pfwjxdwqf74hdi30h1ih198kkpa0nsazyh";

     

       228733
       228733
       +
              version = "0.1.1";

     

       228734
       228734
       +
              sha256 = "0ra2g9l5lir5j0z9c2j8n4gqyxdfkj8v4qdbm7z6b6l9ii2lq8cn";

     

       228188
       228735
        
              libraryHaskellDepends = [ base containers random ];

     

       228189
       228736
        
              testHaskellDepends = [ base hspec ];

     

       228190
       228737
        
              description = "Discrete probability monad";

     
···

       230032
       230579
        
              license = lib.licenses.bsd3;

     

       230033
       230580
        
            }) {};

     

       230034
       230581
        
       

     

       230582
       230582
       +
         "protobuf-builder" = callPackage

     

       230583
       230583
       +
           ({ mkDerivation, array-builder, base, bytebuild, byteslice

     

       230584
       230584
       +
            , bytestring, natural-arithmetic, primitive, run-st, text-short

     

       230585
       230585
       +
            , zigzag

     

       230586
       230586
       +
            }:

     

       230587
       230587
       +
            mkDerivation {

     

       230588
       230588
       +
              pname = "protobuf-builder";

     

       230589
       230589
       +
              version = "0.1.0.0";

     

       230590
       230590
       +
              sha256 = "0qv7vhg250sfah13likpj4jqkldr8lqvcxvlajp2cx3k69sfv1f9";

     

       230591
       230591
       +
              libraryHaskellDepends = [

     

       230592
       230592
       +
                array-builder base bytebuild byteslice bytestring

     

       230593
       230593
       +
                natural-arithmetic primitive run-st text-short zigzag

     

       230594
       230594
       +
              ];

     

       230595
       230595
       +
              description = "Slow protobuf implementation";

     

       230596
       230596
       +
              license = lib.licenses.bsd3;

     

       230597
       230597
       +
            }) {};

     

       230598
       230598
       +
       

     

       230035
       230599
        
         "protobuf-native" = callPackage

     

       230036
       230600
        
           ({ mkDerivation, base, bytestring, cereal, cplusplus-th, criterion

     

       230037
       230601
        
            , hprotoc-fork, protobuf, protocol-buffers-fork, QuickCheck

     
···

       236120
       236684
        
              license = lib.licenses.bsd3;

     

       236121
       236685
        
            }) {};

     

       236122
       236686
        
       

     

       236687
       236687
       +
         "raylib-imgui" = callPackage

     

       236688
       236688
       +
           ({ mkDerivation, base, h-raylib }:

     

       236689
       236689
       +
            mkDerivation {

     

       236690
       236690
       +
              pname = "raylib-imgui";

     

       236691
       236691
       +
              version = "4.5.0.9";

     

       236692
       236692
       +
              sha256 = "1b2363czcxzg22d5mjr6y480lzv82v0hkyabq7821zgb9y5v3879";

     

       236693
       236693
       +
              isLibrary = true;

     

       236694
       236694
       +
              isExecutable = true;

     

       236695
       236695
       +
              libraryHaskellDepends = [ base h-raylib ];

     

       236696
       236696
       +
              description = "Haskell bindings for rlImGui";

     

       236697
       236697
       +
              license = lib.licenses.asl20;

     

       236698
       236698
       +
            }) {};

     

       236699
       236699
       +
       

     

       236123
       236700
        
         "raz" = callPackage

     

       236124
       236701
        
           ({ mkDerivation, base, containers, criterion, deepseq, MonadRandom

     

       236125
       236702
        
            , random, transformers

     
···

       238418
       238995
        
              license = lib.licenses.bsd3;

     

       238419
       238996
        
            }) {};

     

       238420
       238997
        
       

     

       238998
       238998
       +
         "reflex_0_9_0_0" = callPackage

     

       238999
       238999
       +
           ({ mkDerivation, base, bifunctors, commutative-semigroups, comonad

     

       239000
       239000
       +
            , constraints, constraints-extras, containers, criterion

     

       239001
       239001
       +
            , data-default, deepseq, dependent-map, dependent-sum, directory

     

       239002
       239002
       +
            , exception-transformers, filemanip, filepath, haskell-src-exts

     

       239003
       239003
       +
            , haskell-src-meta, hlint, hspec, lens, loch-th, MemoTrie, mmorph

     

       239004
       239004
       +
            , monad-control, monoidal-containers, mtl, patch, prim-uniq

     

       239005
       239005
       +
            , primitive, process, proctest, profunctors, random, ref-tf

     

       239006
       239006
       +
            , reflection, semialign, semigroupoids, split, stm, syb

     

       239007
       239007
       +
            , template-haskell, text, these, these-lens, time, transformers

     

       239008
       239008
       +
            , unbounded-delays, witherable

     

       239009
       239009
       +
            }:

     

       239010
       239010
       +
            mkDerivation {

     

       239011
       239011
       +
              pname = "reflex";

     

       239012
       239012
       +
              version = "0.9.0.0";

     

       239013
       239013
       +
              sha256 = "0g22b2bkv6l2m7aiz7kqi3x572qhzy0hikvpysrq2jffl02by0lm";

     

       239014
       239014
       +
              libraryHaskellDepends = [

     

       239015
       239015
       +
                base bifunctors commutative-semigroups comonad constraints

     

       239016
       239016
       +
                constraints-extras containers data-default dependent-map

     

       239017
       239017
       +
                dependent-sum exception-transformers haskell-src-exts

     

       239018
       239018
       +
                haskell-src-meta lens MemoTrie mmorph monad-control

     

       239019
       239019
       +
                monoidal-containers mtl patch prim-uniq primitive profunctors

     

       239020
       239020
       +
                random ref-tf reflection semialign semigroupoids stm syb

     

       239021
       239021
       +
                template-haskell these time transformers unbounded-delays

     

       239022
       239022
       +
                witherable

     

       239023
       239023
       +
              ];

     

       239024
       239024
       +
              testHaskellDepends = [

     

       239025
       239025
       +
                base bifunctors commutative-semigroups constraints

     

       239026
       239026
       +
                constraints-extras containers deepseq dependent-map dependent-sum

     

       239027
       239027
       +
                directory filemanip filepath hlint hspec lens monoidal-containers

     

       239028
       239028
       +
                mtl patch proctest ref-tf semialign split text these these-lens

     

       239029
       239029
       +
                transformers witherable

     

       239030
       239030
       +
              ];

     

       239031
       239031
       +
              benchmarkHaskellDepends = [

     

       239032
       239032
       +
                base containers criterion deepseq dependent-map dependent-sum

     

       239033
       239033
       +
                loch-th mtl primitive process ref-tf split stm time transformers

     

       239034
       239034
       +
              ];

     

       239035
       239035
       +
              description = "Higher-order Functional Reactive Programming";

     

       239036
       239036
       +
              license = lib.licenses.bsd3;

     

       239037
       239037
       +
              hydraPlatforms = lib.platforms.none;

     

       239038
       239038
       +
            }) {};

     

       239039
       239039
       +
       

     

       238421
       239040
        
         "reflex-animation" = callPackage

     

       238422
       239041
        
           ({ mkDerivation, base, bifunctors, containers, profunctors, reflex

     

       238423
       239042
        
            , reflex-transformers, semigroups, vector-space

     
···

       239135
       239754
        
            }:

     

       239136
       239755
        
            mkDerivation {

     

       239137
       239756
        
              pname = "reflex-vty";

     

       239138
       239138
       -
              version = "0.3.1.0";

     

       239139
       239139
       -
              sha256 = "1dkfrz580rqwir2y54im2ymjq7lgxjy888lq240jarhnr2yc32xi";

     

       239757
       239757
       +
              version = "0.3.1.1";

     

       239758
       239758
       +
              sha256 = "0yzp0lvhadh6164k8lmm5464r3x72951vvg4ii4kf848bjxh7iw6";

     

       239140
       239759
        
              isLibrary = true;

     

       239141
       239760
        
              isExecutable = true;

     

       239142
       239761
        
              libraryHaskellDepends = [

     
···

       243575
       244194
        
            }:

     

       243576
       244195
        
            mkDerivation {

     

       243577
       244196
        
              pname = "rhine";

     

       243578
       243578
       -
              version = "0.8.0.1";

     

       243579
       243579
       -
              sha256 = "07cw0xlj0nwbx0wjb3k4hpw5y6ksp25c1fa8xrrbaqv2jspv7z75";

     

       244197
       244197
       +
              version = "0.8.1";

     

       244198
       244198
       +
              sha256 = "15yklhx5gv8z60ky9ck2rkc9yb9m5jbziwp49a8gk0s03ii8scrz";

     

       243580
       244199
        
              libraryHaskellDepends = [

     

       243581
       244200
        
                base containers deepseq dunai free MonadRandom random

     

       243582
       244201
        
                simple-affine-space time time-domain transformers vector-sized

     
···

       243592
       244211
        
           ({ mkDerivation, base, dunai, gloss, rhine, transformers }:

     

       243593
       244212
        
            mkDerivation {

     

       243594
       244213
        
              pname = "rhine-gloss";

     

       243595
       243595
       -
              version = "0.8.0.1";

     

       243596
       243596
       -
              sha256 = "0qpza2n84illhlmqsz2xqj5k6a3jxb1kb9qhw6gz5fh4p4k8jqyl";

     

       244214
       244214
       +
              version = "0.8.1";

     

       244215
       244215
       +
              sha256 = "1lai9ii3q069zf49ls6cfdgjgq6njybxax45dqzqnxd59p0p9rrm";

     

       243597
       244216
        
              isLibrary = true;

     

       243598
       244217
        
              isExecutable = true;

     

       243599
       244218
        
              libraryHaskellDepends = [ base dunai gloss rhine transformers ];

     
···

       243605
       244224
        
              maintainers = [ lib.maintainers.turion ];

     

       243606
       244225
        
            }) {};

     

       243607
       244226
        
       

     

       244227
       244227
       +
         "rhine-terminal" = callPackage

     

       244228
       244228
       +
           ({ mkDerivation, base, dunai, exceptions, hspec, rhine, stm

     

       244229
       244229
       +
            , terminal, text, time, transformers

     

       244230
       244230
       +
            }:

     

       244231
       244231
       +
            mkDerivation {

     

       244232
       244232
       +
              pname = "rhine-terminal";

     

       244233
       244233
       +
              version = "0.8.1";

     

       244234
       244234
       +
              sha256 = "1fmmzy8qdyk9c1vv2l2n0xs0f1fw46mcgyzmid60wrgw90h02sp7";

     

       244235
       244235
       +
              isLibrary = true;

     

       244236
       244236
       +
              isExecutable = true;

     

       244237
       244237
       +
              libraryHaskellDepends = [

     

       244238
       244238
       +
                base dunai exceptions rhine terminal time transformers

     

       244239
       244239
       +
              ];

     

       244240
       244240
       +
              executableHaskellDepends = [ base rhine terminal text time ];

     

       244241
       244241
       +
              testHaskellDepends = [

     

       244242
       244242
       +
                base exceptions hspec rhine stm terminal text time transformers

     

       244243
       244243
       +
              ];

     

       244244
       244244
       +
              description = "Terminal backend for Rhine";

     

       244245
       244245
       +
              license = lib.licenses.bsd3;

     

       244246
       244246
       +
              hydraPlatforms = lib.platforms.none;

     

       244247
       244247
       +
              mainProgram = "rhine-terminal-simple";

     

       244248
       244248
       +
            }) {};

     

       244249
       244249
       +
       

     

       243608
       244250
        
         "rhythm-game-tutorial" = callPackage

     

       243609
       244251
        
           ({ mkDerivation, base, call, containers, lens, mtl, objective

     

       243610
       244252
        
            , split

     
···

       248168
       248810
        
              broken = true;

     

       248169
       248811
        
            }) {};

     

       248170
       248812
        
       

     

       248813
       248813
       +
         "sarif" = callPackage

     

       248814
       248814
       +
           ({ mkDerivation, aeson, base, bytestring, containers, text

     

       248815
       248815
       +
            , uuid-types

     

       248816
       248816
       +
            }:

     

       248817
       248817
       +
            mkDerivation {

     

       248818
       248818
       +
              pname = "sarif";

     

       248819
       248819
       +
              version = "0.1";

     

       248820
       248820
       +
              sha256 = "17i9fkh2vm5ywi8h4b2h0f7hfqr484kg1dqrhj563a5idw4jqi0v";

     

       248821
       248821
       +
              libraryHaskellDepends = [

     

       248822
       248822
       +
                aeson base bytestring containers text uuid-types

     

       248823
       248823
       +
              ];

     

       248824
       248824
       +
              description = "SARIF implementation for Haskell";

     

       248825
       248825
       +
              license = lib.licenses.mit;

     

       248826
       248826
       +
            }) {};

     

       248827
       248827
       +
       

     

       248171
       248828
        
         "sarsi" = callPackage

     

       248172
       248829
        
           ({ mkDerivation, ansi-terminal, async, attoparsec, base, binary

     

       248173
       248830
        
            , bytestring, Cabal, containers, cryptonite, directory, filepath

     
···

       248464
       249121
        
              license = lib.licenses.bsd3;

     

       248465
       249122
        
            }) {};

     

       248466
       249123
        
       

     

       249124
       249124
       +
         "sayable" = callPackage

     

       249125
       249125
       +
           ({ mkDerivation, base, bytestring, exceptions, prettyprinter, text

     

       249126
       249126
       +
            }:

     

       249127
       249127
       +
            mkDerivation {

     

       249128
       249128
       +
              pname = "sayable";

     

       249129
       249129
       +
              version = "1.0.2.0";

     

       249130
       249130
       +
              sha256 = "041qjk1giqrsfis410r491c3b2s36ngsk64ihzpjb788xbr86adx";

     

       249131
       249131
       +
              libraryHaskellDepends = [

     

       249132
       249132
       +
                base bytestring exceptions prettyprinter text

     

       249133
       249133
       +
              ];

     

       249134
       249134
       +
              description = "Data structures, classes and operators for constructing context-adjusted pretty output";

     

       249135
       249135
       +
              license = lib.licenses.isc;

     

       249136
       249136
       +
            }) {};

     

       249137
       249137
       +
       

     

       248467
       249138
        
         "sbp" = callPackage

     

       248468
       249139
        
           ({ mkDerivation, aeson, aeson-pretty, array, base

     

       248469
       249140
        
            , base64-bytestring, basic-prelude, binary, binary-conduit

     
···

       248489
       249160
        
              testHaskellDepends = [ base basic-prelude tasty tasty-hunit ];

     

       248490
       249161
        
              description = "SwiftNav's SBP Library";

     

       248491
       249162
        
              license = lib.licenses.mit;

     

       249163
       249163
       +
            }) {};

     

       249164
       249164
       +
       

     

       249165
       249165
       +
         "sbp_4_10_0" = callPackage

     

       249166
       249166
       +
           ({ mkDerivation, aeson, aeson-pretty, array, base

     

       249167
       249167
       +
            , base64-bytestring, basic-prelude, binary, binary-conduit

     

       249168
       249168
       +
            , bytestring, cmdargs, conduit, conduit-extra, data-binary-ieee754

     

       249169
       249169
       +
            , lens, lens-aeson, monad-loops, resourcet, tasty, tasty-hunit

     

       249170
       249170
       +
            , template-haskell, text, time, yaml

     

       249171
       249171
       +
            }:

     

       249172
       249172
       +
            mkDerivation {

     

       249173
       249173
       +
              pname = "sbp";

     

       249174
       249174
       +
              version = "4.10.0";

     

       249175
       249175
       +
              sha256 = "1mhnqiqi6yv3mn0rcwiq5k79a2zxcpqp4284ziqrcjwnhjxd2cnf";

     

       249176
       249176
       +
              isLibrary = true;

     

       249177
       249177
       +
              isExecutable = true;

     

       249178
       249178
       +
              libraryHaskellDepends = [

     

       249179
       249179
       +
                aeson array base base64-bytestring basic-prelude binary bytestring

     

       249180
       249180
       +
                data-binary-ieee754 lens lens-aeson monad-loops template-haskell

     

       249181
       249181
       +
                text

     

       249182
       249182
       +
              ];

     

       249183
       249183
       +
              executableHaskellDepends = [

     

       249184
       249184
       +
                aeson aeson-pretty base basic-prelude binary-conduit bytestring

     

       249185
       249185
       +
                cmdargs conduit conduit-extra lens resourcet time yaml

     

       249186
       249186
       +
              ];

     

       249187
       249187
       +
              testHaskellDepends = [ base basic-prelude tasty tasty-hunit ];

     

       249188
       249188
       +
              description = "SwiftNav's SBP Library";

     

       249189
       249189
       +
              license = lib.licenses.mit;

     

       249190
       249190
       +
              hydraPlatforms = lib.platforms.none;

     

       248492
       249191
        
            }) {};

     

       248493
       249192
        
       

     

       248494
       249193
        
         "sbp2udp" = callPackage

     
···

       254176
       254875
        
              pname = "servant-openapi3";

     

       254177
       254876
        
              version = "2.0.1.5";

     

       254178
       254877
        
              sha256 = "0zcyqga4hbdyk34368108vv9vavzdhv26xphas7yppada2sshfay";

     

       254179
       254179
       -
              revision = "1";

     

       254180
       254180
       -
              editedCabalFile = "0bscnxbw1zd0f7ycjr54kxfdcxzndgbxpamc75r1yzly262xrc1b";

     

       254878
       254878
       +
              revision = "3";

     

       254879
       254879
       +
              editedCabalFile = "0xvs5a9zsg32iziznvvjhfji577xmza419xk0cy1hwamw17f43mi";

     

       254880
       254880
       +
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       254881
       254881
       +
              libraryHaskellDepends = [

     

       254882
       254882
       +
                aeson aeson-pretty base base-compat bytestring hspec http-media

     

       254883
       254883
       +
                insert-ordered-containers lens openapi3 QuickCheck servant

     

       254884
       254884
       +
                singleton-bool text unordered-containers

     

       254885
       254885
       +
              ];

     

       254886
       254886
       +
              testHaskellDepends = [

     

       254887
       254887
       +
                aeson base base-compat directory doctest filepath hspec lens

     

       254888
       254888
       +
                lens-aeson openapi3 QuickCheck servant template-haskell text time

     

       254889
       254889
       +
                utf8-string vector

     

       254890
       254890
       +
              ];

     

       254891
       254891
       +
              testToolDepends = [ hspec-discover ];

     

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

     

       254893
       254893
       +
              license = lib.licenses.bsd3;

     

       254894
       254894
       +
            }) {};

     

       254895
       254895
       +
       

     

       254896
       254896
       +
         "servant-openapi3_2_0_1_6" = callPackage

     

       254897
       254897
       +
           ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring

     

       254898
       254898
       +
            , Cabal, cabal-doctest, directory, doctest, filepath, hspec

     

       254899
       254899
       +
            , hspec-discover, http-media, insert-ordered-containers, lens

     

       254900
       254900
       +
            , lens-aeson, openapi3, QuickCheck, servant, singleton-bool

     

       254901
       254901
       +
            , template-haskell, text, time, unordered-containers, utf8-string

     

       254902
       254902
       +
            , vector

     

       254903
       254903
       +
            }:

     

       254904
       254904
       +
            mkDerivation {

     

       254905
       254905
       +
              pname = "servant-openapi3";

     

       254906
       254906
       +
              version = "2.0.1.6";

     

       254907
       254907
       +
              sha256 = "1hxz3n6l5l8p9s58sjilrn4lv1z17kfik0xdh05v5v1bzf0j2aij";

     

       254181
       254908
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       254182
       254909
        
              libraryHaskellDepends = [

     

       254183
       254910
        
                aeson aeson-pretty base base-compat bytestring hspec http-media

     
···

       254192
       254919
        
              testToolDepends = [ hspec-discover ];

     

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

     

       254194
       254921
        
              license = lib.licenses.bsd3;

     

       254922
       254922
       +
              hydraPlatforms = lib.platforms.none;

     

       254195
       254923
        
            }) {};

     

       254196
       254924
        
       

     

       254197
       254925
        
         "servant-options" = callPackage

     
···

       260086
       260814
        
              libraryHaskellDepends = [ base singletons singletons-base ];

     

       260087
       260815
        
              description = "Unary natural numbers relying on the singletons infrastructure";

     

       260088
       260816
        
              license = lib.licenses.bsd3;

     

       260089
       260089
       -
              hydraPlatforms = lib.platforms.none;

     

       260090
       260817
        
            }) {};

     

       260091
       260818
        
       

     

       260092
       260819
        
         "singleton-typelits" = callPackage

     
···

       260151
       260878
        
              ];

     

       260152
       260879
        
              description = "A promoted and singled version of the base library";

     

       260153
       260880
        
              license = lib.licenses.bsd3;

     

       260154
       260154
       -
              hydraPlatforms = lib.platforms.none;

     

       260155
       260155
       -
              broken = true;

     

       260156
       260881
        
            }) {};

     

       260157
       260882
        
       

     

       260158
       260883
        
         "singletons-base_3_1_1" = callPackage

     
···

       260176
       260901
        
              description = "A promoted and singled version of the base library";

     

       260177
       260902
        
              license = lib.licenses.bsd3;

     

       260178
       260903
        
              hydraPlatforms = lib.platforms.none;

     

       260179
       260179
       -
              broken = true;

     

       260180
       260904
        
            }) {};

     

       260181
       260905
        
       

     

       260182
       260906
        
         "singletons-presburger" = callPackage

     
···

       260195
       260919
        
              ];

     

       260196
       260920
        
              description = "Presburger Arithmetic Solver for GHC Type-level natural numbers with Singletons package";

     

       260197
       260921
        
              license = lib.licenses.bsd3;

     

       260198
       260198
       -
              hydraPlatforms = lib.platforms.none;

     

       260199
       260922
        
            }) {};

     

       260200
       260923
        
       

     

       260201
       260924
        
         "singletons-presburger_0_7_1_0" = callPackage

     
···

       261091
       261814
        
           ({ mkDerivation, base, containers, skylighting-core, text }:

     

       261092
       261815
        
            mkDerivation {

     

       261093
       261816
        
              pname = "skylighting-format-context";

     

       261094
       261094
       -
              version = "0.1";

     

       261095
       261095
       -
              sha256 = "066vnhzxknlwzm8wmrzfjfv8ikrj646j21cv9gwm898clqap4yp0";

     

       261817
       261817
       +
              version = "0.1.0.1";

     

       261818
       261818
       +
              sha256 = "1d4nf16wl2l4r627qnph09x21xwcq03r7bznqm08d4di1z241xv0";

     

       261096
       261819
        
              libraryHaskellDepends = [ base containers skylighting-core text ];

     

       261097
       261820
        
              description = "ConTeXt formatter for skylighting syntax highlighting library";

     

       261098
       261821
        
              license = lib.licenses.bsd3;

     
···

       268744
       269467
        
            , amazonka-cloudformation, amazonka-core, amazonka-ec2

     

       268745
       269468
        
            , amazonka-lambda, amazonka-sts, base, Blammo, bytestring, cfn-flip

     

       268746
       269469
        
            , conduit, containers, errors, exceptions, extra, filepath, Glob

     

       268747
       268747
       -
            , hspec, lens, lens-aeson, monad-logger, optparse-applicative

     

       268748
       268748
       -
            , resourcet, rio, text, time, unliftio, unliftio-core

     

       269470
       269470
       +
            , hspec, lens, lens-aeson, monad-logger, mtl, optparse-applicative

     

       269471
       269471
       +
            , QuickCheck, resourcet, rio, text, time, unliftio, unliftio-core

     

       268749
       269472
        
            , unordered-containers, uuid, yaml

     

       268750
       269473
        
            }:

     

       268751
       269474
        
            mkDerivation {

     

       268752
       269475
        
              pname = "stackctl";

     

       268753
       268753
       -
              version = "1.1.2.2";

     

       268754
       268754
       -
              sha256 = "1rwq3brdlspzf16kc0kybx9yl15505ixxf1y7fb8cwqjwkgbqssn";

     

       269476
       269476
       +
              version = "1.1.3.0";

     

       269477
       269477
       +
              sha256 = "16skijv82199x4q2w563bk9xcmwd4i6mdavdr89p16cf8mwqrr7m";

     

       268755
       269478
        
              isLibrary = true;

     

       268756
       269479
        
              isExecutable = true;

     

       268757
       269480
        
              libraryHaskellDepends = [

     

       268758
       269481
        
                aeson aeson-casing aeson-pretty amazonka amazonka-cloudformation

     

       268759
       269482
        
                amazonka-core amazonka-ec2 amazonka-lambda amazonka-sts base Blammo

     

       268760
       269483
        
                bytestring cfn-flip conduit containers errors exceptions extra

     

       268761
       268761
       -
                filepath Glob lens lens-aeson monad-logger optparse-applicative

     

       269484
       269484
       +
                filepath Glob lens lens-aeson monad-logger mtl optparse-applicative

     

       268762
       269485
        
                resourcet rio text time unliftio unliftio-core unordered-containers

     

       268763
       269486
        
                uuid yaml

     

       268764
       269487
        
              ];

     

       268765
       269488
        
              executableHaskellDepends = [ base ];

     

       268766
       268766
       -
              testHaskellDepends = [ base hspec yaml ];

     

       269489
       269489
       +
              testHaskellDepends = [ base bytestring hspec mtl QuickCheck yaml ];

     

       268767
       269490
        
              license = lib.licenses.mit;

     

       268768
       269491
        
              hydraPlatforms = lib.platforms.none;

     

       268769
       269492
        
              mainProgram = "stackctl";

     
···

       278727
       279450
        
              broken = true;

     

       278728
       279451
        
            }) {};

     

       278729
       279452
        
       

     

       279453
       279453
       +
         "tasty-autocollect_0_4_0" = callPackage

     

       279454
       279454
       +
           ({ mkDerivation, base, bytestring, containers, directory

     

       279455
       279455
       +
            , explainable-predicates, filepath, ghc, tasty

     

       279456
       279456
       +
            , tasty-expected-failure, tasty-golden, tasty-hunit

     

       279457
       279457
       +
            , tasty-quickcheck, template-haskell, temporary, text, transformers

     

       279458
       279458
       +
            , typed-process

     

       279459
       279459
       +
            }:

     

       279460
       279460
       +
            mkDerivation {

     

       279461
       279461
       +
              pname = "tasty-autocollect";

     

       279462
       279462
       +
              version = "0.4.0";

     

       279463
       279463
       +
              sha256 = "1nq5zaf3ly7n4mqprdgvgw2ixdxk7qdrl108ppncid43dfj560ik";

     

       279464
       279464
       +
              isLibrary = true;

     

       279465
       279465
       +
              isExecutable = true;

     

       279466
       279466
       +
              libraryHaskellDepends = [

     

       279467
       279467
       +
                base bytestring containers directory filepath ghc tasty

     

       279468
       279468
       +
                tasty-expected-failure template-haskell text transformers

     

       279469
       279469
       +
              ];

     

       279470
       279470
       +
              executableHaskellDepends = [ base text ];

     

       279471
       279471
       +
              testHaskellDepends = [

     

       279472
       279472
       +
                base bytestring containers directory explainable-predicates

     

       279473
       279473
       +
                filepath tasty tasty-golden tasty-hunit tasty-quickcheck temporary

     

       279474
       279474
       +
                text typed-process

     

       279475
       279475
       +
              ];

     

       279476
       279476
       +
              description = "Autocollection of tasty tests";

     

       279477
       279477
       +
              license = lib.licenses.bsd3;

     

       279478
       279478
       +
              hydraPlatforms = lib.platforms.none;

     

       279479
       279479
       +
              mainProgram = "tasty-autocollect";

     

       279480
       279480
       +
              broken = true;

     

       279481
       279481
       +
            }) {};

     

       279482
       279482
       +
       

     

       278730
       279483
        
         "tasty-bdd" = callPackage

     

       278731
       279484
        
           ({ mkDerivation, aeson, aeson-qq, base, exceptions, free, HUnit

     

       278732
       279485
        
            , microlens, microlens-th, mtl, pretty, pretty-show

     
···

       278936
       279689
        
              pname = "tasty-grading-system";

     

       278937
       279690
        
              version = "0.1.0.0";

     

       278938
       279691
        
              sha256 = "1r72gbylmv466naxkqsf56wlkp5kzhvyq0w3k7g47hs1rlslllmp";

     

       278939
       278939
       -
              revision = "2";

     

       278940
       278940
       -
              editedCabalFile = "1kr1113k6a0d8yd51lvl1689wdbq2lb2fp44rl6jzdaizxvj360f";

     

       279692
       279692
       +
              revision = "4";

     

       279693
       279693
       +
              editedCabalFile = "1h80pf2p13f33gl803xyg6znf1ychci9jqcl13xdxai1asb331hq";

     

       278941
       279694
        
              libraryHaskellDepends = [

     

       278942
       279695
        
                aeson base containers directory filepath generic-deriving mtl stm

     

       278943
       279696
        
                tagged tasty text

     
···

       285184
       285937
        
              benchmarkHaskellDepends = [ base criterion weigh ];

     

       285185
       285938
        
              description = "Pattern language for improvised music";

     

       285186
       285939
        
              license = lib.licenses.gpl3Only;

     

       285940
       285940
       +
            }) {};

     

       285941
       285941
       +
       

     

       285942
       285942
       +
         "tidal_1_9_3" = callPackage

     

       285943
       285943
       +
           ({ mkDerivation, base, bytestring, clock, colour, containers

     

       285944
       285944
       +
            , criterion, deepseq, exceptions, hosc, microspec, mtl, network

     

       285945
       285945
       +
            , parsec, primitive, random, text, tidal-link, transformers, weigh

     

       285946
       285946
       +
            }:

     

       285947
       285947
       +
            mkDerivation {

     

       285948
       285948
       +
              pname = "tidal";

     

       285949
       285949
       +
              version = "1.9.3";

     

       285950
       285950
       +
              sha256 = "1p3k65rgxjv701nk30jqf614bk1zmblyq0vlishzza2cdld5rhbc";

     

       285951
       285951
       +
              enableSeparateDataOutput = true;

     

       285952
       285952
       +
              libraryHaskellDepends = [

     

       285953
       285953
       +
                base bytestring clock colour containers deepseq exceptions hosc mtl

     

       285954
       285954
       +
                network parsec primitive random text tidal-link transformers

     

       285955
       285955
       +
              ];

     

       285956
       285956
       +
              testHaskellDepends = [

     

       285957
       285957
       +
                base containers deepseq hosc microspec parsec

     

       285958
       285958
       +
              ];

     

       285959
       285959
       +
              benchmarkHaskellDepends = [ base criterion weigh ];

     

       285960
       285960
       +
              description = "Pattern language for improvised music";

     

       285961
       285961
       +
              license = lib.licenses.gpl3Only;

     

       285962
       285962
       +
              hydraPlatforms = lib.platforms.none;

     

       285187
       285963
        
            }) {};

     

       285188
       285964
        
       

     

       285189
       285965
        
         "tidal-link" = callPackage

     
···

       292914
       293690
        
              license = lib.licenses.bsd3;

     

       292915
       293691
        
            }) {};

     

       292916
       293692
        
       

     

       293693
       293693
       +
         "typecheck-plugin-nat-simple_0_1_0_9" = callPackage

     

       293694
       293694
       +
           ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra }:

     

       293695
       293695
       +
            mkDerivation {

     

       293696
       293696
       +
              pname = "typecheck-plugin-nat-simple";

     

       293697
       293697
       +
              version = "0.1.0.9";

     

       293698
       293698
       +
              sha256 = "0ada389g1zmprwj2injmx49dcj8z6n1vxbbii4c6327mvw39ay0w";

     

       293699
       293699
       +
              enableSeparateDataOutput = true;

     

       293700
       293700
       +
              libraryHaskellDepends = [

     

       293701
       293701
       +
                base containers ghc ghc-tcplugins-extra

     

       293702
       293702
       +
              ];

     

       293703
       293703
       +
              testHaskellDepends = [ base containers ghc ghc-tcplugins-extra ];

     

       293704
       293704
       +
              description = "Simple type check plugin which calculate addition, subtraction and less-or-equal-than";

     

       293705
       293705
       +
              license = lib.licenses.bsd3;

     

       293706
       293706
       +
              hydraPlatforms = lib.platforms.none;

     

       293707
       293707
       +
            }) {};

     

       293708
       293708
       +
       

     

       292917
       293709
        
         "typed-admin" = callPackage

     

       292918
       293710
        
           ({ mkDerivation, base, blaze-markup, bytestring, data-default-class

     

       292919
       293711
        
            , exceptions, generic-lens, HDBC, HDBC-postgresql, HDBC-session

     
···

       294402
       295194
        
              description = "Thread delays and timeouts using proper time units";

     

       294403
       295195
        
              license = lib.licenses.bsd3;

     

       294404
       295196
        
              hydraPlatforms = lib.platforms.none;

     

       295197
       295197
       +
              broken = true;

     

       294405
       295198
        
            }) {};

     

       294406
       295199
        
       

     

       294407
       295200
        
         "unboxed" = callPackage

     
···

       295685
       296478
        
              ];

     

       295686
       296479
        
              description = "A domain-specific type system for dimensional analysis";

     

       295687
       296480
        
              license = lib.licenses.bsd3;

     

       295688
       295688
       -
              hydraPlatforms = lib.platforms.none;

     

       295689
       296481
        
            }) {};

     

       295690
       296482
        
       

     

       295691
       296483
        
         "units-attoparsec" = callPackage

     
···

       295702
       296494
        
              description = "Attoparsec parsers for the units package";

     

       295703
       296495
        
              license = lib.licenses.bsd3;

     

       295704
       296496
        
              hydraPlatforms = lib.platforms.none;

     

       296497
       296497
       +
              broken = true;

     

       295705
       296498
        
            }) {};

     

       295706
       296499
        
       

     

       295707
       296500
        
         "units-defs" = callPackage

     
···

       295713
       296506
        
              libraryHaskellDepends = [ base template-haskell units ];

     

       295714
       296507
        
              description = "Definitions for use with the units package";

     

       295715
       296508
        
              license = lib.licenses.bsd3;

     

       295716
       295716
       -
              hydraPlatforms = lib.platforms.none;

     

       295717
       296509
        
            }) {};

     

       295718
       296510
        
       

     

       295719
       296511
        
         "units-parser" = callPackage

     
···

       309257
       310049
        
            }:

     

       309258
       310050
        
            mkDerivation {

     

       309259
       310051
        
              pname = "xcffib";

     

       309260
       309260
       -
              version = "0.12.1";

     

       309261
       309261
       -
              sha256 = "0qpbm9jncpj7jy9xsbl1xy84mw2kmnfbd0m7g0qng80cifzvkqhi";

     

       310052
       310052
       +
              version = "1.1.2";

     

       310053
       310053
       +
              sha256 = "068g730p0rbsf1l7k9jgc9d7ng0zx3552wqk357wl3q56jac0chs";

     

       309262
       310054
        
              isLibrary = true;

     

       309263
       310055
        
              isExecutable = true;

     

       309264
       310056
        
              libraryHaskellDepends = [

     
···

       317041
       317833
        
              pname = "zip";

     

       317042
       317834
        
              version = "1.7.2";

     

       317043
       317835
        
              sha256 = "1c5pr3hv11dpn4ybd4742qkpqmvb9l3l7xmzlsf65wm2p8071dvj";

     

       317044
       317044
       -
              revision = "2";

     

       317045
       317045
       -
              editedCabalFile = "0gacj2fp0yg45l5vxby0n03lza91zfykk74p6a2r3abrfmvw7kq8";

     

       317836
       317836
       +
              revision = "3";

     

       317837
       317837
       +
              editedCabalFile = "0q72y8qsz1y01rlmi3chdb0p06qng7ffzv0ylmiqqn36f9qjl405";

     

       317046
       317838
        
              isLibrary = true;

     

       317047
       317839
        
              isExecutable = true;

     

       317048
       317840
        
              libraryHaskellDepends = [

     
···

       317084
       317876
        
              description = "Library for creating and modifying zip archives";

     

       317085
       317877
        
              license = lib.licenses.bsd3;

     

       317086
       317878
        
            }) {inherit (pkgs) which;};

     

       317879
       317879
       +
       

     

       317880
       317880
       +
         "zip-cmd" = callPackage

     

       317881
       317881
       +
           ({ mkDerivation, base, bytestring, filepath, optparse-applicative

     

       317882
       317882
       +
            , shellwords, text, time, zip

     

       317883
       317883
       +
            }:

     

       317884
       317884
       +
            mkDerivation {

     

       317885
       317885
       +
              pname = "zip-cmd";

     

       317886
       317886
       +
              version = "1.0.1";

     

       317887
       317887
       +
              sha256 = "18jhhzhbr4bh14b5kw7f2bxwrcnq0590v25f81wrqkvmbb2mzwmz";

     

       317888
       317888
       +
              revision = "1";

     

       317889
       317889
       +
              editedCabalFile = "0f2k4xxvpzf33bn6nab3fqimkc2gaywl8hbadnhavlbyrg5fdhpn";

     

       317890
       317890
       +
              isLibrary = false;

     

       317891
       317891
       +
              isExecutable = true;

     

       317892
       317892
       +
              executableHaskellDepends = [

     

       317893
       317893
       +
                base bytestring filepath optparse-applicative shellwords text time

     

       317894
       317894
       +
                zip

     

       317895
       317895
       +
              ];

     

       317896
       317896
       +
              description = "Simple CLI tool for the haskell zip library";

     

       317897
       317897
       +
              license = lib.licenses.bsd3;

     

       317898
       317898
       +
              mainProgram = "zip-cmd";

     

       317899
       317899
       +
            }) {};

     

       317087
       317900
        
       

     

       317088
       317901
        
         "zip-conduit" = callPackage

     

       317089
       317902
        
           ({ mkDerivation, base, bytestring, cereal, conduit, conduit-extra

+1 -1

pkgs/development/libraries/folks/default.nix

···

       119
       119
        
           homepage = "https://wiki.gnome.org/Projects/Folks";

     

       120
       120
        
           license = licenses.lgpl2Plus;

     

       121
       121
        
           maintainers = teams.gnome.members;

     

       122
       122
       -
           platforms = platforms.gnu ++ platforms.linux; # arbitrary choice

     

       122
       122
       +
           platforms = platforms.unix;

     

       123
       123
        
         };

     

       124
       124
        
       }

+1 -1

pkgs/development/libraries/gnome-video-effects/default.nix

···

       39
       39
        
         meta = with lib; {

     

       40
       40
        
           description = "A collection of GStreamer effects to be used in different GNOME Modules";

     

       41
       41
        
           homepage = "https://wiki.gnome.org/Projects/GnomeVideoEffects";

     

       42
       42
       -
           platforms = platforms.linux;

     

       42
       42
       +
           platforms = platforms.unix;

     

       43
       43
        
           maintainers = teams.gnome.members;

     

       44
       44
        
           license = licenses.gpl2;

     

       45
       45
        
         };

+11 -3

pkgs/development/libraries/protobufc/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub

     

       2
       2
       -
       , autoreconfHook, pkg-config, protobuf, zlib

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , autoreconfHook

     

       5
       5
       +
       , pkg-config

     

       6
       6
       +
       , protobuf

     

       7
       7
       +
       , zlib

     

       8
       8
       +
       , buildPackages

     

       3
       9
        
       }:

     

       4
       10
        
       

     

       5
       11
        
       stdenv.mkDerivation rec {

     
···

       17
       23
        
       

     

       18
       24
        
         buildInputs = [ protobuf zlib ];

     

       19
       25
        
       

     

       26
       26
       +
         PROTOC = lib.getExe buildPackages.protobuf;

     

       27
       27
       +
       

     

       20
       28
        
         meta = with lib; {

     

       21
       29
        
           homepage = "https://github.com/protobuf-c/protobuf-c/";

     

       22
       30
        
           description = "C bindings for Google's Protocol Buffers";

     

       23
       31
        
           license = licenses.bsd2;

     

       24
       32
        
           platforms = platforms.all;

     

       25
       25
       -
           maintainers = with maintainers; [ ];

     

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

     

       26
       34
        
         };

     

       27
       35
        
       }

+7 -1

pkgs/development/libraries/simdjson/default.nix

···

       15
       15
        
       

     

       16
       16
        
         cmakeFlags = [

     

       17
       17
        
           "-DSIMDJSON_DEVELOPER_MODE=OFF"

     

       18
       18
       -
         ] ++ lib.optional stdenv.hostPlatform.isStatic "-DBUILD_SHARED_LIBS=OFF";

     

       18
       18
       +
         ] ++ lib.optionals stdenv.hostPlatform.isStatic [

     

       19
       19
       +
           "-DBUILD_SHARED_LIBS=OFF"

     

       20
       20
       +
         ] ++ lib.optionals (with stdenv.hostPlatform; isPower && isBigEndian) [

     

       21
       21
       +
           # Assume required CPU features are available, since otherwise we

     

       22
       22
       +
           # just get a failed build.

     

       23
       23
       +
           "-DCMAKE_CXX_FLAGS=-mpower8-vector"

     

       24
       24
       +
         ];

     

       19
       25
        
       

     

       20
       26
        
         meta = with lib; {

     

       21
       27
        
           homepage = "https://simdjson.org/";

+2 -2

pkgs/development/libraries/sofia-sip/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "sofia-sip";

     

       5
       5
       -
         version = "1.13.9";

     

       5
       5
       +
         version = "1.13.10";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "freeswitch";

     

       9
       9
        
           repo = pname;

     

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

     

       11
       11
       -
           sha256 = "sha256-xF2LFbxGhA/gF7Z2LX3WYq3nXOLi0ARGGR4Dd3PCftk=";

     

       11
       11
       +
           sha256 = "sha256-UVyjeIIS0WwnY3GoZLIYTgf7R+C8SCuykDozaxCpog0=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         buildInputs = [ glib openssl ] ++ lib.optional stdenv.isDarwin SystemConfiguration;

+2 -1

pkgs/development/ocaml-modules/class_group_vdf/default.nix

···

       1
       1
       -
       { lib, fetchFromGitLab, buildDunePackage

     

       1
       1
       +
       { stdenv, lib, fetchFromGitLab, buildDunePackage

     

       2
       2
        
       , gmp, pkg-config, dune-configurator

     

       3
       3
        
       , zarith, integers

     

       4
       4
        
       , alcotest, bisect_ppx }:

     
···

       38
       38
        
         meta = {

     

       39
       39
        
           description = "Verifiable Delay Functions bindings to Chia's VDF";

     

       40
       40
        
           homepage = "https://gitlab.com/nomadic-labs/tezos";

     

       41
       41
       +
           broken = stdenv.isDarwin && stdenv.isx86_64;

     

       41
       42
        
           license = lib.licenses.mit;

     

       42
       43
        
           maintainers = [ lib.maintainers.ulrikstrid ];

     

       43
       44
        
         };

+2 -2

pkgs/development/php-packages/composer/default.nix

···

       1
       1
        
       { mkDerivation, fetchurl, makeWrapper, unzip, lib, php }:

     

       2
       2
        
       let

     

       3
       3
        
         pname = "composer";

     

       4
       4
       -
         version = "2.5.0";

     

       4
       4
       +
         version = "2.5.1";

     

       5
       5
        
       in

     

       6
       6
        
       mkDerivation {

     

       7
       7
        
         inherit pname version;

     

       8
       8
        
       

     

       9
       9
        
         src = fetchurl {

     

       10
       10
        
           url = "https://getcomposer.org/download/${version}/composer.phar";

     

       11
       11
       -
           sha256 = "tXFhDlRReF92OJoI6VddkcPW44/uHfepcI/jBwE8hCQ=";

     

       11
       11
       +
           sha256 = "sha256-8blP7hGlvWoarl13yNomnfJ8cF/MgG6/TIwub6hkXCA=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         dontUnpack = true;

+1 -1

pkgs/development/python-modules/antlr4-python3-runtime/default.nix

···

       14
       14
        
         # in 4.9, test was renamed to tests

     

       15
       15
        
         checkPhase = ''

     

       16
       16
        
           cd test*

     

       17
       17
       -
           ${python.interpreter} ctest.py

     

       17
       17
       +
           ${python.interpreter} run.py

     

       18
       18
        
         '';

     

       19
       19
        
       

     

       20
       20
        
         meta = with lib; {

+2 -2

pkgs/development/python-modules/certbot-dns-inwx/default.nix

···

       7
       7
        
       

     

       8
       8
        
       buildPythonPackage rec {

     

       9
       9
        
         pname = "certbot-dns-inwx";

     

       10
       10
       -
         version = "2.1.3";

     

       10
       10
       +
         version = "2.2.0";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchPypi {

     

       13
       13
        
           inherit pname version;

     

       14
       14
       -
           sha256 = "sha256-yAgualY4J92pJ8PIkICg8w0eYHmT5L3qAUOCW/cAitw=";

     

       14
       14
       +
           sha256 = "sha256-v03QBHsxhl6R8YcwWIKD+pf4APy9S2vFcQe3ZEc6AjI=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         propagatedBuildInputs = [

+27 -2

pkgs/development/python-modules/explorerscript/default.nix

···

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchFromGitHub

     

       4
       4
        
       , fetchpatch

     

       5
       5
       +
       , antlr4

     

       5
       6
        
       , antlr4-python3-runtime

     

       6
       7
        
       , igraph

     

       7
       8
        
       , pygments

     

       9
       9
       +
       , pytestCheckHook

     

       8
       10
        
       }:

     

       9
       11
        
       

     

       10
       12
        
       buildPythonPackage rec {

     
···

       18
       20
        
           sha256 = "1vzyliiyrxx8l9sfbqcyr4xn5swd7znkxy69kn0vb5rban8hm9c1";

     

       19
       21
        
         };

     

       20
       22
        
       

     

       23
       23
       +
         nativeBuildInputs = [

     

       24
       24
       +
           antlr4

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       21
       27
        
         patches = [

     

       22
       28
        
           # https://github.com/SkyTemple/ExplorerScript/pull/17

     

       23
       29
        
           (fetchpatch {

     
···

       26
       32
        
           })

     

       27
       33
        
         ];

     

       28
       34
        
       

     

       29
       29
       -
         propagatedBuildInputs = [ antlr4-python3-runtime igraph ];

     

       30
       30
       -
         checkInputs = [ pygments ];

     

       35
       35
       +
         postPatch = ''

     

       36
       36
       +
           sed -i "s/antlr4-python3-runtime.*/antlr4-python3-runtime',/" setup.py

     

       37
       37
       +
           antlr -Dlanguage=Python3 -visitor explorerscript/antlr/{ExplorerScript,SsbScript}.g4

     

       38
       38
       +
         '';

     

       39
       39
       +
       

     

       40
       40
       +
         propagatedBuildInputs = [

     

       41
       41
       +
           antlr4-python3-runtime

     

       42
       42
       +
           igraph

     

       43
       43
       +
         ];

     

       44
       44
       +
       

     

       45
       45
       +
         passthru.optional-dependencies.pygments = [

     

       46
       46
       +
           pygments

     

       47
       47
       +
         ];

     

       48
       48
       +
       

     

       49
       49
       +
         checkInputs = [

     

       50
       50
       +
           pytestCheckHook

     

       51
       51
       +
         ] ++ passthru.optional-dependencies.pygments;

     

       52
       52
       +
       

     

       53
       53
       +
         pythonImportsCheck = [

     

       54
       54
       +
           "explorerscript"

     

       55
       55
       +
         ];

     

       31
       56
        
       

     

       32
       57
        
         meta = with lib; {

     

       33
       58
        
           homepage = "https://github.com/SkyTemple/explorerscript";

+48

pkgs/development/python-modules/hassil/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       

     

       5
       5
       +
       # propagates

     

       6
       6
       +
       , antlr4-python3-runtime

     

       7
       7
       +
       , dataclasses-json

     

       8
       8
       +
       , pyyaml

     

       9
       9
       +
       

     

       10
       10
       +
       # tests

     

       11
       11
       +
       , pytestCheckHook

     

       12
       12
       +
       }:

     

       13
       13
       +
       

     

       14
       14
       +
       let

     

       15
       15
       +
         pname = "hassil";

     

       16
       16
       +
         version = "0.1.3";

     

       17
       17
       +
       in

     

       18
       18
       +
       buildPythonPackage {

     

       19
       19
       +
         inherit pname version;

     

       20
       20
       +
         format = "setuptools";

     

       21
       21
       +
       

     

       22
       22
       +
         src = fetchPypi {

     

       23
       23
       +
           inherit pname version;

     

       24
       24
       +
           hash = "sha256-KWkzHWMo50OIrZ2kwFhhqDSleFFkAD7/JugjvSyCkww=";

     

       25
       25
       +
         };

     

       26
       26
       +
       

     

       27
       27
       +
         postPatch = ''

     

       28
       28
       +
           sed -i 's/antlr4-python3-runtime==.*/antlr4-python3-runtime/' requirements.txt

     

       29
       29
       +
         '';

     

       30
       30
       +
       

     

       31
       31
       +
         propagatedBuildInputs = [

     

       32
       32
       +
           antlr4-python3-runtime

     

       33
       33
       +
           dataclasses-json

     

       34
       34
       +
           pyyaml

     

       35
       35
       +
         ];

     

       36
       36
       +
       

     

       37
       37
       +
         checkInputs = [

     

       38
       38
       +
           pytestCheckHook

     

       39
       39
       +
         ];

     

       40
       40
       +
       

     

       41
       41
       +
         meta = with lib; {

     

       42
       42
       +
           changelog  = "https://github.com/home-assistant/hassil/releases/tag/v${version}";

     

       43
       43
       +
           description = "Intent parsing for Home Assistant";

     

       44
       44
       +
           homepage = "https://github.com/home-assistant/hassil";

     

       45
       45
       +
           license = licenses.asl20;

     

       46
       46
       +
           maintainers = teams.home-assistant.members;

     

       47
       47
       +
         };

     

       48
       48
       +
       }

+13

pkgs/development/python-modules/hydra-core/antlr4.patch

···

       1
       1
       +
       diff --git a/build_helpers/build_helpers.py b/build_helpers/build_helpers.py

     

       2
       2
       +
       index 7159d22615..73db312bbe 100644

     

       3
       3
       +
       --- a/build_helpers/build_helpers.py

     

       4
       4
       +
       +++ b/build_helpers/build_helpers.py

     

       5
       5
       +
       @@ -185,7 +185,7 @@ class ANTLRCommand(Command):  # type: ignore

     

       6
       6
       +
                    command = [

     

       7
       7
       +
                        "java",

     

       8
       8
       +
                        "-jar",

     

       9
       9
       +
       -                join(root_dir, "bin/antlr-4.9.3-complete.jar"),

     

       10
       10
       +
       +                "@antlr_jar@",

     

       11
       11
       +
                        "-Dlanguage=Python3",

     

       12
       12
       +
                        "-o",

     

       13
       13
       +
                        join(project_root, "hydra/grammar/gen/"),

+22 -5

pkgs/development/python-modules/hydra/default.nix pkgs/development/python-modules/hydra-core/default.nix

···

       1
       1
        
       { stdenv

     

       2
       2
        
       , lib

     

       3
       3
       -
       , antlr4_9-python3-runtime

     

       3
       3
       +
       , antlr4

     

       4
       4
       +
       , antlr4-python3-runtime

     

       4
       5
        
       , buildPythonPackage

     

       5
       6
        
       , fetchFromGitHub

     

       6
       7
        
       , importlib-resources

     
···

       8
       9
        
       , omegaconf

     

       9
       10
        
       , pytestCheckHook

     

       10
       11
        
       , pythonOlder

     

       12
       12
       +
       , substituteAll

     

       11
       13
        
       }:

     

       12
       14
        
       

     

       13
       15
        
       buildPythonPackage rec {

     

       14
       14
       -
         pname = "hydra";

     

       16
       16
       +
         pname = "hydra-core";

     

       15
       17
        
         version = "1.3.1";

     

       16
       18
        
         format = "setuptools";

     

       17
       19
        
       

     
···

       19
       21
        
       

     

       20
       22
        
         src = fetchFromGitHub {

     

       21
       23
        
           owner = "facebookresearch";

     

       22
       22
       -
           repo = pname;

     

       24
       24
       +
           repo = "hydra";

     

       23
       25
        
           rev = "refs/tags/v${version}";

     

       24
       26
        
           hash = "sha256-4FOh1Jr+LM8ffh/xcAqMqKudKbXb2DZdxU+czq2xwxs=";

     

       25
       27
        
         };

     

       26
       28
        
       

     

       29
       29
       +
         patches = [

     

       30
       30
       +
           (substituteAll {

     

       31
       31
       +
             src = ./antlr4.patch;

     

       32
       32
       +
             antlr_jar = "${antlr4.out}/share/java/antlr-${antlr4.version}-complete.jar";

     

       33
       33
       +
           })

     

       34
       34
       +
         ];

     

       35
       35
       +
       

     

       36
       36
       +
         postPatch = ''

     

       37
       37
       +
           # We substitute the path to the jar with the one from our antlr4

     

       38
       38
       +
           # package, so this file becomes unused

     

       39
       39
       +
           rm -v build_helpers/bin/antlr*-complete.jar

     

       40
       40
       +
       

     

       41
       41
       +
           sed -i 's/antlr4-python3-runtime==.*/antlr4-python3-runtime/' requirements/requirements.txt

     

       42
       42
       +
         '';

     

       43
       43
       +
       

     

       27
       44
        
         nativeBuildInputs = [

     

       28
       45
        
           jre_headless

     

       29
       46
        
         ];

     

       30
       47
        
       

     

       31
       48
        
         propagatedBuildInputs = [

     

       32
       32
       -
           antlr4_9-python3-runtime

     

       49
       49
       +
           antlr4-python3-runtime

     

       33
       50
        
           omegaconf

     

       34
       51
        
         ] ++ lib.optionals (pythonOlder "3.9") [

     

       35
       52
        
           importlib-resources

     
···

       55
       72
        
         ];

     

       56
       73
        
       

     

       57
       74
        
         meta = with lib; {

     

       58
       58
       -
           broken = (stdenv.isLinux && stdenv.isAarch64) || stdenv.isDarwin;

     

       75
       75
       +
           broken = stdenv.isDarwin;

     

       59
       76
        
           description = "A framework for configuring complex applications";

     

       60
       77
        
           homepage = "https://hydra.cc";

     

       61
       78
        
           license = licenses.mit;

+3 -2

pkgs/development/python-modules/meshtastic/default.nix

···

       18
       18
        
       

     

       19
       19
        
       buildPythonPackage rec {

     

       20
       20
        
         pname = "meshtastic";

     

       21
       21
       -
         version = "2.0.6";

     

       21
       21
       +
         version = "2.0.7";

     

       22
       22
        
         format = "setuptools";

     

       23
       23
        
       

     

       24
       24
        
         disabled = pythonOlder "3.7";

     
···

       27
       27
        
           owner = "meshtastic";

     

       28
       28
        
           repo = "Meshtastic-python";

     

       29
       29
        
           rev = "refs/tags/${version}";

     

       30
       30
       -
           hash = "sha256-PN09TaJZR/REQPIgrm9XR+mXvR1evMAWGQziAzpg+fE=";

     

       30
       30
       +
           hash = "sha256-2CzWX+hMH1gN9WytRUf9BGiJ/bfEu2e0Kzg4ScDMrBo=";

     

       31
       31
        
         };

     

       32
       32
        
       

     

       33
       33
        
         propagatedBuildInputs = [

     
···

       94
       94
        
           "test_main_setPref_invalid_field"

     

       95
       95
        
           "test_main_setPref_valid_field_int_as_string"

     

       96
       96
        
           "test_readGPIOs"

     

       97
       97
       +
           "test_onGPIOreceive"

     

       97
       98
        
           "test_setURL_empty_url"

     

       98
       99
        
           "test_watchGPIOs"

     

       99
       100
        
           "test_writeConfig_with_no_radioConfig"

+13

pkgs/development/python-modules/omegaconf/antlr4.patch

···

       1
       1
       +
       diff --git a/build_helpers/build_helpers.py b/build_helpers/build_helpers.py

     

       2
       2
       +
       index 6419e26..9e6c21c 100644

     

       3
       3
       +
       --- a/build_helpers/build_helpers.py

     

       4
       4
       +
       +++ b/build_helpers/build_helpers.py

     

       5
       5
       +
       @@ -30,7 +30,7 @@ class ANTLRCommand(Command):  # type: ignore  # pragma: no cover

     

       6
       6
       +
                    command = [

     

       7
       7
       +
                        "java",

     

       8
       8
       +
                        "-jar",

     

       9
       9
       +
       -                str(build_dir / "bin" / "antlr-4.9.3-complete.jar"),

     

       10
       10
       +
       +                "@antlr_jar@",

     

       11
       11
       +
                        "-Dlanguage=Python3",

     

       12
       12
       +
                        "-o",

     

       13
       13
       +
                        str(project_root / "omegaconf" / "grammar" / "gen"),

+19 -2

pkgs/development/python-modules/omegaconf/default.nix

···

       1
       1
        
       { lib

     

       2
       2
       -
       , antlr4_9-python3-runtime

     

       2
       2
       +
       , antlr4

     

       3
       3
       +
       , antlr4-python3-runtime

     

       3
       4
        
       , buildPythonPackage

     

       4
       5
        
       , fetchFromGitHub

     

       5
       6
        
       , jre_minimal

     
···

       8
       9
        
       , pytestCheckHook

     

       9
       10
        
       , pythonOlder

     

       10
       11
        
       , pyyaml

     

       12
       12
       +
       , substituteAll

     

       11
       13
        
       }:

     

       12
       14
        
       

     

       13
       15
        
       buildPythonPackage rec {

     
···

       24
       26
        
           hash = "sha256-Qxa4uIiX5TAyQ5rFkizdev60S4iVAJ08ES6FpNqf8zI=";

     

       25
       27
        
         };

     

       26
       28
        
       

     

       29
       29
       +
         patches = [

     

       30
       30
       +
           (substituteAll {

     

       31
       31
       +
             src = ./antlr4.patch;

     

       32
       32
       +
             antlr_jar = "${antlr4.out}/share/java/antlr-${antlr4.version}-complete.jar";

     

       33
       33
       +
           })

     

       34
       34
       +
         ];

     

       35
       35
       +
       

     

       36
       36
       +
         postPatch = ''

     

       37
       37
       +
           # We substitute the path to the jar with the one from our antlr4

     

       38
       38
       +
           # package, so this file becomes unused

     

       39
       39
       +
           rm -v build_helpers/bin/antlr*-complete.jar

     

       40
       40
       +
       

     

       41
       41
       +
           sed -i 's/antlr4-python3-runtime==.*/antlr4-python3-runtime/' requirements/base.txt

     

       42
       42
       +
         '';

     

       43
       43
       +
       

     

       27
       44
        
         nativeBuildInputs = [

     

       28
       45
        
           jre_minimal

     

       29
       46
        
         ];

     

       30
       47
        
       

     

       31
       48
        
         propagatedBuildInputs = [

     

       32
       32
       -
           antlr4_9-python3-runtime

     

       49
       49
       +
           antlr4-python3-runtime

     

       33
       50
        
           pyyaml

     

       34
       51
        
         ];

     

       35
       52

+2 -2

pkgs/development/python-modules/wled/default.nix

···

       15
       15
        
       

     

       16
       16
        
       buildPythonPackage rec {

     

       17
       17
        
         pname = "wled";

     

       18
       18
       -
         version = "0.14.1";

     

       18
       18
       +
         version = "0.15.0";

     

       19
       19
        
         format = "pyproject";

     

       20
       20
        
       

     

       21
       21
        
         disabled = pythonOlder "3.8";

     
···

       24
       24
        
           owner = "frenck";

     

       25
       25
        
           repo = "python-wled";

     

       26
       26
        
           rev = "refs/tags/v${version}";

     

       27
       27
       -
           sha256 = "sha256-ytjCjxnJOMmFlGS+AuEAbIZcV2yoTgaXSLdqxPg6Hew=";

     

       27
       27
       +
           sha256 = "sha256-GmentEsCJQ9N9kXfy5pbkGXi5CvZfbepdCWab+/fLJc=";

     

       28
       28
        
         };

     

       29
       29
        
       

     

       30
       30
        
         nativeBuildInputs = [

+5 -1

pkgs/development/tools/luaformatter/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, substituteAll, antlr4, libargs, catch2, cmake, libyamlcpp }:

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, substituteAll, antlr4_9, libargs, catch2, cmake, libyamlcpp }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         antlr4 = antlr4_9;

     

       5
       5
       +
       in

     

       2
       6
        
       

     

       3
       7
        
       stdenv.mkDerivation rec {

     

       4
       8
        
         pname = "luaformatter";

+3 -3

pkgs/development/tools/pulumictl/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "pulumictl";

     

       5
       5
       -
         version = "0.0.32";

     

       5
       5
       +
         version = "0.0.38";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "pulumi";

     

       9
       9
        
           repo = "pulumictl";

     

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

     

       11
       11
       -
           sha256 = "sha256-CZ0DnQUnyj8aoesFymc+Uhv+3vdQhdxb2YHElAyqGWE=";

     

       11
       11
       +
           sha256 = "sha256-j7wuzyGko3agDO7L8MUaAegjE4yj4KzQEcxWLY39BhQ=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "sha256-xalfnLc6bPBvm2B42+FzpgrOH541HMWmNHChveI792s=";

     

       14
       14
       +
         vendorSha256 = "sha256-WzfTS68YIpoZYbm6i0USxXyEyR4px+hrNRbsCTXdJsk=";

     

       15
       15
        
       

     

       16
       16
        
         ldflags = [

     

       17
       17
        
           "-s" "-w" "-X=github.com/pulumi/pulumictl/pkg/version.Version=${src.rev}"

+6 -3

pkgs/development/tools/ruff/default.nix

···

       7
       7
        
       

     

       8
       8
        
       rustPlatform.buildRustPackage rec {

     

       9
       9
        
         pname = "ruff";

     

       10
       10
       -
         version = "0.0.194";

     

       10
       10
       +
         version = "0.0.198";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "charliermarsh";

     

       14
       14
        
           repo = pname;

     

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

     

       16
       16
       -
           sha256 = "sha256-28ckhFvUjA/Hb7bkd/iRaSm24EP0oUAxlVymHdPIJk0=";

     

       16
       16
       +
           sha256 = "sha256-hXG3Iu9p678UYh4NrpaVoPj8CDdU7D3GB7BQHsyQHWg=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         cargoSha256 = "sha256-PLYU+J7xneZZOkJ+MEVTpgICIN3/Kunr7B+ryb4eZFk=";

     

       19
       19
       +
         cargoSha256 = "sha256-uWdlbVV6IODK+iugut/S8/WJwa9rSIvenvaROeyLaR0=";

     

       20
       20
        
       

     

       21
       21
        
         buildInputs = lib.optionals stdenv.isDarwin [

     

       22
       22
        
           darwin.apple_sdk.frameworks.CoreServices

     

       23
       23
        
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         # building tests fails with `undefined symbols`

     

       26
       26
       +
         doCheck = false;

     

       24
       27
        
       

     

       25
       28
        
         meta = with lib; {

     

       26
       29
        
           description = "An extremely fast Python linter";

+2 -2

pkgs/games/vcmi/default.nix

···

       24
       24
        
       

     

       25
       25
        
       stdenv.mkDerivation rec {

     

       26
       26
        
         pname = "vcmi";

     

       27
       27
       -
         version = "1.0.0";

     

       27
       27
       +
         version = "1.1.0";

     

       28
       28
        
       

     

       29
       29
        
         src = fetchFromGitHub {

     

       30
       30
        
           owner = "vcmi";

     

       31
       31
        
           repo = "vcmi";

     

       32
       32
        
           rev = version;

     

       33
       33
        
           fetchSubmodules = true;

     

       34
       34
       -
           hash = "sha256-5PuFq6wDSj5Ye2fUjqcr/VRU0ocus6h2nn+myQTOrhU=";

     

       34
       34
       +
           hash = "sha256-Ah+aAuU2ioUfvtxfcSb4GNqriqY71ee5RhW2L9UMYFY=";

     

       35
       35
        
         };

     

       36
       36
        
       

     

       37
       37
        
         postPatch = ''

+22 -14

pkgs/servers/baserow/default.nix

···

       2
       2
        
       , fetchFromGitLab

     

       3
       3
        
       , makeWrapper

     

       4
       4
        
       , python3

     

       5
       5
       +
       , antlr4_9

     

       5
       6
        
       }:

     

       6
       7
        
       

     

       7
       8
        
       let

     

       8
       9
        
       

     

       9
       9
       -
         baserow_premium = with python3.pkgs; ( buildPythonPackage rec {

     

       10
       10
       -
           pname = "baserow_premium";

     

       11
       11
       -
           version = "1.12.1";

     

       12
       12
       -
           foramt = "setuptools";

     

       10
       10
       +
         python = python3.override {

     

       11
       11
       +
           packageOverrides = self: super: {

     

       12
       12
       +
             antlr4-python3-runtime = super.antlr4-python3-runtime.override {

     

       13
       13
       +
               antlr4 = antlr4_9;

     

       14
       14
       +
             };

     

       13
       15
        
       

     

       14
       14
       -
           src = fetchFromGitLab {

     

       15
       15
       -
             owner = "bramw";

     

       16
       16
       -
             repo = pname;

     

       17
       17
       -
             rev = "refs/tags/${version}";

     

       18
       18
       -
             hash = "sha256-zT2afl3QNE2dO3JXjsZXqSmm1lv3EorG3mYZLQQMQ2Q=";

     

       19
       19
       -
           };

     

       16
       16
       +
             baserow_premium = self.buildPythonPackage rec {

     

       17
       17
       +
               pname = "baserow_premium";

     

       18
       18
       +
               version = "1.12.1";

     

       19
       19
       +
               foramt = "setuptools";

     

       20
       20
        
       

     

       21
       21
       -
           sourceRoot = "source/premium/backend";

     

       21
       21
       +
               src = fetchFromGitLab {

     

       22
       22
       +
                 owner = "bramw";

     

       23
       23
       +
                 repo = pname;

     

       24
       24
       +
                 rev = "refs/tags/${version}";

     

       25
       25
       +
                 hash = "sha256-zT2afl3QNE2dO3JXjsZXqSmm1lv3EorG3mYZLQQMQ2Q=";

     

       26
       26
       +
               };

     

       22
       27
        
       

     

       23
       23
       -
           doCheck = false;

     

       24
       24
       -
         });

     

       28
       28
       +
               sourceRoot = "source/premium/backend";

     

       25
       29
        
       

     

       30
       30
       +
               doCheck = false;

     

       31
       31
       +
             };

     

       32
       32
       +
           };

     

       33
       33
       +
         };

     

       26
       34
        
       in

     

       27
       35
        
       

     

       28
       28
       -
       with python3.pkgs; buildPythonPackage rec {

     

       36
       36
       +
       with python.pkgs; buildPythonApplication rec {

     

       29
       37
        
         pname = "baserow";

     

       30
       38
        
         version = "1.12.1";

     

       31
       39
        
         format = "setuptools";

+2 -9

pkgs/servers/http/trafficserver/default.nix

···

       50
       50
        
       

     

       51
       51
        
       stdenv.mkDerivation rec {

     

       52
       52
        
         pname = "trafficserver";

     

       53
       53
       -
         version = "9.1.3";

     

       53
       53
       +
         version = "9.1.4";

     

       54
       54
        
       

     

       55
       55
        
         src = fetchzip {

     

       56
       56
        
           url = "mirror://apache/trafficserver/trafficserver-${version}.tar.bz2";

     

       57
       57
       -
           sha256 = "sha256-Ihhsbn4PvIjWskmbWKajThIwtuiEyldBpmtuQ8RdyHA=";

     

       57
       57
       +
           sha256 = "sha256-+iq+z+1JE6JE6OLcUwRRAe2/EISqb6Ax6pNm8GcB7bc=";

     

       58
       58
        
         };

     

       59
       59
        
       

     

       60
       60
        
         patches = [

     
···

       107
       107
        
             tools/check-unused-dependencies

     

       108
       108
        
       

     

       109
       109
        
           substituteInPlace configure --replace '/usr/bin/file' '${file}/bin/file'

     

       110
       110
       -
       

     

       111
       111
       -
           # TODO: remove after the following change has been released

     

       112
       112
       -
           # https://github.com/apache/trafficserver/pull/8683

     

       113
       113
       -
           cp ${catch2}/include/catch2/catch.hpp tests/include/catch.hpp

     

       114
       110
        
         '' + lib.optionalString stdenv.isLinux ''

     

       115
       111
        
           substituteInPlace configure \

     

       116
       112
        
             --replace '/usr/include/linux' '${linuxHeaders}/include/linux'

     
···

       125
       121
        
           "--enable-experimental-plugins"

     

       126
       122
        
           (lib.enableFeature enableWCCP "wccp")

     

       127
       123
        
       

     

       128
       128
       -
           # the configure script can't auto-locate the following from buildInputs

     

       129
       129
       -
           "--with-lzma=${xz.dev}"

     

       130
       130
       -
           "--with-zlib=${zlib.dev}"

     

       131
       124
        
           (lib.withFeatureAs withHiredis "hiredis" hiredis)

     

       132
       125
        
         ];

     

       133
       126

+3 -3

pkgs/tools/admin/qovery-cli/default.nix

···

       8
       8
        
       

     

       9
       9
        
       buildGoModule rec {

     

       10
       10
        
         pname = "qovery-cli";

     

       11
       11
       -
         version = "0.46.7";

     

       11
       11
       +
         version = "0.47.2";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "Qovery";

     

       15
       15
        
           repo = pname;

     

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

     

       17
       17
       -
           hash = "sha256-cMoT0vbWTcuMI7MMDGQ8+G7FqTuaJl4+rp22Uy4e83g=";

     

       17
       17
       +
           hash = "sha256-leQ/wMtFt4e+NaLYPA50BICLJV7tBJ7NcaaYagbG+Ww=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         vendorHash = "sha256-4TY7/prMbvw5zVPJRoMLg7Omrxvh1HPGsdz1wqPn4uU=";

     

       20
       20
       +
         vendorHash = "sha256-fkVtyydWPLh0D8jJZQ02hc8Hzntfmd7UMOuTv4Rckng=";

     

       21
       21
        
       

     

       22
       22
        
         nativeBuildInputs = [ installShellFiles ];

     

       23
       23

+28

pkgs/tools/filesystems/envfs/default.nix

···

       1
       1
       +
       { rustPlatform, lib, fetchFromGitHub, nixosTests }:

     

       2
       2
       +
       rustPlatform.buildRustPackage rec {

     

       3
       3
       +
         pname = "envfs";

     

       4
       4
       +
         version = "1.0.0";

     

       5
       5
       +
         src = fetchFromGitHub {

     

       6
       6
       +
           owner = "Mic92";

     

       7
       7
       +
           repo = "envfs";

     

       8
       8
       +
           rev = version;

     

       9
       9
       +
           hash = "sha256-aF8V1LwPGifFWoVxM0ydOnTX1pDVJ6HXevTxADJ/rsw=";

     

       10
       10
       +
         };

     

       11
       11
       +
         cargoHash = "sha256-kw56tbe5zvWY5bI//dUqR1Rlumz8kOG4HeXiyEyL0I0=";

     

       12
       12
       +
       

     

       13
       13
       +
         passthru.tests = {

     

       14
       14
       +
           envfs = nixosTests.envfs;

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         postInstall = ''

     

       18
       18
       +
           ln -s envfs $out/bin/mount.envfs

     

       19
       19
       +
           ln -s envfs $out/bin/mount.fuse.envfs

     

       20
       20
       +
         '';

     

       21
       21
       +
         meta = with lib; {

     

       22
       22
       +
           description = "Fuse filesystem that returns symlinks to executables based on the PATH of the requesting process.";

     

       23
       23
       +
           homepage = "https://github.com/Mic92/envfs";

     

       24
       24
       +
           license = licenses.mit;

     

       25
       25
       +
           maintainers = with maintainers; [ mic92 ];

     

       26
       26
       +
           platforms = platforms.linux;

     

       27
       27
       +
         };

     

       28
       28
       +
       }

-725

pkgs/tools/filesystems/httm/cargo-lock.patch

···

       1
       1
       -
       diff --git i/Cargo.lock w/Cargo.lock

     

       2
       2
       -
       index d59e8af..2409033 100644

     

       3
       3
       -
       --- i/Cargo.lock

     

       4
       4
       -
       +++ w/Cargo.lock

     

       5
       5
       -
       @@ -8,16 +8,16 @@ version = "0.8.2"

     

       6
       6
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       7
       7
       -
        checksum = "bf6ccdb167abbf410dcb915cabd428929d7f6a04980b54a11f26a39f1c7f7107"

     

       8
       8
       -
        dependencies = [

     

       9
       9
       -
       - "cfg-if 1.0.0",

     

       10
       10
       -
       + "cfg-if",

     

       11
       11
       -
         "once_cell",

     

       12
       12
       -
         "version_check",

     

       13
       13
       -
        ]

     

       14
       14
       -
        

     

       15
       15
       -
        [[package]]

     

       16
       16
       -
        name = "aho-corasick"

     

       17
       17
       -
       -version = "0.7.18"

     

       18
       18
       -
       +version = "0.7.20"

     

       19
       19
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       20
       20
       -
       -checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"

     

       21
       21
       -
       +checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"

     

       22
       22
       -
        dependencies = [

     

       23
       23
       -
         "memchr",

     

       24
       24
       -
        ]

     

       25
       25
       -
       @@ -77,21 +77,15 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

     

       26
       26
       -
        

     

       27
       27
       -
        [[package]]

     

       28
       28
       -
        name = "bumpalo"

     

       29
       29
       -
       -version = "3.10.0"

     

       30
       30
       -
       +version = "3.11.1"

     

       31
       31
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       32
       32
       -
       -checksum = "37ccbd214614c6783386c1af30caf03192f17891059cecc394b4fb119e363de3"

     

       33
       33
       -
       +checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"

     

       34
       34
       -
        

     

       35
       35
       -
        [[package]]

     

       36
       36
       -
        name = "cc"

     

       37
       37
       -
       -version = "1.0.73"

     

       38
       38
       -
       +version = "1.0.77"

     

       39
       39
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       40
       40
       -
       -checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"

     

       41
       41
       -
       -

     

       42
       42
       -
       -[[package]]

     

       43
       43
       -
       -name = "cfg-if"

     

       44
       44
       -
       -version = "0.1.10"

     

       45
       45
       -
       -source = "registry+https://github.com/rust-lang/crates.io-index"

     

       46
       46
       -
       -checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

     

       47
       47
       -
       +checksum = "e9f73505338f7d905b19d18738976aae232eb46b8efc15554ffc56deb5d9ebe4"

     

       48
       48
       -
        

     

       49
       49
       -
        [[package]]

     

       50
       50
       -
        name = "cfg-if"

     

       51
       51
       -
       @@ -101,13 +95,16 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

     

       52
       52
       -
        

     

       53
       53
       -
        [[package]]

     

       54
       54
       -
        name = "chrono"

     

       55
       55
       -
       -version = "0.4.22"

     

       56
       56
       -
       +version = "0.4.23"

     

       57
       57
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       58
       58
       -
       -checksum = "bfd4d1b31faaa3a89d7934dbded3111da0d2ef28e3ebccdb4f0179f5929d1ef1"

     

       59
       59
       -
       +checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"

     

       60
       60
       -
        dependencies = [

     

       61
       61
       -
         "iana-time-zone",

     

       62
       62
       -
       + "js-sys",

     

       63
       63
       -
         "num-integer",

     

       64
       64
       -
         "num-traits",

     

       65
       65
       -
       + "time 0.1.45",

     

       66
       66
       -
       + "wasm-bindgen",

     

       67
       67
       -
         "winapi",

     

       68
       68
       -
        ]

     

       69
       69
       -
        

     

       70
       70
       -
       @@ -129,9 +126,9 @@ dependencies = [

     

       71
       71
       -
        

     

       72
       72
       -
        [[package]]

     

       73
       73
       -
        name = "clap_lex"

     

       74
       74
       -
       -version = "0.2.2"

     

       75
       75
       -
       +version = "0.2.4"

     

       76
       76
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       77
       77
       -
       -checksum = "5538cd660450ebeb4234cfecf8f2284b844ffc4c50531e66d584ad5b91293613"

     

       78
       78
       -
       +checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"

     

       79
       79
       -
        dependencies = [

     

       80
       80
       -
         "os_str_bytes",

     

       81
       81
       -
        ]

     

       82
       82
       -
       @@ -148,14 +145,13 @@ dependencies = [

     

       83
       83
       -
        

     

       84
       84
       -
        [[package]]

     

       85
       85
       -
        name = "console"

     

       86
       86
       -
       -version = "0.15.0"

     

       87
       87
       -
       +version = "0.15.2"

     

       88
       88
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       89
       89
       -
       -checksum = "a28b32d32ca44b70c3e4acd7db1babf555fa026e385fb95f18028f88848b3c31"

     

       90
       90
       -
       +checksum = "c050367d967ced717c04b65d8c619d863ef9292ce0c5760028655a2fb298718c"

     

       91
       91
       -
        dependencies = [

     

       92
       92
       -
         "encode_unicode",

     

       93
       93
       -
       + "lazy_static",

     

       94
       94
       -
         "libc",

     

       95
       95
       -
       - "once_cell",

     

       96
       96
       -
       - "regex",

     

       97
       97
       -
         "terminal_size 0.1.17",

     

       98
       98
       -
         "winapi",

     

       99
       99
       -
        ]

     

       100
       100
       -
       @@ -172,95 +168,72 @@ version = "0.8.2"

     

       101
       101
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       102
       102
       -
        checksum = "2801af0d36612ae591caa9568261fddce32ce6e08a7275ea334a06a4ad021a2c"

     

       103
       103
       -
        dependencies = [

     

       104
       104
       -
       - "cfg-if 1.0.0",

     

       105
       105
       -
       - "crossbeam-channel 0.5.5",

     

       106
       106
       -
       + "cfg-if",

     

       107
       107
       -
       + "crossbeam-channel",

     

       108
       108
       -
         "crossbeam-deque",

     

       109
       109
       -
         "crossbeam-epoch",

     

       110
       110
       -
         "crossbeam-queue",

     

       111
       111
       -
       - "crossbeam-utils 0.8.9",

     

       112
       112
       -
       + "crossbeam-utils",

     

       113
       113
       -
        ]

     

       114
       114
       -
        

     

       115
       115
       -
        [[package]]

     

       116
       116
       -
        name = "crossbeam-channel"

     

       117
       117
       -
       -version = "0.4.4"

     

       118
       118
       -
       +version = "0.5.6"

     

       119
       119
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       120
       120
       -
       -checksum = "b153fe7cbef478c567df0f972e02e6d736db11affe43dfc9c56a9374d1adfb87"

     

       121
       121
       -
       +checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"

     

       122
       122
       -
        dependencies = [

     

       123
       123
       -
       - "crossbeam-utils 0.7.2",

     

       124
       124
       -
       - "maybe-uninit",

     

       125
       125
       -
       -]

     

       126
       126
       -
       -

     

       127
       127
       -
       -[[package]]

     

       128
       128
       -
       -name = "crossbeam-channel"

     

       129
       129
       -
       -version = "0.5.5"

     

       130
       130
       -
       -source = "registry+https://github.com/rust-lang/crates.io-index"

     

       131
       131
       -
       -checksum = "4c02a4d71819009c192cf4872265391563fd6a84c81ff2c0f2a7026ca4c1d85c"

     

       132
       132
       -
       -dependencies = [

     

       133
       133
       -
       - "cfg-if 1.0.0",

     

       134
       134
       -
       - "crossbeam-utils 0.8.9",

     

       135
       135
       -
       + "cfg-if",

     

       136
       136
       -
       + "crossbeam-utils",

     

       137
       137
       -
        ]

     

       138
       138
       -
        

     

       139
       139
       -
        [[package]]

     

       140
       140
       -
        name = "crossbeam-deque"

     

       141
       141
       -
       -version = "0.8.1"

     

       142
       142
       -
       +version = "0.8.2"

     

       143
       143
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       144
       144
       -
       -checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"

     

       145
       145
       -
       +checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"

     

       146
       146
       -
        dependencies = [

     

       147
       147
       -
       - "cfg-if 1.0.0",

     

       148
       148
       -
       + "cfg-if",

     

       149
       149
       -
         "crossbeam-epoch",

     

       150
       150
       -
       - "crossbeam-utils 0.8.9",

     

       151
       151
       -
       + "crossbeam-utils",

     

       152
       152
       -
        ]

     

       153
       153
       -
        

     

       154
       154
       -
        [[package]]

     

       155
       155
       -
        name = "crossbeam-epoch"

     

       156
       156
       -
       -version = "0.9.9"

     

       157
       157
       -
       +version = "0.9.13"

     

       158
       158
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       159
       159
       -
       -checksum = "07db9d94cbd326813772c968ccd25999e5f8ae22f4f8d1b11effa37ef6ce281d"

     

       160
       160
       -
       +checksum = "01a9af1f4c2ef74bb8aa1f7e19706bc72d03598c8a570bb5de72243c7a9d9d5a"

     

       161
       161
       -
        dependencies = [

     

       162
       162
       -
         "autocfg",

     

       163
       163
       -
       - "cfg-if 1.0.0",

     

       164
       164
       -
       - "crossbeam-utils 0.8.9",

     

       165
       165
       -
       - "memoffset",

     

       166
       166
       -
       - "once_cell",

     

       167
       167
       -
       + "cfg-if",

     

       168
       168
       -
       + "crossbeam-utils",

     

       169
       169
       -
       + "memoffset 0.7.1",

     

       170
       170
       -
         "scopeguard",

     

       171
       171
       -
        ]

     

       172
       172
       -
        

     

       173
       173
       -
        [[package]]

     

       174
       174
       -
        name = "crossbeam-queue"

     

       175
       175
       -
       -version = "0.3.5"

     

       176
       176
       -
       +version = "0.3.8"

     

       177
       177
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       178
       178
       -
       -checksum = "1f25d8400f4a7a5778f0e4e52384a48cbd9b5c495d110786187fc750075277a2"

     

       179
       179
       -
       +checksum = "d1cfb3ea8a53f37c40dea2c7bedcbd88bdfae54f5e2175d6ecaff1c988353add"

     

       180
       180
       -
        dependencies = [

     

       181
       181
       -
       - "cfg-if 1.0.0",

     

       182
       182
       -
       - "crossbeam-utils 0.8.9",

     

       183
       183
       -
       + "cfg-if",

     

       184
       184
       -
       + "crossbeam-utils",

     

       185
       185
       -
        ]

     

       186
       186
       -
        

     

       187
       187
       -
        [[package]]

     

       188
       188
       -
        name = "crossbeam-utils"

     

       189
       189
       -
       -version = "0.7.2"

     

       190
       190
       -
       +version = "0.8.14"

     

       191
       191
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       192
       192
       -
       -checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"

     

       193
       193
       -
       +checksum = "4fb766fa798726286dbbb842f174001dab8abc7b627a1dd86e0b7222a95d929f"

     

       194
       194
       -
        dependencies = [

     

       195
       195
       -
       - "autocfg",

     

       196
       196
       -
       - "cfg-if 0.1.10",

     

       197
       197
       -
       - "lazy_static",

     

       198
       198
       -
       -]

     

       199
       199
       -
       -

     

       200
       200
       -
       -[[package]]

     

       201
       201
       -
       -name = "crossbeam-utils"

     

       202
       202
       -
       -version = "0.8.9"

     

       203
       203
       -
       -source = "registry+https://github.com/rust-lang/crates.io-index"

     

       204
       204
       -
       -checksum = "8ff1f980957787286a554052d03c7aee98d99cc32e09f6d45f0a814133c87978"

     

       205
       205
       -
       -dependencies = [

     

       206
       206
       -
       - "cfg-if 1.0.0",

     

       207
       207
       -
       - "once_cell",

     

       208
       208
       -
       + "cfg-if",

     

       209
       209
       -
        ]

     

       210
       210
       -
        

     

       211
       211
       -
        [[package]]

     

       212
       212
       -
        name = "cxx"

     

       213
       213
       -
       -version = "1.0.80"

     

       214
       214
       -
       +version = "1.0.83"

     

       215
       215
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       216
       216
       -
       -checksum = "6b7d4e43b25d3c994662706a1d4fcfc32aaa6afd287502c111b237093bb23f3a"

     

       217
       217
       -
       +checksum = "bdf07d07d6531bfcdbe9b8b739b104610c6508dcc4d63b410585faf338241daf"

     

       218
       218
       -
        dependencies = [

     

       219
       219
       -
         "cc",

     

       220
       220
       -
         "cxxbridge-flags",

     

       221
       221
       -
       @@ -270,9 +243,9 @@ dependencies = [

     

       222
       222
       -
        

     

       223
       223
       -
        [[package]]

     

       224
       224
       -
        name = "cxx-build"

     

       225
       225
       -
       -version = "1.0.80"

     

       226
       226
       -
       +version = "1.0.83"

     

       227
       227
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       228
       228
       -
       -checksum = "84f8829ddc213e2c1368e51a2564c552b65a8cb6a28f31e576270ac81d5e5827"

     

       229
       229
       -
       +checksum = "d2eb5b96ecdc99f72657332953d4d9c50135af1bac34277801cc3937906ebd39"

     

       230
       230
       -
        dependencies = [

     

       231
       231
       -
         "cc",

     

       232
       232
       -
         "codespan-reporting",

     

       233
       233
       -
       @@ -285,15 +258,15 @@ dependencies = [

     

       234
       234
       -
        

     

       235
       235
       -
        [[package]]

     

       236
       236
       -
        name = "cxxbridge-flags"

     

       237
       237
       -
       -version = "1.0.80"

     

       238
       238
       -
       +version = "1.0.83"

     

       239
       239
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       240
       240
       -
       -checksum = "e72537424b474af1460806647c41d4b6d35d09ef7fe031c5c2fa5766047cc56a"

     

       241
       241
       -
       +checksum = "ac040a39517fd1674e0f32177648334b0f4074625b5588a64519804ba0553b12"

     

       242
       242
       -
        

     

       243
       243
       -
        [[package]]

     

       244
       244
       -
        name = "cxxbridge-macro"

     

       245
       245
       -
       -version = "1.0.80"

     

       246
       246
       -
       +version = "1.0.83"

     

       247
       247
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       248
       248
       -
       -checksum = "309e4fb93eed90e1e14bea0da16b209f81813ba9fc7830c20ed151dd7bc0a4d7"

     

       249
       249
       -
       +checksum = "1362b0ddcfc4eb0a1f57b68bd77dd99f0e826958a96abd0ae9bd092e114ffed6"

     

       250
       250
       -
        dependencies = [

     

       251
       251
       -
         "proc-macro2",

     

       252
       252
       -
         "quote",

     

       253
       253
       -
       @@ -337,11 +310,11 @@ dependencies = [

     

       254
       254
       -
        

     

       255
       255
       -
        [[package]]

     

       256
       256
       -
        name = "defer-drop"

     

       257
       257
       -
       -version = "1.2.0"

     

       258
       258
       -
       +version = "1.3.0"

     

       259
       259
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       260
       260
       -
       -checksum = "828aca0e5e4341b0320a319209cbc6255b8b06254849ce8a5f33d33f7f2fa0f0"

     

       261
       261
       -
       +checksum = "f613ec9fa66a6b28cdb1842b27f9adf24f39f9afc4dcdd9fdecee4aca7945c57"

     

       262
       262
       -
        dependencies = [

     

       263
       263
       -
       - "crossbeam-channel 0.4.4",

     

       264
       264
       -
       + "crossbeam-channel",

     

       265
       265
       -
         "once_cell",

     

       266
       266
       -
        ]

     

       267
       267
       -
        

     

       268
       268
       -
       @@ -382,7 +355,7 @@ version = "2.0.0"

     

       269
       269
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       270
       270
       -
        checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"

     

       271
       271
       -
        dependencies = [

     

       272
       272
       -
       - "cfg-if 1.0.0",

     

       273
       273
       -
       + "cfg-if",

     

       274
       274
       -
         "dirs-sys-next",

     

       275
       275
       -
        ]

     

       276
       276
       -
        

     

       277
       277
       -
       @@ -399,9 +372,9 @@ dependencies = [

     

       278
       278
       -
        

     

       279
       279
       -
        [[package]]

     

       280
       280
       -
        name = "either"

     

       281
       281
       -
       -version = "1.6.1"

     

       282
       282
       -
       +version = "1.8.0"

     

       283
       283
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       284
       284
       -
       -checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"

     

       285
       285
       -
       +checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"

     

       286
       286
       -
        

     

       287
       287
       -
        [[package]]

     

       288
       288
       -
        name = "encode_unicode"

     

       289
       289
       -
       @@ -447,20 +420,20 @@ dependencies = [

     

       290
       290
       -
        

     

       291
       291
       -
        [[package]]

     

       292
       292
       -
        name = "getrandom"

     

       293
       293
       -
       -version = "0.2.7"

     

       294
       294
       -
       +version = "0.2.8"

     

       295
       295
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       296
       296
       -
       -checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6"

     

       297
       297
       -
       +checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"

     

       298
       298
       -
        dependencies = [

     

       299
       299
       -
       - "cfg-if 1.0.0",

     

       300
       300
       -
       + "cfg-if",

     

       301
       301
       -
         "libc",

     

       302
       302
       -
       - "wasi",

     

       303
       303
       -
       + "wasi 0.11.0+wasi-snapshot-preview1",

     

       304
       304
       -
        ]

     

       305
       305
       -
        

     

       306
       306
       -
        [[package]]

     

       307
       307
       -
        name = "hashbrown"

     

       308
       308
       -
       -version = "0.11.2"

     

       309
       309
       -
       +version = "0.12.3"

     

       310
       310
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       311
       311
       -
       -checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"

     

       312
       312
       -
       +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"

     

       313
       313
       -
        

     

       314
       314
       -
        [[package]]

     

       315
       315
       -
        name = "hashbrown"

     

       316
       316
       -
       @@ -482,7 +455,7 @@ dependencies = [

     

       317
       317
       -
        

     

       318
       318
       -
        [[package]]

     

       319
       319
       -
        name = "httm"

     

       320
       320
       -
       -version = "0.17.9"

     

       321
       321
       -
       +version = "0.17.10"

     

       322
       322
       -
        dependencies = [

     

       323
       323
       -
         "clap",

     

       324
       324
       -
         "crossbeam",

     

       325
       325
       -
       @@ -495,8 +468,8 @@ dependencies = [

     

       326
       326
       -
         "proc-mounts",

     

       327
       327
       -
         "rayon",

     

       328
       328
       -
         "skim",

     

       329
       329
       -
       - "terminal_size 0.2.2",

     

       330
       330
       -
       - "time",

     

       331
       331
       -
       + "terminal_size 0.2.3",

     

       332
       332
       -
       + "time 0.3.17",

     

       333
       333
       -
         "which",

     

       334
       334
       -
        ]

     

       335
       335
       -
        

     

       336
       336
       -
       @@ -532,12 +505,12 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"

     

       337
       337
       -
        

     

       338
       338
       -
        [[package]]

     

       339
       339
       -
        name = "indexmap"

     

       340
       340
       -
       -version = "1.8.2"

     

       341
       341
       -
       +version = "1.9.2"

     

       342
       342
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       343
       343
       -
       -checksum = "e6012d540c5baa3589337a98ce73408de9b5a25ec9fc2c6fd6be8f0d39e0ca5a"

     

       344
       344
       -
       +checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"

     

       345
       345
       -
        dependencies = [

     

       346
       346
       -
         "autocfg",

     

       347
       347
       -
       - "hashbrown 0.11.2",

     

       348
       348
       -
       + "hashbrown 0.12.3",

     

       349
       349
       -
        ]

     

       350
       350
       -
        

     

       351
       351
       -
        [[package]]

     

       352
       352
       -
       @@ -553,15 +526,19 @@ dependencies = [

     

       353
       353
       -
        

     

       354
       354
       -
        [[package]]

     

       355
       355
       -
        name = "io-lifetimes"

     

       356
       356
       -
       -version = "0.7.5"

     

       357
       357
       -
       +version = "1.0.3"

     

       358
       358
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       359
       359
       -
       -checksum = "59ce5ef949d49ee85593fc4d3f3f95ad61657076395cbbce23e2121fc5542074"

     

       360
       360
       -
       +checksum = "46112a93252b123d31a119a8d1a1ac19deac4fac6e0e8b0df58f0d4e5870e63c"

     

       361
       361
       -
       +dependencies = [

     

       362
       362
       -
       + "libc",

     

       363
       363
       -
       + "windows-sys",

     

       364
       364
       -
       +]

     

       365
       365
       -
        

     

       366
       366
       -
        [[package]]

     

       367
       367
       -
        name = "itoa"

     

       368
       368
       -
       -version = "1.0.2"

     

       369
       369
       -
       +version = "1.0.4"

     

       370
       370
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       371
       371
       -
       -checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d"

     

       372
       372
       -
       +checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc"

     

       373
       373
       -
        

     

       374
       374
       -
        [[package]]

     

       375
       375
       -
        name = "js-sys"

     

       376
       376
       -
       @@ -580,9 +557,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

     

       377
       377
       -
        

     

       378
       378
       -
        [[package]]

     

       379
       379
       -
        name = "libc"

     

       380
       380
       -
       -version = "0.2.137"

     

       381
       381
       -
       +version = "0.2.138"

     

       382
       382
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       383
       383
       -
       -checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"

     

       384
       384
       -
       +checksum = "db6d7e329c562c5dfab7a46a2afabc8b987ab9a4834c9d1ca04dc54c1546cef8"

     

       385
       385
       -
        

     

       386
       386
       -
        [[package]]

     

       387
       387
       -
        name = "link-cplusplus"

     

       388
       388
       -
       @@ -595,9 +572,9 @@ dependencies = [

     

       389
       389
       -
        

     

       390
       390
       -
        [[package]]

     

       391
       391
       -
        name = "linux-raw-sys"

     

       392
       392
       -
       -version = "0.0.46"

     

       393
       393
       -
       +version = "0.1.3"

     

       394
       394
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       395
       395
       -
       -checksum = "d4d2456c373231a208ad294c33dc5bff30051eafd954cd4caae83a712b12854d"

     

       396
       396
       -
       +checksum = "8f9f08d8963a6c613f4b1a78f4f4a4dbfadf8e6545b2d72861731e4858b8b47f"

     

       397
       397
       -
        

     

       398
       398
       -
        [[package]]

     

       399
       399
       -
        name = "log"

     

       400
       400
       -
       @@ -605,7 +582,7 @@ version = "0.4.17"

     

       401
       401
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       402
       402
       -
        checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"

     

       403
       403
       -
        dependencies = [

     

       404
       404
       -
       - "cfg-if 1.0.0",

     

       405
       405
       -
       + "cfg-if",

     

       406
       406
       -
        ]

     

       407
       407
       -
        

     

       408
       408
       -
        [[package]]

     

       409
       409
       -
       @@ -618,12 +595,6 @@ dependencies = [

     

       410
       410
       -
         "nu-ansi-term",

     

       411
       411
       -
        ]

     

       412
       412
       -
        

     

       413
       413
       -
       -[[package]]

     

       414
       414
       -
       -name = "maybe-uninit"

     

       415
       415
       -
       -version = "2.0.0"

     

       416
       416
       -
       -source = "registry+https://github.com/rust-lang/crates.io-index"

     

       417
       417
       -
       -checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"

     

       418
       418
       -
       -

     

       419
       419
       -
        [[package]]

     

       420
       420
       -
        name = "memchr"

     

       421
       421
       -
        version = "2.5.0"

     

       422
       422
       -
       @@ -639,28 +610,37 @@ dependencies = [

     

       423
       423
       -
         "autocfg",

     

       424
       424
       -
        ]

     

       425
       425
       -
        

     

       426
       426
       -
       +[[package]]

     

       427
       427
       -
       +name = "memoffset"

     

       428
       428
       -
       +version = "0.7.1"

     

       429
       429
       -
       +source = "registry+https://github.com/rust-lang/crates.io-index"

     

       430
       430
       -
       +checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"

     

       431
       431
       -
       +dependencies = [

     

       432
       432
       -
       + "autocfg",

     

       433
       433
       -
       +]

     

       434
       434
       -
       +

     

       435
       435
       -
        [[package]]

     

       436
       436
       -
        name = "nix"

     

       437
       437
       -
       -version = "0.24.1"

     

       438
       438
       -
       +version = "0.24.3"

     

       439
       439
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       440
       440
       -
       -checksum = "8f17df307904acd05aa8e32e97bb20f2a0df1728bbc2d771ae8f9a90463441e9"

     

       441
       441
       -
       +checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"

     

       442
       442
       -
        dependencies = [

     

       443
       443
       -
         "bitflags",

     

       444
       444
       -
       - "cfg-if 1.0.0",

     

       445
       445
       -
       + "cfg-if",

     

       446
       446
       -
         "libc",

     

       447
       447
       -
        ]

     

       448
       448
       -
        

     

       449
       449
       -
        [[package]]

     

       450
       450
       -
        name = "nix"

     

       451
       451
       -
       -version = "0.25.0"

     

       452
       452
       -
       +version = "0.25.1"

     

       453
       453
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       454
       454
       -
       -checksum = "e322c04a9e3440c327fca7b6c8a63e6890a32fa2ad689db972425f07e0d22abb"

     

       455
       455
       -
       +checksum = "f346ff70e7dbfd675fe90590b92d59ef2de15a8779ae305ebcbfd3f0caf59be4"

     

       456
       456
       -
        dependencies = [

     

       457
       457
       -
         "autocfg",

     

       458
       458
       -
         "bitflags",

     

       459
       459
       -
       - "cfg-if 1.0.0",

     

       460
       460
       -
       + "cfg-if",

     

       461
       461
       -
         "libc",

     

       462
       462
       -
       - "memoffset",

     

       463
       463
       -
       + "memoffset 0.6.5",

     

       464
       464
       -
         "pin-utils",

     

       465
       465
       -
        ]

     

       466
       466
       -
        

     

       467
       467
       -
       @@ -726,9 +706,9 @@ checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"

     

       468
       468
       -
        

     

       469
       469
       -
        [[package]]

     

       470
       470
       -
        name = "os_str_bytes"

     

       471
       471
       -
       -version = "6.1.0"

     

       472
       472
       -
       +version = "6.4.1"

     

       473
       473
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       474
       474
       -
       -checksum = "21326818e99cfe6ce1e524c2a805c189a99b5ae555a35d19f9a284b427d86afa"

     

       475
       475
       -
       +checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"

     

       476
       476
       -
        

     

       477
       477
       -
        [[package]]

     

       478
       478
       -
        name = "overload"

     

       479
       479
       -
       @@ -759,9 +739,9 @@ checksum = "15eb2c6e362923af47e13c23ca5afb859e83d54452c55b0b9ac763b8f7c1ac16"

     

       480
       480
       -
        

     

       481
       481
       -
        [[package]]

     

       482
       482
       -
        name = "proc-macro2"

     

       483
       483
       -
       -version = "1.0.39"

     

       484
       484
       -
       +version = "1.0.47"

     

       485
       485
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       486
       486
       -
       -checksum = "c54b25569025b7fc9651de43004ae593a75ad88543b17178aa5e1b9c4f15f56f"

     

       487
       487
       -
       +checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"

     

       488
       488
       -
        dependencies = [

     

       489
       489
       -
         "unicode-ident",

     

       490
       490
       -
        ]

     

       491
       491
       -
       @@ -777,9 +757,9 @@ dependencies = [

     

       492
       492
       -
        

     

       493
       493
       -
        [[package]]

     

       494
       494
       -
        name = "quote"

     

       495
       495
       -
       -version = "1.0.18"

     

       496
       496
       -
       +version = "1.0.21"

     

       497
       497
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       498
       498
       -
       -checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1"

     

       499
       499
       -
       +checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"

     

       500
       500
       -
        dependencies = [

     

       501
       501
       -
         "proc-macro2",

     

       502
       502
       -
        ]

     

       503
       503
       -
       @@ -801,17 +781,17 @@ version = "1.10.1"

     

       504
       504
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       505
       505
       -
        checksum = "cac410af5d00ab6884528b4ab69d1e8e146e8d471201800fa1b4524126de6ad3"

     

       506
       506
       -
        dependencies = [

     

       507
       507
       -
       - "crossbeam-channel 0.5.5",

     

       508
       508
       -
       + "crossbeam-channel",

     

       509
       509
       -
         "crossbeam-deque",

     

       510
       510
       -
       - "crossbeam-utils 0.8.9",

     

       511
       511
       -
       + "crossbeam-utils",

     

       512
       512
       -
         "num_cpus",

     

       513
       513
       -
        ]

     

       514
       514
       -
        

     

       515
       515
       -
        [[package]]

     

       516
       516
       -
        name = "redox_syscall"

     

       517
       517
       -
       -version = "0.2.13"

     

       518
       518
       -
       +version = "0.2.16"

     

       519
       519
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       520
       520
       -
       -checksum = "62f25bc4c7e55e0b0b7a1d43fb893f4fa1361d0abe38b9ce4f323c2adfe6ef42"

     

       521
       521
       -
       +checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"

     

       522
       522
       -
        dependencies = [

     

       523
       523
       -
         "bitflags",

     

       524
       524
       -
        ]

     

       525
       525
       -
       @@ -829,9 +809,9 @@ dependencies = [

     

       526
       526
       -
        

     

       527
       527
       -
        [[package]]

     

       528
       528
       -
        name = "regex"

     

       529
       529
       -
       -version = "1.6.0"

     

       530
       530
       -
       +version = "1.7.0"

     

       531
       531
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       532
       532
       -
       -checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b"

     

       533
       533
       -
       +checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"

     

       534
       534
       -
        dependencies = [

     

       535
       535
       -
         "aho-corasick",

     

       536
       536
       -
         "memchr",

     

       537
       537
       -
       @@ -840,15 +820,15 @@ dependencies = [

     

       538
       538
       -
        

     

       539
       539
       -
        [[package]]

     

       540
       540
       -
        name = "regex-syntax"

     

       541
       541
       -
       -version = "0.6.27"

     

       542
       542
       -
       +version = "0.6.28"

     

       543
       543
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       544
       544
       -
       -checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"

     

       545
       545
       -
       +checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"

     

       546
       546
       -
        

     

       547
       547
       -
        [[package]]

     

       548
       548
       -
        name = "rustix"

     

       549
       549
       -
       -version = "0.35.13"

     

       550
       550
       -
       +version = "0.36.4"

     

       551
       551
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       552
       552
       -
       -checksum = "727a1a6d65f786ec22df8a81ca3121107f235970dc1705ed681d3e6e8b9cd5f9"

     

       553
       553
       -
       +checksum = "cb93e85278e08bb5788653183213d3a60fc242b10cb9be96586f5a73dcb67c23"

     

       554
       554
       -
        dependencies = [

     

       555
       555
       -
         "bitflags",

     

       556
       556
       -
         "errno",

     

       557
       557
       -
       @@ -860,9 +840,9 @@ dependencies = [

     

       558
       558
       -
        

     

       559
       559
       -
        [[package]]

     

       560
       560
       -
        name = "rustversion"

     

       561
       561
       -
       -version = "1.0.6"

     

       562
       562
       -
       +version = "1.0.9"

     

       563
       563
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       564
       564
       -
       -checksum = "f2cc38e8fa666e2de3c4aba7edeb5ffc5246c1c2ed0e3d17e560aeeba736b23f"

     

       565
       565
       -
       +checksum = "97477e48b4cf8603ad5f7aaf897467cf42ab4218a38ef76fb14c2d6773a6d6a8"

     

       566
       566
       -
        

     

       567
       567
       -
        [[package]]

     

       568
       568
       -
        name = "scopeguard"

     

       569
       569
       -
       @@ -878,14 +858,14 @@ checksum = "9c8132065adcfd6e02db789d9285a0deb2f3fcb04002865ab67d5fb103533898"

     

       570
       570
       -
        

     

       571
       571
       -
        [[package]]

     

       572
       572
       -
        name = "serde"

     

       573
       573
       -
       -version = "1.0.137"

     

       574
       574
       -
       +version = "1.0.148"

     

       575
       575
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       576
       576
       -
       -checksum = "61ea8d54c77f8315140a05f4c7237403bf38b72704d031543aa1d16abbf517d1"

     

       577
       577
       -
       +checksum = "e53f64bb4ba0191d6d0676e1b141ca55047d83b74f5607e6d8eb88126c52c2dc"

     

       578
       578
       -
        

     

       579
       579
       -
        [[package]]

     

       580
       580
       -
        name = "skim"

     

       581
       581
       -
        version = "0.10.2"

     

       582
       582
       -
       -source = "git+https://github.com/kimono-koans/skim?branch=httm-vendored#bf2b007ae7371a7cff4d93194033bd6c90cbf96c"

     

       583
       583
       -
       +source = "git+https://github.com/kimono-koans/skim?branch=httm-vendored#bca6554ebf09803fc429a59c89eb96428e920cc5"

     

       584
       584
       -
        dependencies = [

     

       585
       585
       -
         "beef",

     

       586
       586
       -
         "bitflags",

     

       587
       587
       -
       @@ -896,10 +876,11 @@ dependencies = [

     

       588
       588
       -
         "fuzzy-matcher",

     

       589
       589
       -
         "lazy_static",

     

       590
       590
       -
         "log",

     

       591
       591
       -
       - "nix 0.25.0",

     

       592
       592
       -
       + "nix 0.25.1",

     

       593
       593
       -
       + "once_cell",

     

       594
       594
       -
         "rayon",

     

       595
       595
       -
         "regex",

     

       596
       596
       -
       - "time",

     

       597
       597
       -
       + "time 0.3.17",

     

       598
       598
       -
         "timer",

     

       599
       599
       -
         "tuikit",

     

       600
       600
       -
         "unicode-width",

     

       601
       601
       -
       @@ -914,9 +895,9 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"

     

       602
       602
       -
        

     

       603
       603
       -
        [[package]]

     

       604
       604
       -
        name = "syn"

     

       605
       605
       -
       -version = "1.0.96"

     

       606
       606
       -
       +version = "1.0.105"

     

       607
       607
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       608
       608
       -
       -checksum = "0748dd251e24453cb8717f0354206b91557e4ec8703673a4b30208f2abaf1ebf"

     

       609
       609
       -
       +checksum = "60b9b43d45702de4c839cb9b51d9f529c5dd26a4aff255b42b1ebc03e88ee908"

     

       610
       610
       -
        dependencies = [

     

       611
       611
       -
         "proc-macro2",

     

       612
       612
       -
         "quote",

     

       613
       613
       -
       @@ -955,9 +936,9 @@ dependencies = [

     

       614
       614
       -
        

     

       615
       615
       -
        [[package]]

     

       616
       616
       -
        name = "terminal_size"

     

       617
       617
       -
       -version = "0.2.2"

     

       618
       618
       -
       +version = "0.2.3"

     

       619
       619
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       620
       620
       -
       -checksum = "40ca90c434fd12083d1a6bdcbe9f92a14f96c8a1ba600ba451734ac334521f7a"

     

       621
       621
       -
       +checksum = "cb20089a8ba2b69debd491f8d2d023761cbf196e999218c591fa1e7e15a21907"

     

       622
       622
       -
        dependencies = [

     

       623
       623
       -
         "rustix",

     

       624
       624
       -
         "windows-sys",

     

       625
       625
       -
       @@ -971,18 +952,18 @@ checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"

     

       626
       626
       -
        

     

       627
       627
       -
        [[package]]

     

       628
       628
       -
        name = "thiserror"

     

       629
       629
       -
       -version = "1.0.31"

     

       630
       630
       -
       +version = "1.0.37"

     

       631
       631
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       632
       632
       -
       -checksum = "bd829fe32373d27f76265620b5309d0340cb8550f523c1dda251d6298069069a"

     

       633
       633
       -
       +checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"

     

       634
       634
       -
        dependencies = [

     

       635
       635
       -
         "thiserror-impl",

     

       636
       636
       -
        ]

     

       637
       637
       -
        

     

       638
       638
       -
        [[package]]

     

       639
       639
       -
        name = "thiserror-impl"

     

       640
       640
       -
       -version = "1.0.31"

     

       641
       641
       -
       +version = "1.0.37"

     

       642
       642
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       643
       643
       -
       -checksum = "0396bc89e626244658bef819e22d0cc459e795a5ebe878e6ec336d1674a8d79a"

     

       644
       644
       -
       +checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"

     

       645
       645
       -
        dependencies = [

     

       646
       646
       -
         "proc-macro2",

     

       647
       647
       -
         "quote",

     

       648
       648
       -
       @@ -998,6 +979,17 @@ dependencies = [

     

       649
       649
       -
         "once_cell",

     

       650
       650
       -
        ]

     

       651
       651
       -
        

     

       652
       652
       -
       +[[package]]

     

       653
       653
       -
       +name = "time"

     

       654
       654
       -
       +version = "0.1.45"

     

       655
       655
       -
       +source = "registry+https://github.com/rust-lang/crates.io-index"

     

       656
       656
       -
       +checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"

     

       657
       657
       -
       +dependencies = [

     

       658
       658
       -
       + "libc",

     

       659
       659
       -
       + "wasi 0.10.0+wasi-snapshot-preview1",

     

       660
       660
       -
       + "winapi",

     

       661
       661
       -
       +]

     

       662
       662
       -
       +

     

       663
       663
       -
        [[package]]

     

       664
       664
       -
        name = "time"

     

       665
       665
       -
        version = "0.3.17"

     

       666
       666
       -
       @@ -1030,7 +1022,8 @@ dependencies = [

     

       667
       667
       -
        [[package]]

     

       668
       668
       -
        name = "timer"

     

       669
       669
       -
        version = "0.2.0"

     

       670
       670
       -
       -source = "git+https://github.com/kimono-koans/timer.rs#85c9e56ab20ea530c934433636406f8b585bef59"

     

       671
       671
       -
       +source = "registry+https://github.com/rust-lang/crates.io-index"

     

       672
       672
       -
       +checksum = "31d42176308937165701f50638db1c31586f183f1aab416268216577aec7306b"

     

       673
       673
       -
        dependencies = [

     

       674
       674
       -
         "chrono",

     

       675
       675
       -
        ]

     

       676
       676
       -
       @@ -1044,22 +1037,22 @@ dependencies = [

     

       677
       677
       -
         "bitflags",

     

       678
       678
       -
         "lazy_static",

     

       679
       679
       -
         "log",

     

       680
       680
       -
       - "nix 0.24.1",

     

       681
       681
       -
       + "nix 0.24.3",

     

       682
       682
       -
         "term",

     

       683
       683
       -
         "unicode-width",

     

       684
       684
       -
        ]

     

       685
       685
       -
        

     

       686
       686
       -
        [[package]]

     

       687
       687
       -
        name = "unicode-ident"

     

       688
       688
       -
       -version = "1.0.1"

     

       689
       689
       -
       +version = "1.0.5"

     

       690
       690
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       691
       691
       -
       -checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c"

     

       692
       692
       -
       +checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"

     

       693
       693
       -
        

     

       694
       694
       -
        [[package]]

     

       695
       695
       -
        name = "unicode-width"

     

       696
       696
       -
       -version = "0.1.9"

     

       697
       697
       -
       +version = "0.1.10"

     

       698
       698
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       699
       699
       -
       -checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"

     

       700
       700
       -
       +checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"

     

       701
       701
       -
        

     

       702
       702
       -
        [[package]]

     

       703
       703
       -
        name = "utf8parse"

     

       704
       704
       -
       @@ -1094,6 +1087,12 @@ dependencies = [

     

       705
       705
       -
         "quote",

     

       706
       706
       -
        ]

     

       707
       707
       -
        

     

       708
       708
       -
       +[[package]]

     

       709
       709
       -
       +name = "wasi"

     

       710
       710
       -
       +version = "0.10.0+wasi-snapshot-preview1"

     

       711
       711
       -
       +source = "registry+https://github.com/rust-lang/crates.io-index"

     

       712
       712
       -
       +checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"

     

       713
       713
       -
       +

     

       714
       714
       -
        [[package]]

     

       715
       715
       -
        name = "wasi"

     

       716
       716
       -
        version = "0.11.0+wasi-snapshot-preview1"

     

       717
       717
       -
       @@ -1106,7 +1105,7 @@ version = "0.2.83"

     

       718
       718
       -
        source = "registry+https://github.com/rust-lang/crates.io-index"

     

       719
       719
       -
        checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"

     

       720
       720
       -
        dependencies = [

     

       721
       721
       -
       - "cfg-if 1.0.0",

     

       722
       722
       -
       + "cfg-if",

     

       723
       723
       -
         "wasm-bindgen-macro",

     

       724
       724
       -
        ]

     

       725
       725
       -

+5 -7

pkgs/tools/filesystems/httm/default.nix

···

       1
       1
        
       { lib

     

       2
       2
       -
       , fetchFromGitHub

     

       3
       2
        
       , rustPlatform

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
        
       , installShellFiles

     

       5
       5
        
       }:

     

       6
       6
        
       

     

       7
       7
        
       rustPlatform.buildRustPackage rec {

     

       8
       8
        
         pname = "httm";

     

       9
       9
       -
         version = "0.17.10";

     

       9
       9
       +
         version = "0.18.3";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "kimono-koans";

     

       13
       13
        
           repo = pname;

     

       14
       14
        
           rev = version;

     

       15
       15
       -
           sha256 = "sha256-xhsZaOsEYmtx3EcKbc7cIPvrUdXl3gyl5InZ1Va0U6E=";

     

       15
       15
       +
           sha256 = "sha256-LJFBridWS7YYO9Bw3mzRdRnh2gGUxAtuoNq2T1wuAcY=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         cargoPatches = [ ./cargo-lock.patch ];

     

       19
       19
       -
       

     

       20
       20
       -
         cargoSha256 = "sha256-H8LOpNKsc9CxURB+ZcQT6Uhv4aw2sx8sNdDGDCkz2SU=";

     

       18
       18
       +
         cargoSha256 = "sha256-/v0QQ3EnmL1EKEjJ4O0t52SOrCz+CVBpunogEfVMpBw=";

     

       21
       19
        
       

     

       22
       20
        
         nativeBuildInputs = [ installShellFiles ];

     

       23
       21
        
       

     
···

       31
       29
        
         meta = with lib; {

     

       32
       30
        
           description = "Interactive, file-level Time Machine-like tool for ZFS/btrfs";

     

       33
       31
        
           homepage = "https://github.com/kimono-koans/httm";

     

       32
       32
       +
           changelog = "https://github.com/kimono-koans/httm/releases/tag/${version}";

     

       34
       33
        
           license = licenses.mpl20;

     

       35
       35
       -
           platforms = platforms.unix;

     

       36
       34
        
           maintainers = with maintainers; [ wyndon ];

     

       37
       35
        
         };

     

       38
       36
        
       }

+3 -3

pkgs/tools/misc/didyoumean/default.nix

···

       12
       12
        
       

     

       13
       13
        
       rustPlatform.buildRustPackage rec {

     

       14
       14
        
         pname = "didyoumean";

     

       15
       15
       -
         version = "1.1.3";

     

       15
       15
       +
         version = "1.1.4";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchFromGitHub {

     

       18
       18
        
           owner = "hisbaan";

     

       19
       19
        
           repo = "didyoumean";

     

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

     

       21
       21
       -
           sha256 = "sha256-hHl9PGNDFN7Dad2JOlAy99dz0pC9OmphwYMJHBBwx7Y=";

     

       21
       21
       +
           sha256 = "sha256-PSEoh1OMElFJ8m4er1vBMkQak3JvLjd+oWNWA46cows=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
       -
         cargoSha256 = "sha256-rjkj9MO6fXVOk3fA87olGt/iIaJ8Zv/cy/Cqy/pg6yI=";

     

       24
       24
       +
         cargoSha256 = "sha256-QERnohWpkJ0LWkdxHrY6gKxdGqxDkLla7jlG44laojk=";

     

       25
       25
        
       

     

       26
       26
        
         nativeBuildInputs = [

     

       27
       27
        
           installShellFiles

+3 -3

pkgs/tools/networking/q/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "q";

     

       5
       5
       -
         version = "0.8.2";

     

       5
       5
       +
         version = "0.8.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "natesales";

     

       9
       9
        
           repo = "q";

     

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

     

       11
       11
       -
           sha256 = "sha256-Esg2i8UNT+SuW9+jsnVEOt1ot822CamZ3JoR8ReY0+4=";

     

       11
       11
       +
           sha256 = "sha256-M2TgDha+F4hY7f9sabzZEdsxdp8rdXDZB4ktmpDF5D8=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorHash = "sha256-oarXbxROTd7knHr9GKlrPnnS6ehkps2ZYYsUS9cn6ek=";

     

       14
       14
       +
         vendorHash = "sha256-216NwRlU7mmr+ebiBwq9DVtFb2SpPgkGUrVZMUAY9rI=";

     

       15
       15
        
       

     

       16
       16
        
         doCheck = false; # tries to resolve DNS

     

       17
       17

+3 -3

pkgs/tools/text/diffsitter/default.nix

···

       32
       32
        
       in

     

       33
       33
        
       rustPlatform.buildRustPackage rec {

     

       34
       34
        
         pname = "diffsitter";

     

       35
       35
       -
         version = "0.7.2";

     

       35
       35
       +
         version = "0.7.3";

     

       36
       36
        
       

     

       37
       37
        
         src = fetchFromGitHub {

     

       38
       38
        
           owner = "afnanenayet";

     

       39
       39
        
           repo = pname;

     

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

     

       41
       41
       -
           sha256 = "sha256-oHG2vw981r9FZSwbJ+xcLemfQSMDrk6PAr/qtyImM04=";

     

       41
       41
       +
           sha256 = "sha256-AJjgn+qFfy6/gjb8tQOJDmevZy1ZfpF0nTxAgunSabE=";

     

       42
       42
        
           fetchSubmodules = false;

     

       43
       43
        
         };

     

       44
       44
        
       

     

       45
       45
       -
         cargoSha256 = "sha256-Cj9jdeeJNR/7mquEfaQCsFgiCjyJbZaaSkOzbU64T3U=";

     

       45
       45
       +
         cargoSha256 = "sha256-U/XvllkzEVt4TpDPA5gSRKpIIQagATGdHh7YPFOo4CY=";

     

       46
       46
        
       

     

       47
       47
        
         buildNoDefaultFeatures = true;

     

       48
       48
        
         buildFeatures = [

+4 -2

pkgs/top-level/all-packages.nix

···

       2173
       2173
        
       

     

       2174
       2174
        
         ### APPLICATIONS/EMULATORS/BSNES

     

       2175
       2175
        
       

     

       2176
       2176
       -
         ares = callPackage ../applications/emulators/bsnes/ares { };

     

       2176
       2176
       +
         ares = darwin.apple_sdk_11_0.callPackage ../applications/emulators/bsnes/ares { };

     

       2177
       2177
        
       

     

       2178
       2178
        
         bsnes-hd = callPackage ../applications/emulators/bsnes/bsnes-hd {

     

       2179
       2179
        
           inherit (darwin.apple_sdk.frameworks) Cocoa OpenAL;

     
···

       4404
       4404
        
         envconsul = callPackage ../tools/system/envconsul { };

     

       4405
       4405
        
       

     

       4406
       4406
        
         envsubst = callPackage ../tools/misc/envsubst { };

     

       4407
       4407
       +
       

     

       4408
       4408
       +
         envfs = callPackage ../tools/filesystems/envfs { };

     

       4407
       4409
        
       

     

       4408
       4410
        
         er-patcher = callPackage ../tools/games/er-patcher { };

     

       4409
       4411
        
       

     
···

       16735
       16737
        
           antlr4_10

     

       16736
       16738
        
           antlr4_11;

     

       16737
       16739
        
       

     

       16738
       16738
       -
         antlr4 = antlr4_8;

     

       16740
       16740
       +
         antlr4 = antlr4_11;

     

       16739
       16741
        
       

     

       16740
       16742
        
         antlr = antlr4;

     

       16741
       16743

+5 -7

pkgs/top-level/python-packages.nix

···

       488
       488
        
       

     

       489
       489
        
         ansiwrap = callPackage ../development/python-modules/ansiwrap { };

     

       490
       490
        
       

     

       491
       491
       -
         antlr4_8-python3-runtime = callPackage ../development/python-modules/antlr4-python3-runtime {

     

       492
       492
       -
           antlr4 = pkgs.antlr4_8;

     

       493
       493
       -
         };

     

       494
       494
       -
         antlr4_9-python3-runtime = callPackage ../development/python-modules/antlr4-python3-runtime {

     

       495
       495
       -
           antlr4 = pkgs.antlr4_9;

     

       491
       491
       +
         antlr4-python3-runtime = callPackage ../development/python-modules/antlr4-python3-runtime {

     

       492
       492
       +
           inherit (pkgs) antlr4;

     

       496
       493
        
         };

     

       497
       497
       -
         antlr4-python3-runtime = self.antlr4_8-python3-runtime;

     

       498
       494
        
       

     

       499
       495
        
         anyascii = callPackage ../development/python-modules/anyascii { };

     

       500
       496
        
       

     
···

       4173
       4169
        
       

     

       4174
       4170
        
         hass-nabucasa = callPackage ../development/python-modules/hass-nabucasa { };

     

       4175
       4171
        
       

     

       4172
       4172
       +
         hassil = callPackage ../development/python-modules/hassil { };

     

       4173
       4173
       +
       

     

       4176
       4174
        
         hatasmota = callPackage ../development/python-modules/hatasmota { };

     

       4177
       4175
        
       

     

       4178
       4176
        
         hatchling = callPackage ../development/python-modules/hatchling { };

     
···

       4389
       4387
        
       

     

       4390
       4388
        
         hy = callPackage ../development/python-modules/hy { };

     

       4391
       4389
        
       

     

       4392
       4392
       -
         hydra = callPackage ../development/python-modules/hydra { };

     

       4390
       4390
       +
         hydra-core = callPackage ../development/python-modules/hydra-core { };

     

       4393
       4391
        
       

     

       4394
       4392
        
         hydra-check = callPackage ../development/python-modules/hydra-check { };

     

       4395
       4393