From d88318ee558014b26e3076f7edac8a832c808b5b Mon Sep 17 00:00:00 2001 From: Ryan Burns Date: Sat, 30 Jan 2021 00:53:37 -0800 Subject: [PATCH 01/70] libdrm: fix cross-compile to x86 Don't omit drm_intel when cross-compiling. We've had this switch since ca5d91aa608224368d93599416dd97b16cbe6bbf and it doesn't seem to be needed anymore. https://hydra.nixos.org/eval/1644952?filter=x86_64-musl.mesa#tabs-still-fail --- pkgs/development/libraries/libdrm/default.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/libraries/libdrm/default.nix b/pkgs/development/libraries/libdrm/default.nix index e575624f815..b4ba311165a 100644 --- a/pkgs/development/libraries/libdrm/default.nix +++ b/pkgs/development/libraries/libdrm/default.nix @@ -33,7 +33,7 @@ stdenv.mkDerivation rec { ] ++ lib.optionals (stdenv.isAarch32 || stdenv.isAarch64) [ "-Dtegra=true" "-Detnaviv=true" - ] ++ lib.optional (stdenv.hostPlatform != stdenv.buildPlatform) "-Dintel=false"; + ]; meta = with lib; { homepage = "https://gitlab.freedesktop.org/mesa/drm"; From 53033aaf5a2620c8adaf6e66ef9afc1d567132c2 Mon Sep 17 00:00:00 2001 From: Vincent Haupert Date: Sat, 30 Jan 2021 11:04:35 +0100 Subject: [PATCH 02/70] nixos/networkd: add missing dhcpV6Config options --- nixos/modules/system/boot/networkd.nix | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/nixos/modules/system/boot/networkd.nix b/nixos/modules/system/boot/networkd.nix index 3b01bc00baf..2a679ffa81a 100644 --- a/nixos/modules/system/boot/networkd.nix +++ b/nixos/modules/system/boot/networkd.nix @@ -643,18 +643,29 @@ let sectionDHCPv6 = checkUnitConfig "DHCPv6" [ (assertOnlyFields [ + "UseAddress" "UseDNS" "UseNTP" + "RouteMetric" "RapidCommit" + "MUDURL" + "RequestOptions" + "SendVendorOption" "ForceDHCPv6PDOtherInformation" "PrefixDelegationHint" - "RouteMetric" + "WithoutRA" + "SendOption" + "UserClass" + "VendorClass" ]) + (assertValueOneOf "UseAddress" boolValues) (assertValueOneOf "UseDNS" boolValues) (assertValueOneOf "UseNTP" boolValues) + (assertInt "RouteMetric") (assertValueOneOf "RapidCommit" boolValues) (assertValueOneOf "ForceDHCPv6PDOtherInformation" boolValues) - (assertInt "RouteMetric") + (assertValueOneOf "WithoutRA" ["solicit" "information-request"]) + (assertRange "SendOption" 1 65536) ]; sectionDHCPServer = checkUnitConfig "DHCPServer" [ From 38f19af76935a5c86ee17daa41cc835fe8f10ac9 Mon Sep 17 00:00:00 2001 From: Vincent Haupert Date: Sat, 30 Jan 2021 11:24:13 +0100 Subject: [PATCH 03/70] nixos/networkd: add dhcpV6PrefixDelegationConfig option networkd gained a new section [DHCPv6PrefixDelegation] which controls delegated prefixes assigned by DHCPv6 client. Added in systemd 246. --- nixos/modules/system/boot/networkd.nix | 29 ++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/nixos/modules/system/boot/networkd.nix b/nixos/modules/system/boot/networkd.nix index 2a679ffa81a..382e4abe620 100644 --- a/nixos/modules/system/boot/networkd.nix +++ b/nixos/modules/system/boot/networkd.nix @@ -437,6 +437,7 @@ let "IPv6ProxyNDP" "IPv6ProxyNDPAddress" "IPv6PrefixDelegation" + "DHCPv6PrefixDelegation" "IPv6MTUBytes" "Bridge" "Bond" @@ -478,6 +479,7 @@ let (assertValueOneOf "IPv4ProxyARP" boolValues) (assertValueOneOf "IPv6ProxyNDP" boolValues) (assertValueOneOf "IPv6PrefixDelegation" ["static" "dhcpv6" "yes" "false"]) + (assertValueOneOf "DHCPv6PrefixDelegation" boolValues) (assertByteFormat "IPv6MTUBytes") (assertValueOneOf "ActiveSlave" boolValues) (assertValueOneOf "PrimarySlave" boolValues) @@ -668,6 +670,17 @@ let (assertRange "SendOption" 1 65536) ]; + sectionDHCPv6PrefixDelegation = checkUnitConfig "DHCPv6PrefixDelegation" [ + (assertOnlyFields [ + "SubnetId" + "Announce" + "Assign" + "Token" + ]) + (assertValueOneOf "Announce" boolValues) + (assertValueOneOf "Assign" boolValues) + ]; + sectionDHCPServer = checkUnitConfig "DHCPServer" [ (assertOnlyFields [ "PoolOffset" @@ -1101,6 +1114,18 @@ let ''; }; + dhcpV6PrefixDelegationConfig = mkOption { + default = {}; + example = { SubnetId = "auto"; Announce = true; }; + type = types.addCheck (types.attrsOf unitOption) check.network.sectionDHCPv6PrefixDelegation; + description = '' + Each attribute in this set specifies an option in the + [DHCPv6PrefixDelegation] section of the unit. See + systemd.network + 5 for details. + ''; + }; + dhcpServerConfig = mkOption { default = {}; example = { PoolOffset = 50; EmitDNS = false; }; @@ -1468,6 +1493,10 @@ let [DHCPv6] ${attrsToSection def.dhcpV6Config} '' + + optionalString (def.dhcpV6PrefixDelegationConfig != { }) '' + [DHCPv6PrefixDelegation] + ${attrsToSection def.dhcpV6PrefixDelegationConfig} + '' + optionalString (def.dhcpServerConfig != { }) '' [DHCPServer] ${attrsToSection def.dhcpServerConfig} From 735111487b6f5d0e1353e4bac157366ec5036756 Mon Sep 17 00:00:00 2001 From: Vincent Haupert Date: Sat, 30 Jan 2021 11:32:07 +0100 Subject: [PATCH 04/70] nixos/networkd: add ipv6AcceptRAConfig option Adds `systemd.network.networks.*.ipv6AcceptRAConfig` for networkd's [IPv6AcceptRA] section. --- nixos/modules/system/boot/networkd.nix | 39 ++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/nixos/modules/system/boot/networkd.nix b/nixos/modules/system/boot/networkd.nix index 382e4abe620..d439c602534 100644 --- a/nixos/modules/system/boot/networkd.nix +++ b/nixos/modules/system/boot/networkd.nix @@ -681,6 +681,29 @@ let (assertValueOneOf "Assign" boolValues) ]; + sectionIPv6AcceptRA = checkUnitConfig "IPv6AcceptRA" [ + (assertOnlyFields [ + "UseDNS" + "UseDomains" + "RouteTable" + "UseAutonomousPrefix" + "UseOnLinkPrefix" + "RouterDenyList" + "RouterAllowList" + "PrefixDenyList" + "PrefixAllowList" + "RouteDenyList" + "RouteAllowList" + "DHCPv6Client" + ]) + (assertValueOneOf "UseDNS" boolValues) + (assertValueOneOf "UseDomains" (boolValues ++ ["route"])) + (assertRange "RouteTable" 0 4294967295) + (assertValueOneOf "UseAutonomousPrefix" boolValues) + (assertValueOneOf "UseOnLinkPrefix" boolValues) + (assertValueOneOf "DHCPv6Client" (boolValues ++ ["always"])) + ]; + sectionDHCPServer = checkUnitConfig "DHCPServer" [ (assertOnlyFields [ "PoolOffset" @@ -1126,6 +1149,18 @@ let ''; }; + ipv6AcceptRAConfig = mkOption { + default = {}; + example = { UseDNS = true; DHCPv6Client = "always"; }; + type = types.addCheck (types.attrsOf unitOption) check.network.sectionIPv6AcceptRA; + description = '' + Each attribute in this set specifies an option in the + [IPv6AcceptRA] section of the unit. See + systemd.network + 5 for details. + ''; + }; + dhcpServerConfig = mkOption { default = {}; example = { PoolOffset = 50; EmitDNS = false; }; @@ -1497,6 +1532,10 @@ let [DHCPv6PrefixDelegation] ${attrsToSection def.dhcpV6PrefixDelegationConfig} '' + + optionalString (def.ipv6AcceptRAConfig != { }) '' + [IPv6AcceptRA] + ${attrsToSection def.ipv6AcceptRAConfig} + '' + optionalString (def.dhcpServerConfig != { }) '' [DHCPServer] ${attrsToSection def.dhcpServerConfig} From e6660ffe7ff0a516bf6347d01aca7231129c4c03 Mon Sep 17 00:00:00 2001 From: Vincent Haupert Date: Sat, 30 Jan 2021 12:33:14 +0100 Subject: [PATCH 05/70] nixos/networkd: rename ipv6PrefixDelegationConfig option to ipv6SendRAConfig networkd's [IPv6PrefixDelegation] section and IPv6PrefixDelegation= options have been renamed as [IPv6SendRA] and IPv6SendRA= in systemd 247. Throws if the deprecated option ipv6PrefixDelegationConfig is used. --- nixos/modules/system/boot/networkd.nix | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/nixos/modules/system/boot/networkd.nix b/nixos/modules/system/boot/networkd.nix index d439c602534..d9ae298490c 100644 --- a/nixos/modules/system/boot/networkd.nix +++ b/nixos/modules/system/boot/networkd.nix @@ -436,7 +436,7 @@ let "IPv4ProxyARP" "IPv6ProxyNDP" "IPv6ProxyNDPAddress" - "IPv6PrefixDelegation" + "IPv6SendRA" "DHCPv6PrefixDelegation" "IPv6MTUBytes" "Bridge" @@ -478,7 +478,7 @@ let (assertMinimum "IPv6HopLimit" 0) (assertValueOneOf "IPv4ProxyARP" boolValues) (assertValueOneOf "IPv6ProxyNDP" boolValues) - (assertValueOneOf "IPv6PrefixDelegation" ["static" "dhcpv6" "yes" "false"]) + (assertValueOneOf "IPv6SendRA" boolValues) (assertValueOneOf "DHCPv6PrefixDelegation" boolValues) (assertByteFormat "IPv6MTUBytes") (assertValueOneOf "ActiveSlave" boolValues) @@ -732,7 +732,7 @@ let (assertValueOneOf "EmitTimezone" boolValues) ]; - sectionIPv6PrefixDelegation = checkUnitConfig "IPv6PrefixDelegation" [ + sectionIPv6SendRA = checkUnitConfig "IPv6SendRA" [ (assertOnlyFields [ "Managed" "OtherInformation" @@ -1173,13 +1173,20 @@ let ''; }; + # systemd.network.networks.*.ipv6PrefixDelegationConfig has been deprecated + # in 247 in favor of systemd.network.networks.*.ipv6SendRAConfig. ipv6PrefixDelegationConfig = mkOption { + visible = false; + apply = _: throw "The option `systemd.network.networks.*.ipv6PrefixDelegationConfig` has been replaced by `systemd.network.networks.*.ipv6SendRAConfig`."; + }; + + ipv6SendRAConfig = mkOption { default = {}; example = { EmitDNS = true; Managed = true; OtherInformation = true; }; - type = types.addCheck (types.attrsOf unitOption) check.network.sectionIPv6PrefixDelegation; + type = types.addCheck (types.attrsOf unitOption) check.network.sectionIPv6SendRA; description = '' Each attribute in this set specifies an option in the - [IPv6PrefixDelegation] section of the unit. See + [IPv6SendRA] section of the unit. See systemd.network 5 for details. ''; @@ -1540,9 +1547,9 @@ let [DHCPServer] ${attrsToSection def.dhcpServerConfig} '' - + optionalString (def.ipv6PrefixDelegationConfig != { }) '' - [IPv6PrefixDelegation] - ${attrsToSection def.ipv6PrefixDelegationConfig} + + optionalString (def.ipv6SendRAConfig != { }) '' + [IPv6SendRA] + ${attrsToSection def.ipv6SendRAConfig} '' + flip concatMapStrings def.ipv6Prefixes (x: '' [IPv6Prefix] @@ -1558,7 +1565,6 @@ let in { - options = { systemd.network.enable = mkOption { From 730da50f8512f134d119a2fa4ca12e91bc38a338 Mon Sep 17 00:00:00 2001 From: Vincent Haupert Date: Sat, 30 Jan 2021 13:25:32 +0100 Subject: [PATCH 06/70] nixos/tests: adapt systemd-networkd-ipv6-prefix-delegation --- ...ystemd-networkd-ipv6-prefix-delegation.nix | 20 ++++++++----------- 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/nixos/tests/systemd-networkd-ipv6-prefix-delegation.nix b/nixos/tests/systemd-networkd-ipv6-prefix-delegation.nix index bce78f09fdc..5831c8692f6 100644 --- a/nixos/tests/systemd-networkd-ipv6-prefix-delegation.nix +++ b/nixos/tests/systemd-networkd-ipv6-prefix-delegation.nix @@ -165,7 +165,7 @@ import ./make-test-python.nix ({pkgs, ...}: { # accept the delegated prefix. PrefixDelegationHint = "::/48"; }; - ipv6PrefixDelegationConfig = { + ipv6SendRAConfig = { # Let networkd know that we would very much like to use DHCPv6 # to obtain the "managed" information. Not sure why they can't # just take that from the upstream RAs. @@ -179,24 +179,20 @@ import ./make-test-python.nix ({pkgs, ...}: { name = "eth2"; networkConfig = { Description = "Client interface"; - # the client shouldn't be allowed to send us RAs, that would be weird. + # The client shouldn't be allowed to send us RAs, that would be weird. IPv6AcceptRA = false; - # Just delegate prefixes from the DHCPv6 PD pool. - # If you also want to distribute a local ULA prefix you want to - # set this to `yes` as that includes both static prefixes as well - # as PD prefixes. - IPv6PrefixDelegation = "dhcpv6"; + # Delegate prefixes from the DHCPv6 PD pool. + DHCPv6PrefixDelegation = true; + IPv6SendRA = true; }; - # finally "act as router" (according to systemd.network(5)) - ipv6PrefixDelegationConfig = { - RouterLifetimeSec = 300; # required as otherwise no RA's are being emitted - # In a production environment you should consider setting these as well: + # In a production environment you should consider setting these as well: + # ipv6SendRAConfig = { #EmitDNS = true; #EmitDomains = true; #DNS= = "fe80::1"; # or whatever "well known" IP your router will have on the inside. - }; + # }; # This adds a "random" ULA prefix to the interface that is being # advertised to the clients. From 9ac395366bee383913c157911f76cbbbf09f226b Mon Sep 17 00:00:00 2001 From: Luke Granger-Brown Date: Sun, 14 Feb 2021 17:57:50 +0000 Subject: [PATCH 07/70] ceph: use bundled rocksdb Ceph have some custom patches to make RocksDB play nicely with Bluestore, which means the system RocksDB package doesn't quite work properly. --- pkgs/tools/filesystems/ceph/default.nix | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/pkgs/tools/filesystems/ceph/default.nix b/pkgs/tools/filesystems/ceph/default.nix index 61cc4573693..2d9ecfbcaa9 100644 --- a/pkgs/tools/filesystems/ceph/default.nix +++ b/pkgs/tools/filesystems/ceph/default.nix @@ -9,7 +9,7 @@ , babeltrace, gperf , gtest , cunit, snappy -, rocksdb, makeWrapper +, makeWrapper , leveldb, oathToolkit , libnl, libcap_ng , rdkafka @@ -146,7 +146,7 @@ in rec { buildInputs = cryptoLibsMap.${cryptoStr} ++ [ boost ceph-python-env libxml2 optYasm optLibatomic_ops optLibs3 malloc zlib openldap lttng-ust babeltrace gperf gtest cunit - snappy rocksdb lz4 oathToolkit leveldb libnl libcap_ng rdkafka + snappy lz4 oathToolkit leveldb libnl libcap_ng rdkafka ] ++ lib.optionals stdenv.isLinux [ linuxHeaders util-linux libuuid udev keyutils optLibaio optLibxfs optZfs # ceph 14 @@ -171,12 +171,10 @@ in rec { cmakeFlags = [ "-DWITH_PYTHON3=ON" - "-DWITH_SYSTEM_ROCKSDB=OFF" + "-DWITH_SYSTEM_ROCKSDB=OFF" # breaks Bluestore "-DCMAKE_INSTALL_DATADIR=${placeholder "lib"}/lib" - "-DWITH_SYSTEM_BOOST=ON" - "-DWITH_SYSTEM_ROCKSDB=ON" "-DWITH_SYSTEM_GTEST=ON" "-DMGR_PYTHON_VERSION=${ceph-python-env.python.pythonVersion}" "-DWITH_SYSTEMD=OFF" From bfc11c643d9e0bd2d79c5de86d0bddce589b56d0 Mon Sep 17 00:00:00 2001 From: Luke Granger-Brown Date: Sun, 14 Feb 2021 17:59:29 +0000 Subject: [PATCH 08/70] nixos/tests/ceph-single-node-bluestore: init The current Ceph tests use the old method for OSDs to store data on disks, known as Filestore. This means there are no tests for the Bluestore functionality that run on install, which means that things like RocksDB being broken can slip through and break the Bluestore functionality in a subtle and difficult to debug manner. Add a test to check that Bluestore works, at least on a single node. --- nixos/tests/all-tests.nix | 1 + nixos/tests/ceph-single-node-bluestore.nix | 196 +++++++++++++++++++++ 2 files changed, 197 insertions(+) create mode 100644 nixos/tests/ceph-single-node-bluestore.nix diff --git a/nixos/tests/all-tests.nix b/nixos/tests/all-tests.nix index 444580bc0be..530847575bc 100644 --- a/nixos/tests/all-tests.nix +++ b/nixos/tests/all-tests.nix @@ -55,6 +55,7 @@ in cassandra_3_11 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_11; }; ceph-multi-node = handleTestOn ["x86_64-linux"] ./ceph-multi-node.nix {}; ceph-single-node = handleTestOn ["x86_64-linux"] ./ceph-single-node.nix {}; + ceph-single-node-bluestore = handleTestOn ["x86_64-linux"] ./ceph-single-node-bluestore.nix {}; certmgr = handleTest ./certmgr.nix {}; cfssl = handleTestOn ["x86_64-linux"] ./cfssl.nix {}; charliecloud = handleTest ./charliecloud.nix {}; diff --git a/nixos/tests/ceph-single-node-bluestore.nix b/nixos/tests/ceph-single-node-bluestore.nix new file mode 100644 index 00000000000..cc873e8aee5 --- /dev/null +++ b/nixos/tests/ceph-single-node-bluestore.nix @@ -0,0 +1,196 @@ +import ./make-test-python.nix ({pkgs, lib, ...}: + +let + cfg = { + clusterId = "066ae264-2a5d-4729-8001-6ad265f50b03"; + monA = { + name = "a"; + ip = "192.168.1.1"; + }; + osd0 = { + name = "0"; + key = "AQBCEJNa3s8nHRAANvdsr93KqzBznuIWm2gOGg=="; + uuid = "55ba2294-3e24-478f-bee0-9dca4c231dd9"; + }; + osd1 = { + name = "1"; + key = "AQBEEJNac00kExAAXEgy943BGyOpVH1LLlHafQ=="; + uuid = "5e97a838-85b6-43b0-8950-cb56d554d1e5"; + }; + osd2 = { + name = "2"; + key = "AQAdyhZeIaUlARAAGRoidDAmS6Vkp546UFEf5w=="; + uuid = "ea999274-13d0-4dd5-9af9-ad25a324f72f"; + }; + }; + generateCephConfig = { daemonConfig }: { + enable = true; + global = { + fsid = cfg.clusterId; + monHost = cfg.monA.ip; + monInitialMembers = cfg.monA.name; + }; + } // daemonConfig; + + generateHost = { pkgs, cephConfig, networkConfig, ... }: { + virtualisation = { + memorySize = 512; + emptyDiskImages = [ 20480 20480 20480 ]; + vlans = [ 1 ]; + }; + + networking = networkConfig; + + environment.systemPackages = with pkgs; [ + bash + sudo + ceph + xfsprogs + ]; + + boot.kernelModules = [ "xfs" ]; + + services.ceph = cephConfig; + }; + + networkMonA = { + dhcpcd.enable = false; + interfaces.eth1.ipv4.addresses = pkgs.lib.mkOverride 0 [ + { address = cfg.monA.ip; prefixLength = 24; } + ]; + }; + cephConfigMonA = generateCephConfig { daemonConfig = { + mon = { + enable = true; + daemons = [ cfg.monA.name ]; + }; + mgr = { + enable = true; + daemons = [ cfg.monA.name ]; + }; + osd = { + enable = true; + daemons = [ cfg.osd0.name cfg.osd1.name cfg.osd2.name ]; + }; + }; }; + + # Following deployment is based on the manual deployment described here: + # https://docs.ceph.com/docs/master/install/manual-deployment/ + # For other ways to deploy a ceph cluster, look at the documentation at + # https://docs.ceph.com/docs/master/ + testscript = { ... }: '' + start_all() + + monA.wait_for_unit("network.target") + + # Bootstrap ceph-mon daemon + monA.succeed( + "sudo -u ceph ceph-authtool --create-keyring /tmp/ceph.mon.keyring --gen-key -n mon. --cap mon 'allow *'", + "sudo -u ceph ceph-authtool --create-keyring /etc/ceph/ceph.client.admin.keyring --gen-key -n client.admin --cap mon 'allow *' --cap osd 'allow *' --cap mds 'allow *' --cap mgr 'allow *'", + "sudo -u ceph ceph-authtool /tmp/ceph.mon.keyring --import-keyring /etc/ceph/ceph.client.admin.keyring", + "monmaptool --create --add ${cfg.monA.name} ${cfg.monA.ip} --fsid ${cfg.clusterId} /tmp/monmap", + "sudo -u ceph ceph-mon --mkfs -i ${cfg.monA.name} --monmap /tmp/monmap --keyring /tmp/ceph.mon.keyring", + "sudo -u ceph touch /var/lib/ceph/mon/ceph-${cfg.monA.name}/done", + "systemctl start ceph-mon-${cfg.monA.name}", + ) + monA.wait_for_unit("ceph-mon-${cfg.monA.name}") + monA.succeed("ceph mon enable-msgr2") + + # Can't check ceph status until a mon is up + monA.succeed("ceph -s | grep 'mon: 1 daemons'") + + # Start the ceph-mgr daemon, after copying in the keyring + monA.succeed( + "sudo -u ceph mkdir -p /var/lib/ceph/mgr/ceph-${cfg.monA.name}/", + "ceph auth get-or-create mgr.${cfg.monA.name} mon 'allow profile mgr' osd 'allow *' mds 'allow *' > /var/lib/ceph/mgr/ceph-${cfg.monA.name}/keyring", + "systemctl start ceph-mgr-${cfg.monA.name}", + ) + monA.wait_for_unit("ceph-mgr-a") + monA.wait_until_succeeds("ceph -s | grep 'quorum ${cfg.monA.name}'") + monA.wait_until_succeeds("ceph -s | grep 'mgr: ${cfg.monA.name}(active,'") + + # Bootstrap OSDs + monA.succeed( + "mkdir -p /var/lib/ceph/osd/ceph-${cfg.osd0.name}", + "echo bluestore > /var/lib/ceph/osd/ceph-${cfg.osd0.name}/type", + "ln -sf /dev/vdb /var/lib/ceph/osd/ceph-${cfg.osd0.name}/block", + "mkdir -p /var/lib/ceph/osd/ceph-${cfg.osd1.name}", + "echo bluestore > /var/lib/ceph/osd/ceph-${cfg.osd1.name}/type", + "ln -sf /dev/vdc /var/lib/ceph/osd/ceph-${cfg.osd1.name}/block", + "mkdir -p /var/lib/ceph/osd/ceph-${cfg.osd2.name}", + "echo bluestore > /var/lib/ceph/osd/ceph-${cfg.osd2.name}/type", + "ln -sf /dev/vdd /var/lib/ceph/osd/ceph-${cfg.osd2.name}/block", + "ceph-authtool --create-keyring /var/lib/ceph/osd/ceph-${cfg.osd0.name}/keyring --name osd.${cfg.osd0.name} --add-key ${cfg.osd0.key}", + "ceph-authtool --create-keyring /var/lib/ceph/osd/ceph-${cfg.osd1.name}/keyring --name osd.${cfg.osd1.name} --add-key ${cfg.osd1.key}", + "ceph-authtool --create-keyring /var/lib/ceph/osd/ceph-${cfg.osd2.name}/keyring --name osd.${cfg.osd2.name} --add-key ${cfg.osd2.key}", + 'echo \'{"cephx_secret": "${cfg.osd0.key}"}\' | ceph osd new ${cfg.osd0.uuid} -i -', + 'echo \'{"cephx_secret": "${cfg.osd1.key}"}\' | ceph osd new ${cfg.osd1.uuid} -i -', + 'echo \'{"cephx_secret": "${cfg.osd2.key}"}\' | ceph osd new ${cfg.osd2.uuid} -i -', + ) + + # Initialize the OSDs with regular filestore + monA.succeed( + "ceph-osd -i ${cfg.osd0.name} --mkfs --osd-uuid ${cfg.osd0.uuid}", + "ceph-osd -i ${cfg.osd1.name} --mkfs --osd-uuid ${cfg.osd1.uuid}", + "ceph-osd -i ${cfg.osd2.name} --mkfs --osd-uuid ${cfg.osd2.uuid}", + "chown -R ceph:ceph /var/lib/ceph/osd", + "systemctl start ceph-osd-${cfg.osd0.name}", + "systemctl start ceph-osd-${cfg.osd1.name}", + "systemctl start ceph-osd-${cfg.osd2.name}", + ) + monA.wait_until_succeeds("ceph osd stat | grep -e '3 osds: 3 up[^,]*, 3 in'") + monA.wait_until_succeeds("ceph -s | grep 'mgr: ${cfg.monA.name}(active,'") + monA.wait_until_succeeds("ceph -s | grep 'HEALTH_OK'") + + monA.succeed( + "ceph osd pool create single-node-test 32 32", + "ceph osd pool ls | grep 'single-node-test'", + "ceph osd pool rename single-node-test single-node-other-test", + "ceph osd pool ls | grep 'single-node-other-test'", + ) + monA.wait_until_succeeds("ceph -s | grep '2 pools, 33 pgs'") + monA.succeed( + "ceph osd getcrushmap -o crush", + "crushtool -d crush -o decrushed", + "sed 's/step chooseleaf firstn 0 type host/step chooseleaf firstn 0 type osd/' decrushed > modcrush", + "crushtool -c modcrush -o recrushed", + "ceph osd setcrushmap -i recrushed", + "ceph osd pool set single-node-other-test size 2", + ) + monA.wait_until_succeeds("ceph -s | grep 'HEALTH_OK'") + monA.wait_until_succeeds("ceph -s | grep '33 active+clean'") + monA.fail( + "ceph osd pool ls | grep 'multi-node-test'", + "ceph osd pool delete single-node-other-test single-node-other-test --yes-i-really-really-mean-it", + ) + + # Shut down ceph by stopping ceph.target. + monA.succeed("systemctl stop ceph.target") + + # Start it up + monA.succeed("systemctl start ceph.target") + monA.wait_for_unit("ceph-mon-${cfg.monA.name}") + monA.wait_for_unit("ceph-mgr-${cfg.monA.name}") + monA.wait_for_unit("ceph-osd-${cfg.osd0.name}") + monA.wait_for_unit("ceph-osd-${cfg.osd1.name}") + monA.wait_for_unit("ceph-osd-${cfg.osd2.name}") + + # Ensure the cluster comes back up again + monA.succeed("ceph -s | grep 'mon: 1 daemons'") + monA.wait_until_succeeds("ceph -s | grep 'quorum ${cfg.monA.name}'") + monA.wait_until_succeeds("ceph osd stat | grep -e '3 osds: 3 up[^,]*, 3 in'") + monA.wait_until_succeeds("ceph -s | grep 'mgr: ${cfg.monA.name}(active,'") + monA.wait_until_succeeds("ceph -s | grep 'HEALTH_OK'") + ''; +in { + name = "basic-single-node-ceph-cluster-bluestore"; + meta = with pkgs.lib.maintainers; { + maintainers = [ lukegb ]; + }; + + nodes = { + monA = generateHost { pkgs = pkgs; cephConfig = cephConfigMonA; networkConfig = networkMonA; }; + }; + + testScript = testscript; +}) From 236df9cee7b22e37ce2e98a3ede370abc145dfea Mon Sep 17 00:00:00 2001 From: Luke Granger-Brown Date: Sun, 14 Feb 2021 18:01:16 +0000 Subject: [PATCH 09/70] ceph: add passthru.tests --- pkgs/tools/filesystems/ceph/default.nix | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pkgs/tools/filesystems/ceph/default.nix b/pkgs/tools/filesystems/ceph/default.nix index 2d9ecfbcaa9..aaa5806d402 100644 --- a/pkgs/tools/filesystems/ceph/default.nix +++ b/pkgs/tools/filesystems/ceph/default.nix @@ -13,6 +13,7 @@ , leveldb, oathToolkit , libnl, libcap_ng , rdkafka +, nixosTests # Optional Dependencies , yasm ? null, fcgi ? null, expat ? null @@ -199,6 +200,7 @@ in rec { meta = getMeta "Distributed storage system"; passthru.version = version; + passthru.tests = { inherit (nixosTests) ceph-single-node ceph-multi-node ceph-single-node-bluestore; }; }; ceph-client = runCommand "ceph-client-${version}" { From 373c6ad893d49a3b1aeb6ae9604a216478e72a99 Mon Sep 17 00:00:00 2001 From: sohalt Date: Wed, 18 Dec 2019 12:29:52 +0100 Subject: [PATCH 10/70] libspnav: init at 0.2.3 --- .../libspnav/configure-socket-path.patch | 47 +++++++++++++++++++ .../libraries/libspnav/default.nix | 36 ++++++++++++++ pkgs/top-level/all-packages.nix | 2 + 3 files changed, 85 insertions(+) create mode 100644 pkgs/development/libraries/libspnav/configure-socket-path.patch create mode 100644 pkgs/development/libraries/libspnav/default.nix diff --git a/pkgs/development/libraries/libspnav/configure-socket-path.patch b/pkgs/development/libraries/libspnav/configure-socket-path.patch new file mode 100644 index 00000000000..2c315067f41 --- /dev/null +++ b/pkgs/development/libraries/libspnav/configure-socket-path.patch @@ -0,0 +1,47 @@ +diff --git a/spnav.c b/spnav.c +index f9e10f8..27149f7 100644 +--- a/spnav.c ++++ b/spnav.c +@@ -36,7 +36,7 @@ OF SUCH DAMAGE. + #include + #include "spnav.h" + +-#define SPNAV_SOCK_PATH "/var/run/spnav.sock" ++#define DEFAULT_SPNAV_SOCK_PATH "/run/spnav.sock" + + #ifdef USE_X11 + #include +@@ -70,6 +70,24 @@ static struct event_node *ev_queue, *ev_queue_tail; + /* AF_UNIX socket used for alternative communication with daemon */ + static int sock = -1; + ++static char *spath = NULL; ++ ++static char *socket_path() ++{ ++ char *xdg_runtime_dir; ++ if((xdg_runtime_dir = getenv("XDG_RUNTIME_DIR"))) { ++ if ( spath == NULL ) { ++ spath = malloc(strlen(xdg_runtime_dir) + strlen("/spnav.sock") + 1); ++ if ( spath != NULL ) { ++ sprintf(spath, sizeof(spath), "%s/spnav.sock", xdg_runtime_dir); ++ } ++ } ++ if(access(spath, F_OK)){ ++ return spath; ++ } ++ } ++ return DEFAULT_SPNAV_SOCK_PATH; ++} + + int spnav_open(void) + { +@@ -92,7 +110,7 @@ int spnav_open(void) + + memset(&addr, 0, sizeof addr); + addr.sun_family = AF_UNIX; +- strncpy(addr.sun_path, SPNAV_SOCK_PATH, sizeof(addr.sun_path)); ++ strncpy(addr.sun_path, socket_path(), sizeof(addr.sun_path)); + + + if(connect(s, (struct sockaddr*)&addr, sizeof addr) == -1) { diff --git a/pkgs/development/libraries/libspnav/default.nix b/pkgs/development/libraries/libspnav/default.nix new file mode 100644 index 00000000000..9bd0a67041b --- /dev/null +++ b/pkgs/development/libraries/libspnav/default.nix @@ -0,0 +1,36 @@ +{ stdenv, lib, fetchFromGitHub, libX11}: + +stdenv.mkDerivation rec { + version = "0.2.3"; + pname = "libspnav"; + + src = fetchFromGitHub { + owner = "FreeSpacenav"; + repo = "libspnav"; + rev = "${pname}-${version}"; + sha256 = "098h1jhlj87axpza5zgy58prp0zn94wyrbch6x0s7q4mzh7dc8ba"; + }; + + buildInputs = [ libX11 ]; + + patches = [ + # Changes the socket path from /run/spnav.sock to $XDG_RUNTIME_DIR/spnav.sock + # to allow for a user service + ./configure-socket-path.patch + ]; + + configureFlags = [ "--disable-debug"]; + + preInstall = '' + mkdir -p $out/{lib,include} + ''; + + meta = with lib; { + homepage = "http://spacenav.sourceforge.net/"; + description = "Device driver and SDK for 3Dconnexion 3D input devices"; + longDescription = "A free, compatible alternative, to the proprietary 3Dconnexion device driver and SDK, for their 3D input devices (called 'space navigator', 'space pilot', 'space traveller', etc)"; + license = licenses.bsd3; + platforms = platforms.unix; + maintainers = with maintainers; [ sohalt ]; + }; +} diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 04fb6805e96..d2fe01436fa 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -15061,6 +15061,8 @@ in libspectre = callPackage ../development/libraries/libspectre { }; + libspnav = callPackage ../development/libraries/libspnav { }; + libgsf = callPackage ../development/libraries/libgsf { }; # GNU libc provides libiconv so systems with glibc don't need to build From 4f19003feccd8fa83c52eae915c4bdf2cc3816cd Mon Sep 17 00:00:00 2001 From: sohalt Date: Wed, 18 Dec 2019 12:31:47 +0100 Subject: [PATCH 11/70] spacenavd: init at 0.8 --- .../spacenavd/configure-socket-path.patch | 118 ++++++++++++++++++ pkgs/misc/drivers/spacenavd/default.nix | 32 +++++ pkgs/top-level/all-packages.nix | 2 + 3 files changed, 152 insertions(+) create mode 100644 pkgs/misc/drivers/spacenavd/configure-socket-path.patch create mode 100644 pkgs/misc/drivers/spacenavd/default.nix diff --git a/pkgs/misc/drivers/spacenavd/configure-socket-path.patch b/pkgs/misc/drivers/spacenavd/configure-socket-path.patch new file mode 100644 index 00000000000..03eb329f4b6 --- /dev/null +++ b/pkgs/misc/drivers/spacenavd/configure-socket-path.patch @@ -0,0 +1,118 @@ +diff --git a/src/proto_unix.c b/src/proto_unix.c +index 998f234..d38452c 100644 +--- a/src/proto_unix.c ++++ b/src/proto_unix.c +@@ -36,11 +36,14 @@ enum { + + static int lsock = -1; + ++static char *spath = NULL; ++ + int init_unix(void) + { + int s; + mode_t prev_umask; + struct sockaddr_un addr; ++ char *sock_path; + + if(lsock >= 0) return 0; + +@@ -49,16 +52,18 @@ int init_unix(void) + return -1; + } + +- unlink(SOCK_NAME); /* in case it already exists */ ++ sock_path = socket_path(); ++ ++ unlink(sock_path); /* in case it already exists */ + + memset(&addr, 0, sizeof addr); + addr.sun_family = AF_UNIX; +- strcpy(addr.sun_path, SOCK_NAME); ++ strcpy(addr.sun_path, sock_path); + + prev_umask = umask(0); + + if(bind(s, (struct sockaddr*)&addr, sizeof addr) == -1) { +- logmsg(LOG_ERR, "failed to bind unix socket: %s: %s\n", SOCK_NAME, strerror(errno)); ++ logmsg(LOG_ERR, "failed to bind unix socket: %s: %s\n", sock_path, strerror(errno)); + close(s); + return -1; + } +@@ -68,7 +73,7 @@ int init_unix(void) + if(listen(s, 8) == -1) { + logmsg(LOG_ERR, "listen failed: %s\n", strerror(errno)); + close(s); +- unlink(SOCK_NAME); ++ unlink(sock_path); + return -1; + } + +@@ -82,7 +87,7 @@ void close_unix(void) + close(lsock); + lsock = -1; + +- unlink(SOCK_NAME); ++ unlink(socket_path()); + } + } + +@@ -173,3 +178,19 @@ int handle_uevents(fd_set *rset) + + return 0; + } ++ ++char *socket_path(void) ++{ ++ char *xdg_runtime_dir; ++ if((xdg_runtime_dir = getenv("XDG_RUNTIME_DIR"))) { ++ if ( spath == NULL ) { ++ spath = malloc(strlen(xdg_runtime_dir) + strlen("/spnav.sock") + 1); ++ if ( spath != NULL ) { ++ sprintf(spath, "%s/spnav.sock", xdg_runtime_dir); ++ } ++ }; ++ return spath; ++ } else { ++ return DEFAULT_SOCK_NAME; ++ } ++} +diff --git a/src/proto_unix.h b/src/proto_unix.h +index 045b379..ec4509c 100644 +--- a/src/proto_unix.h ++++ b/src/proto_unix.h +@@ -23,6 +23,7 @@ along with this program. If not, see . + #include "event.h" + #include "client.h" + ++char *socket_path(void); + int init_unix(void); + void close_unix(void); + int get_unix_socket(void); +diff --git a/src/spnavd.c b/src/spnavd.c +index cbea191..03080da 100644 +--- a/src/spnavd.c ++++ b/src/spnavd.c +@@ -344,7 +344,7 @@ static int find_running_daemon(void) + } + memset(&addr, 0, sizeof addr); + addr.sun_family = AF_UNIX; +- strncpy(addr.sun_path, SOCK_NAME, sizeof addr.sun_path); ++ strncpy(addr.sun_path, socket_path(), sizeof addr.sun_path); + + if(connect(s, (struct sockaddr*)&addr, sizeof addr) == -1) { + close(s); +diff --git a/src/spnavd.h b/src/spnavd.h +index fa0a916..deea4e0 100644 +--- a/src/spnavd.h ++++ b/src/spnavd.h +@@ -26,7 +26,8 @@ along with this program. If not, see . + #define DEF_CFGFILE "/etc/spnavrc" + #define DEF_LOGFILE "/var/log/spnavd.log" + +-#define SOCK_NAME "/var/run/spnav.sock" ++#define DEFAULT_SOCK_NAME "/run/spnav.sock" ++#define SOCK_NAME_ENV "SPNAVD_SOCK_LOCATION" + #define PIDFILE "/var/run/spnavd.pid" + #define SYSLOG_ID "spnavd" + diff --git a/pkgs/misc/drivers/spacenavd/default.nix b/pkgs/misc/drivers/spacenavd/default.nix new file mode 100644 index 00000000000..1051d469f61 --- /dev/null +++ b/pkgs/misc/drivers/spacenavd/default.nix @@ -0,0 +1,32 @@ +{ stdenv, lib, fetchFromGitHub, libX11 }: + +stdenv.mkDerivation rec { + version = "0.8"; + pname = "spacenavd"; + + src = fetchFromGitHub { + owner = "FreeSpacenav"; + repo = "spacenavd"; + rev = "v${version}"; + sha256 = "1zz0cm5cgvp9s5n4nzksl8rb11c7sw214bdafzra74smvqfjcjcf"; + }; + + buildInputs = [ libX11 ]; + + patches = [ + # Changes the socket path from /run/spnav.sock to $XDG_RUNTIME_DIR/spnav.sock + # to allow for a user service + ./configure-socket-path.patch + ]; + + configureFlags = [ "--disable-debug"]; + + meta = with lib; { + homepage = "http://spacenav.sourceforge.net/"; + description = "Device driver and SDK for 3Dconnexion 3D input devices"; + longDescription = "A free, compatible alternative, to the proprietary 3Dconnexion device driver and SDK, for their 3D input devices (called 'space navigator', 'space pilot', 'space traveller', etc)"; + license = licenses.gpl3Plus; + platforms = platforms.unix; + maintainers = with maintainers; [ sohalt ]; + }; +} diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index d2fe01436fa..77a7396078c 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -29224,6 +29224,8 @@ in hasktags = haskellPackages.hasktags; }; + spacenavd = callPackage ../misc/drivers/spacenavd { }; + splix = callPackage ../misc/cups/drivers/splix { }; steamcontroller = callPackage ../misc/drivers/steamcontroller { }; From 725966b870d983b59af74246a7a6d03a12aa8923 Mon Sep 17 00:00:00 2001 From: sohalt Date: Wed, 18 Dec 2019 12:32:35 +0100 Subject: [PATCH 12/70] nixos/spacenavd: init --- nixos/modules/module-list.nix | 1 + nixos/modules/services/hardware/spacenavd.nix | 26 +++++++++++++++++++ 2 files changed, 27 insertions(+) create mode 100644 nixos/modules/services/hardware/spacenavd.nix diff --git a/nixos/modules/module-list.nix b/nixos/modules/module-list.nix index 0d26b7300d0..1d0312061df 100644 --- a/nixos/modules/module-list.nix +++ b/nixos/modules/module-list.nix @@ -377,6 +377,7 @@ ./services/hardware/sane.nix ./services/hardware/sane_extra_backends/brscan4.nix ./services/hardware/sane_extra_backends/dsseries.nix + ./services/hardware/spacenavd.nix ./services/hardware/tcsd.nix ./services/hardware/tlp.nix ./services/hardware/thinkfan.nix diff --git a/nixos/modules/services/hardware/spacenavd.nix b/nixos/modules/services/hardware/spacenavd.nix new file mode 100644 index 00000000000..7afae76cc4f --- /dev/null +++ b/nixos/modules/services/hardware/spacenavd.nix @@ -0,0 +1,26 @@ +{ config, lib, pkgs, ... }: + +with lib; + +let cfg = config.hardware.spacenavd; + +in { + + options = { + hardware.spacenavd = { + enable = mkEnableOption "spacenavd to support 3DConnexion devices"; + }; + }; + + config = mkIf cfg.enable { + systemd.user.services.spacenavd = { + description = "Daemon for the Spacenavigator 6DOF mice by 3Dconnexion"; + after = [ "syslog.target" ]; + wantedBy = [ "graphical.target" ]; + serviceConfig = { + ExecStart = "${pkgs.spacenavd}/bin/spacenavd -d -l syslog"; + StandardError = "syslog"; + }; + }; + }; +} From ea15465201a395d73e2ce670fd4fac0b8db7a739 Mon Sep 17 00:00:00 2001 From: sohalt Date: Wed, 18 Dec 2019 12:38:04 +0100 Subject: [PATCH 13/70] spacenav-cube-example: init at 2.3.0 --- .../misc/spacenav-cube-example/default.nix | 29 +++++++++++++++++++ pkgs/top-level/all-packages.nix | 2 ++ 2 files changed, 31 insertions(+) create mode 100644 pkgs/applications/misc/spacenav-cube-example/default.nix diff --git a/pkgs/applications/misc/spacenav-cube-example/default.nix b/pkgs/applications/misc/spacenav-cube-example/default.nix new file mode 100644 index 00000000000..1221db1ad96 --- /dev/null +++ b/pkgs/applications/misc/spacenav-cube-example/default.nix @@ -0,0 +1,29 @@ +{ stdenv, lib, libspnav, libX11, mesa_glu }: + +stdenv.mkDerivation { + pname = "spacenav-cube-example"; + version = libspnav.version; + + src = libspnav.src; + + sourceRoot = "source/examples/cube"; + + buildInputs = [ libX11 mesa_glu libspnav ]; + + configureFlags = [ "--disable-debug" ]; + + installPhase = '' + runHook preInstall + mkdir -p $out/bin + cp cube $out/bin/spacenav-cube-example + runHook postInstall + ''; + + meta = with lib; { + homepage = "http://spacenav.sourceforge.net/"; + description = "An example application to test the spacenavd driver"; + license = licenses.bsd3; + platforms = platforms.unix; + maintainers = with maintainers; [ sohalt ]; + }; +} diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 77a7396078c..d7826ba7442 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -29226,6 +29226,8 @@ in spacenavd = callPackage ../misc/drivers/spacenavd { }; + spacenav-cube-example = callPackage ../applications/misc/spacenav-cube-example { }; + splix = callPackage ../misc/cups/drivers/splix { }; steamcontroller = callPackage ../misc/drivers/steamcontroller { }; From e7933ddd87cfa7387d306ce74f57db5242abb8cc Mon Sep 17 00:00:00 2001 From: sohalt Date: Wed, 18 Dec 2019 12:39:49 +0100 Subject: [PATCH 14/70] blender: support for libspnav --- pkgs/applications/misc/blender/default.nix | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pkgs/applications/misc/blender/default.nix b/pkgs/applications/misc/blender/default.nix index 9921fdc7a79..039dfe59ff7 100644 --- a/pkgs/applications/misc/blender/default.nix +++ b/pkgs/applications/misc/blender/default.nix @@ -7,6 +7,7 @@ , jackaudioSupport ? false, libjack2 , cudaSupport ? config.cudaSupport or false, cudatoolkit , colladaSupport ? true, opencollada +, spaceNavSupport ? false, libspnav , makeWrapper , pugixml, llvmPackages, SDL, Cocoa, CoreGraphics, ForceFeedback, OpenAL, OpenGL , embree, gmp @@ -56,7 +57,8 @@ stdenv.mkDerivation rec { ]) ++ optional jackaudioSupport libjack2 ++ optional cudaSupport cudatoolkit - ++ optional colladaSupport opencollada; + ++ optional colladaSupport opencollada + ++ optional spaceNavSupport libspnav; postPatch = '' # allow usage of dynamically linked embree From c6a5c7ac58ccbf228a656b1eb8087e5821b9383b Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Sun, 21 Feb 2021 02:30:30 +0100 Subject: [PATCH 15/70] hackage-packages.nix: automatic Haskell package set update This update was generated by hackage2nix v2.16.0-13-gefcfbb2 from Hackage revision https://github.com/commercialhaskell/all-cabal-hashes/commit/80305babfb44f4e7222f92b9693296e10dbb00c3. --- .../haskell-modules/hackage-packages.nix | 379 +++++++++++++++--- 1 file changed, 315 insertions(+), 64 deletions(-) diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index b4fcf554bbf..76ed05a480f 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -15016,6 +15016,8 @@ self: { pname = "OneTuple"; version = "0.2.2.1"; sha256 = "15ls6kkf953288q7rsc49bvw467ll4nq28hvsgbaazdn7hf75ixc"; + revision = "1"; + editedCabalFile = "03mygfz7lv6h0i30bq2grvmahbg9j7a36mc0wls2nr81dv9p19s7"; libraryHaskellDepends = [ base ]; description = "Singleton Tuple"; license = lib.licenses.bsd3; @@ -21961,8 +21963,8 @@ self: { }: mkDerivation { pname = "Z-Data"; - version = "0.6.0.0"; - sha256 = "16wb7hrk6rlxl0sks5nkhl60wxwlxdyjwj9j72g40l5x6qnlvk7d"; + version = "0.6.1.0"; + sha256 = "096zzi2fb6pj310bkihsidwaail9hi78mpfplg4c8skq4157ps6s"; setupHaskellDepends = [ base Cabal ]; libraryHaskellDepends = [ base bytestring case-insensitive containers deepseq ghc-prim @@ -21983,18 +21985,18 @@ self: { "Z-IO" = callPackage ({ mkDerivation, base, bytestring, containers, exceptions, hashable - , hspec, hspec-discover, HUnit, microlens, primitive, QuickCheck + , hspec, hspec-discover, HUnit, primitive, QuickCheck , quickcheck-instances, scientific, stm, time, unix-time , unordered-containers, Z-Data, zlib }: mkDerivation { pname = "Z-IO"; - version = "0.6.2.0"; - sha256 = "0d004yi1i45ccqhl4vqw6h4qxav693vas359gs76bz04wdbqgrah"; + version = "0.6.3.0"; + sha256 = "12xy3dvd3yvln2z2dzkwqazzlyxb70ksrmzl6rhvmlx32j7djlvi"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - base containers exceptions microlens primitive stm time unix-time + base containers exceptions primitive stm time unix-time unordered-containers Z-Data ]; libraryToolDepends = [ hspec-discover ]; @@ -40481,6 +40483,8 @@ self: { pname = "binary-instances"; version = "1.0.1"; sha256 = "0whqjziwqrqslf6byliry84pg47z7vc6yjligpzb8gb5db2gw1h0"; + revision = "1"; + editedCabalFile = "1xw2rl5mk626i54c0azrw5as3avd2cvzxn8l6sg5ymc14c240iwp"; libraryHaskellDepends = [ aeson base binary binary-orphans case-insensitive hashable scientific tagged text text-binary time-compat unordered-containers @@ -48757,23 +48761,22 @@ self: { ({ mkDerivation, array, async, base, base16-bytestring, binary , bytestring, Cabal, containers, cryptohash-sha256, deepseq , directory, echo, edit-distance, filepath, hackage-security - , hashable, HTTP, lukko, mtl, network, network-uri, parsec, pretty - , process, random, resolv, stm, tar, text, time, transformers, unix - , zlib + , hashable, HTTP, lukko, mtl, network-uri, parsec, pretty, process + , random, regex-base, regex-posix, resolv, stm, tar, text, time + , transformers, unix, zlib }: mkDerivation { pname = "cabal-install"; - version = "3.2.0.0"; - sha256 = "1c0cc256bha97aj7l0lf76l5swlnmwcqppiz8l4cl5xgba4mwmd0"; + version = "3.4.0.0"; + sha256 = "15rylx5pa03jdiwcg1x7zvs6aq3g6phwmi1hz26cl080nczyz00r"; isLibrary = false; isExecutable = true; - setupHaskellDepends = [ base Cabal filepath process ]; executableHaskellDepends = [ array async base base16-bytestring binary bytestring Cabal containers cryptohash-sha256 deepseq directory echo edit-distance - filepath hackage-security hashable HTTP lukko mtl network - network-uri parsec pretty process random resolv stm tar text time - transformers unix zlib + filepath hackage-security hashable HTTP lukko mtl network-uri + parsec pretty process random regex-base regex-posix resolv stm tar + text time transformers unix zlib ]; doCheck = false; postInstall = '' @@ -71777,6 +71780,18 @@ self: { license = lib.licenses.bsd3; }) {}; + "dec_0_0_4" = callPackage + ({ mkDerivation, base }: + mkDerivation { + pname = "dec"; + version = "0.0.4"; + sha256 = "0yslffafmqfkvhcw2arpc53hfmn1788z85ss9lxnbclr29lbvzgc"; + libraryHaskellDepends = [ base ]; + description = "Decidable propositions"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "decepticons" = callPackage ({ mkDerivation, base, comonad-transformers }: mkDerivation { @@ -73121,6 +73136,19 @@ self: { license = lib.licenses.bsd3; }) {}; + "deriving-aeson_0_2_6_1" = callPackage + ({ mkDerivation, aeson, base, bytestring }: + mkDerivation { + pname = "deriving-aeson"; + version = "0.2.6.1"; + sha256 = "014f3jsaiwqkz2l0jap8shwq3rdn1hq14ahmq0hm3l4c98vznjra"; + libraryHaskellDepends = [ aeson base ]; + testHaskellDepends = [ aeson base bytestring ]; + description = "Type driven generic aeson instance customisation"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "deriving-compat" = callPackage ({ mkDerivation, base, base-compat, base-orphans, containers , ghc-boot-th, ghc-prim, hspec, hspec-discover, QuickCheck, tagged @@ -75991,6 +76019,8 @@ self: { pname = "directory"; version = "1.3.6.1"; sha256 = "00cr2sshzjmn57rpvjj8wvgr60x2mk8c7w1nd40wxqs8s9xaa1bi"; + revision = "1"; + editedCabalFile = "1rf2w9gx0vy74mgsf5q1y82bhm5ngb9mi0i2v2h6ss9gscyvgb7j"; libraryHaskellDepends = [ base filepath time unix ]; testHaskellDepends = [ base filepath time unix ]; description = "Platform-agnostic library for filesystem operations"; @@ -77532,8 +77562,8 @@ self: { pname = "dlist-nonempty"; version = "0.1.1"; sha256 = "0csbspdy43pzvasb5mhs5pz2f49ws78pi253cx7pp84wjx6ads20"; - revision = "9"; - editedCabalFile = "09qgsqzjnkr5d2lwdz86q3zrikd5hacd62hvvfdqy39kh5wrqn4y"; + revision = "10"; + editedCabalFile = "0k9h3d93ivjykdpblkdcxyv1aybbjq6m5laqjh7bdv6nrdr5va2c"; libraryHaskellDepends = [ base base-compat deepseq dlist semigroupoids ]; @@ -79393,9 +79423,12 @@ self: { ({ mkDerivation, base, criterion, ki, transformers, unagi-chan }: mkDerivation { pname = "drama"; - version = "0.1.0.1"; - sha256 = "0ssmw1yci4369hvpdc5f4ng6s4m7m2lgn9sp6jbgj90izwg0px8w"; + version = "0.2.0.0"; + sha256 = "00blv7fi0ibvjc2qqn30ybhsshbzsdpkjp32fhg1m7h7wvlzi312"; + isLibrary = true; + isExecutable = true; libraryHaskellDepends = [ base ki transformers unagi-chan ]; + executableHaskellDepends = [ base ]; benchmarkHaskellDepends = [ base criterion ]; description = "Simple actor library for Haskell"; license = lib.licenses.bsd3; @@ -87949,8 +87982,8 @@ self: { }: mkDerivation { pname = "extensible"; - version = "0.8.1"; - sha256 = "189svxwh54zzczrrirlnfyqmv2f12h8qxw9rqq47mn55ch40xnw3"; + version = "0.8.2"; + sha256 = "133yid7snb48n4rn15p6nsk2h1shbiw647d5fvapn3lnsb4ymqgv"; libraryHaskellDepends = [ aeson base bytestring cassava comonad constraints deepseq ghc-prim hashable incremental membership monad-skeleton prettyprinter @@ -127431,7 +127464,7 @@ self: { license = lib.licenses.bsd3; }) {}; - "hie-bios_0_7_3" = callPackage + "hie-bios_0_7_4" = callPackage ({ mkDerivation, aeson, base, base16-bytestring, bytestring , conduit, conduit-extra, containers, cryptohash-sha1, deepseq , directory, extra, file-embed, filepath, ghc, hslogger @@ -127441,8 +127474,8 @@ self: { }: mkDerivation { pname = "hie-bios"; - version = "0.7.3"; - sha256 = "0njgxy8dx43smqk4wv3zg0c8a7llbgnz4fbil9dw53yx2xncgapi"; + version = "0.7.4"; + sha256 = "05ad47ll6vxi7say4f7zf13npcjpqbwb42pqs2bmxslif6rl9sdh"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -129050,8 +129083,8 @@ self: { pname = "hkd"; version = "0.1"; sha256 = "1xz0i8lkh0rp55b0s7npkzqgyz9pf1bwq9b66cwbg073r9sz41wa"; - revision = "1"; - editedCabalFile = "09inakgqdwqifha2whvjfx6imx642zfinw8faxgjiv55ncm04zhr"; + revision = "2"; + editedCabalFile = "19z00b29z095fp9jxp0n7k1dgm980j9i94aysqd0mm1yjvxvn1k5"; libraryHaskellDepends = [ base some ]; testHaskellDepends = [ base some ]; description = "\"higher-kinded data\""; @@ -130836,6 +130869,8 @@ self: { pname = "hnix"; version = "0.12.0.1"; sha256 = "013jlmzzr5fcvl0w9rrvhsg8jikg0hbc8z57yzxgz109x7hrnjzc"; + revision = "1"; + editedCabalFile = "136lwfb5hjwdbfik5c5dw1nhsmy8v410czmjn4i242s8jv5wm9yb"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -139467,6 +139502,8 @@ self: { pname = "http-api-data"; version = "0.4.3"; sha256 = "171bw2a44pg50d3y77gw2y9vmx72laky7hnn5hw6r93pnjmlf9yz"; + revision = "1"; + editedCabalFile = "0vy4glhjc036m2lmkc1ls0s48pcxga2qqc1jbpj4139v9j8h158m"; libraryHaskellDepends = [ attoparsec attoparsec-iso8601 base base-compat bytestring containers cookie hashable http-types tagged text time-compat @@ -146889,6 +146926,34 @@ self: { license = lib.licenses.bsd3; }) {}; + "influxdb_1_9_1" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal + , cabal-doctest, clock, containers, doctest, foldl, http-client + , http-types, lens, network, optional-args, raw-strings-qq + , scientific, tagged, tasty, tasty-hunit, template-haskell, text + , time, unordered-containers, vector + }: + mkDerivation { + pname = "influxdb"; + version = "1.9.1"; + sha256 = "1g8lj56xi61g0vfindiz4lmnypjh2bzp2nm92dmh2d4mlfhrh78y"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + aeson attoparsec base bytestring clock containers foldl http-client + http-types lens network optional-args scientific tagged text time + unordered-containers vector + ]; + testHaskellDepends = [ + base containers doctest lens raw-strings-qq tasty tasty-hunit + template-haskell time vector + ]; + description = "InfluxDB client library for Haskell"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "informative" = callPackage ({ mkDerivation, base, containers, csv, highlighting-kate , http-conduit, monad-logger, pandoc, persistent @@ -148442,6 +148507,32 @@ self: { license = lib.licenses.bsd2; }) {}; + "inventory" = callPackage + ({ mkDerivation, appendmap, base, bytestring, containers, directory + , filepath, ghc, ghc-paths, mtl, tasty, tasty-hunit + }: + mkDerivation { + pname = "inventory"; + version = "0.1.0.0"; + sha256 = "0nflfrs9qb2bfkpi07r2a5k6lkyyspvfqz18pfvqa2rkpfcqw9bd"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + appendmap base bytestring containers directory filepath ghc + ghc-paths mtl + ]; + executableHaskellDepends = [ + appendmap base bytestring containers directory filepath ghc + ghc-paths mtl + ]; + testHaskellDepends = [ + appendmap base bytestring containers directory filepath ghc + ghc-paths mtl tasty tasty-hunit + ]; + description = "Project statistics and definition analysis"; + license = lib.licenses.bsd3; + }) {}; + "invert" = callPackage ({ mkDerivation, base, containers, criterion, generic-deriving , hashable, unordered-containers, vector @@ -159125,8 +159216,8 @@ self: { pname = "lattices"; version = "2.0.2"; sha256 = "108rhpax72j6xdl0yqdmg7n32l1j805861f3q9wd3jh8nc67avix"; - revision = "2"; - editedCabalFile = "122mrj3b15jv1bjmzc8k37dkc2gy05hg550gia09n7j7n76v0h7i"; + revision = "3"; + editedCabalFile = "1n1sv7477v88ibcwb5rh4p1r9r4hj0jj7s0vh6r0y2w4hbhpslvr"; libraryHaskellDepends = [ base base-compat containers deepseq hashable integer-logarithms QuickCheck semigroupoids tagged transformers universe-base @@ -167599,6 +167690,8 @@ self: { pname = "lukko"; version = "0.1.1.3"; sha256 = "07xb926kixqv5scqdl8w34z42zjzdpbq06f0ha3f3nm3rxhgn3m8"; + revision = "1"; + editedCabalFile = "0mmq1q82mrbayiij0p8wdnkf0j8drmq1iibg8kn4cak3nrn9pd1d"; libraryHaskellDepends = [ base ]; testHaskellDepends = [ async base bytestring filepath singleton-bool tasty @@ -172146,8 +172239,8 @@ self: { }: mkDerivation { pname = "membership"; - version = "0"; - sha256 = "0hdy0yv64gcwja2kr6akfms21jgq6lqhzbxap603nhiwvf7n8ayv"; + version = "0.0.1"; + sha256 = "07b40i1fvkix9x60nqp6nmlchjkcj3jhp7xpq583fpssqm79x14m"; libraryHaskellDepends = [ base constraints deepseq hashable prettyprinter template-haskell th-lift @@ -185413,8 +185506,8 @@ self: { ({ mkDerivation, base }: mkDerivation { pname = "network-types-icmp"; - version = "1.0.0.2"; - sha256 = "1s449djcr78k8ywzypmc62d7lysm245ih60z4wi6p0kmyv1qcj75"; + version = "1.0.1"; + sha256 = "0wf2rg4alw4alalvjdcd85k6sjhcpdqacblbn76r5kmy2pqfrqfs"; libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Types for representing ICMP and ICMPv6 messages"; @@ -187797,6 +187890,21 @@ self: { license = lib.licenses.bsd3; }) {}; + "nri-env-parser_0_1_0_4" = callPackage + ({ mkDerivation, base, modern-uri, network-uri, nri-prelude, text + }: + mkDerivation { + pname = "nri-env-parser"; + version = "0.1.0.4"; + sha256 = "01s2346rdccnqrymxb947kx68jqdyh29v3s2mq3c707pvmxlhw4y"; + libraryHaskellDepends = [ + base modern-uri network-uri nri-prelude text + ]; + description = "Read environment variables as settings to build 12-factor apps"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "nri-prelude" = callPackage ({ mkDerivation, aeson, ansi-terminal, async, auto-update, base , bytestring, containers, directory, exceptions, filepath, hedgehog @@ -187821,25 +187929,25 @@ self: { license = lib.licenses.bsd3; }) {}; - "nri-prelude_0_3_1_0" = callPackage + "nri-prelude_0_4_0_0" = callPackage ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async , auto-update, base, bytestring, containers, directory, exceptions - , filepath, hedgehog, junit-xml, pretty-diff, pretty-show + , filepath, ghc, hedgehog, junit-xml, pretty-diff, pretty-show , safe-exceptions, terminal-size, text, time, vector }: mkDerivation { pname = "nri-prelude"; - version = "0.3.1.0"; - sha256 = "0dg94blhrrnzh00kgjz5bclcwzx87ky2210nxx8902xx54x928vc"; + version = "0.4.0.0"; + sha256 = "032j7wy9wjjv0pbn1g16vdj15j03brkkwa3ssjv7g0v61hjaq4z7"; libraryHaskellDepends = [ aeson aeson-pretty ansi-terminal async auto-update base bytestring - containers directory exceptions filepath hedgehog junit-xml + containers directory exceptions filepath ghc hedgehog junit-xml pretty-diff pretty-show safe-exceptions terminal-size text time vector ]; testHaskellDepends = [ aeson aeson-pretty ansi-terminal async auto-update base bytestring - containers directory exceptions filepath hedgehog junit-xml + containers directory exceptions filepath ghc hedgehog junit-xml pretty-diff pretty-show safe-exceptions terminal-size text time vector ]; @@ -194025,8 +194133,8 @@ self: { ({ mkDerivation }: mkDerivation { pname = "pandora"; - version = "0.3.6"; - sha256 = "12slj2jy688k4ndngwmjjkdvl2ryljv3siwal874pdficx0dffxg"; + version = "0.3.7"; + sha256 = "0laqf7mfzdpdbg583l3mr25qxdqryq1cd1141gl713d5m9s1b4fs"; description = "A box of patterns and paradigms"; license = lib.licenses.mit; }) {}; @@ -203751,8 +203859,8 @@ self: { }: mkDerivation { pname = "polysemy-mocks"; - version = "0.1.0.0"; - sha256 = "04cgajjrlbiqij54k6agm1p6h4hv5lldb9f9yrzbwm0v69d02bs7"; + version = "0.1.0.1"; + sha256 = "0jd8x47mdx9fyn65ra0y1m05myf2m2bhz3ykg1i3818ixwd93xvl"; libraryHaskellDepends = [ base polysemy template-haskell ]; testHaskellDepends = [ base hspec polysemy ]; testToolDepends = [ hspec-discover ]; @@ -205138,6 +205246,8 @@ self: { pname = "postgresql-libpq"; version = "0.9.4.3"; sha256 = "1gfnhc5pibn7zmifdf2g0c112xrpzsk756ln2kjzqljkspf4dqp3"; + revision = "1"; + editedCabalFile = "1clivf13z15w954a0kcfkv8yc0d8kx61b68x2hk7a9236ck7l2m2"; setupHaskellDepends = [ base Cabal ]; libraryHaskellDepends = [ base bytestring unix ]; librarySystemDepends = [ postgresql ]; @@ -207722,7 +207832,7 @@ self: { broken = true; }) {}; - "primitive-extras_0_9" = callPackage + "primitive-extras_0_10_1" = callPackage ({ mkDerivation, base, bytestring, cereal, deferred-folds, focus , foldl, list-t, primitive, primitive-unlifted, profunctors , QuickCheck, quickcheck-instances, rerebase, tasty, tasty-hunit @@ -207730,8 +207840,8 @@ self: { }: mkDerivation { pname = "primitive-extras"; - version = "0.9"; - sha256 = "04sb2q5r5z1sdj976p8p6hgx360agwxjqmcrgr8vcgyfgzphizfr"; + version = "0.10.1"; + sha256 = "0ddnn94qqkx021marpi2j03sil15422scq0df6dmlc6q0qyyivyc"; libraryHaskellDepends = [ base bytestring cereal deferred-folds focus foldl list-t primitive primitive-unlifted profunctors vector @@ -216554,6 +216664,44 @@ self: { broken = true; }) {}; + "reanimate_1_1_3_3" = callPackage + ({ mkDerivation, aeson, ansi-terminal, array, attoparsec, base + , base64-bytestring, bytestring, cassava, cereal, colour + , containers, cryptohash-sha256, cubicbezier, directory, filelock + , filepath, fingertree, fsnotify, geojson, hashable, hgeometry + , hgeometry-combinatorial, JuicyPixels, lens, linear, matrix, mtl + , neat-interpolation, network, open-browser, optparse-applicative + , parallel, process, QuickCheck, random, random-shuffle + , reanimate-svg, split, tasty, tasty-expected-failure, tasty-golden + , tasty-hunit, tasty-quickcheck, tasty-rerun, temporary, text, time + , unix, unordered-containers, vector, vector-space, websockets, xml + }: + mkDerivation { + pname = "reanimate"; + version = "1.1.3.3"; + sha256 = "1d348fpfzfqi3vm8qzdxbbdrx62awxx0hrnj3vw1szp41an6ya30"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson ansi-terminal array attoparsec base base64-bytestring + bytestring cassava cereal colour containers cryptohash-sha256 + cubicbezier directory filelock filepath fingertree fsnotify geojson + hashable hgeometry hgeometry-combinatorial JuicyPixels lens linear + matrix mtl neat-interpolation network open-browser + optparse-applicative parallel process random random-shuffle + reanimate-svg split temporary text time unix unordered-containers + vector vector-space websockets xml + ]; + testHaskellDepends = [ + base bytestring directory filepath linear process QuickCheck tasty + tasty-expected-failure tasty-golden tasty-hunit tasty-quickcheck + tasty-rerun temporary text vector + ]; + description = "Animation library based on SVGs"; + license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "reanimate-svg" = callPackage ({ mkDerivation, attoparsec, base, bytestring, containers, Diff , directory, double-conversion, filepath, hashable, JuicyPixels @@ -216581,6 +216729,33 @@ self: { broken = true; }) {}; + "reanimate-svg_0_13_0_1" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers, Diff + , directory, double-conversion, filepath, hashable, JuicyPixels + , lens, linear, mtl, process, QuickCheck, scientific, tasty + , tasty-expected-failure, tasty-golden, tasty-hunit + , tasty-quickcheck, tasty-rerun, temporary, text, transformers + , typed-process, vector, xml + }: + mkDerivation { + pname = "reanimate-svg"; + version = "0.13.0.1"; + sha256 = "1h31r0lrslxqfayh06955p1kv35g42g3drmqp4miydk6zibyn091"; + libraryHaskellDepends = [ + attoparsec base bytestring containers double-conversion hashable + JuicyPixels lens linear mtl scientific text transformers vector xml + ]; + testHaskellDepends = [ + base bytestring Diff directory filepath linear process QuickCheck + tasty tasty-expected-failure tasty-golden tasty-hunit + tasty-quickcheck tasty-rerun temporary text typed-process vector + ]; + description = "SVG file loader and serializer"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "reason-export" = callPackage ({ mkDerivation, base, bytestring, containers, Diff, directory , formatting, hashable, hspec, hspec-core, HUnit, mtl, QuickCheck @@ -216952,6 +217127,24 @@ self: { license = lib.licenses.bsd2; }) {}; + "recursion-schemes_5_2_2" = callPackage + ({ mkDerivation, base, base-orphans, comonad, containers, data-fix + , free, HUnit, template-haskell, th-abstraction, transformers + }: + mkDerivation { + pname = "recursion-schemes"; + version = "5.2.2"; + sha256 = "02p1blgxd0nyzrgqw8ghm2a680f2a05rn1nrqqcjyh1whksl2g3x"; + libraryHaskellDepends = [ + base base-orphans comonad containers data-fix free template-haskell + th-abstraction transformers + ]; + testHaskellDepends = [ base HUnit template-haskell transformers ]; + description = "Representing common recursion patterns as higher-order functions"; + license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + }) {}; + "recursion-schemes-ext" = callPackage ({ mkDerivation, base, composition-prelude, criterion, deepseq , hspec, lens, recursion-schemes @@ -218591,6 +218784,20 @@ self: { license = lib.licenses.bsd3; }) {}; + "regex-base_0_94_0_1" = callPackage + ({ mkDerivation, array, base, bytestring, containers, mtl, text }: + mkDerivation { + pname = "regex-base"; + version = "0.94.0.1"; + sha256 = "1ngdmmrxs1rhvib052c6shfa40yad82jylylikz327r0zxpxkcbi"; + libraryHaskellDepends = [ + array base bytestring containers mtl text + ]; + description = "Common \"Text.Regex.*\" API for Regex matching"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "regex-compat" = callPackage ({ mkDerivation, array, base, regex-base, regex-posix }: mkDerivation { @@ -218604,6 +218811,18 @@ self: { license = lib.licenses.bsd3; }) {}; + "regex-compat_0_95_2_1" = callPackage + ({ mkDerivation, array, base, regex-base, regex-posix }: + mkDerivation { + pname = "regex-compat"; + version = "0.95.2.1"; + sha256 = "0ivrdrcphrz3g6nr5wbsmfiv8i82caw0kf6z5qlmlq7xf9n3hywg"; + libraryHaskellDepends = [ array base regex-base regex-posix ]; + description = "Replaces/enhances \"Text.Regex\""; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "regex-compat-tdfa" = callPackage ({ mkDerivation, array, base, regex-base, regex-tdfa }: mkDerivation { @@ -218781,8 +219000,8 @@ self: { pname = "regex-pcre"; version = "0.95.0.0"; sha256 = "0nn76q4bsjnxim0j0d01jifmh36as9jdpcvm001a851vvq86zb8n"; - revision = "1"; - editedCabalFile = "1s5jdwvymc9hxdfa23x5amnv2kkcsm2p119f38df2vjdxfvjfiq4"; + revision = "2"; + editedCabalFile = "0bvpy3rswyawv23s14nbxvgz5761s61g0shcj7p032i95iq7dj6d"; libraryHaskellDepends = [ array base bytestring containers regex-base ]; @@ -218848,8 +219067,8 @@ self: { pname = "regex-posix"; version = "0.96.0.0"; sha256 = "08a584jabmmn5gmaqrcar5wsp3qzk0hklldzp2mr2bmvlvqh04r5"; - revision = "1"; - editedCabalFile = "1cy39n1928wv55i7k4wm7zd3xijk7p54kbrxxlfzfvgax5k163b9"; + revision = "2"; + editedCabalFile = "10al5qljh6pc46581nkhrs0rjn8w05pp6jb4v55lgfr17ac0z1xx"; libraryHaskellDepends = [ array base bytestring containers regex-base ]; @@ -218896,8 +219115,8 @@ self: { pname = "regex-tdfa"; version = "1.3.1.0"; sha256 = "1h1fliv2zjxwmddl9wnn7ckxxpgy1049hdfg6fcknyrr7mw7dhqm"; - revision = "1"; - editedCabalFile = "1fhi4g2p29qnnfyb211n62g97qrw3gz1kahca7rlz43all93ihdy"; + revision = "2"; + editedCabalFile = "1hvcqdywwlcpia7qss7ikr9bq0lvkk8z0mjgaylaqpzlgh00z3gb"; libraryHaskellDepends = [ array base bytestring containers mtl parsec regex-base text ]; @@ -236935,8 +237154,8 @@ self: { pname = "singleton-bool"; version = "0.1.5"; sha256 = "17w9vv6arn7vvc7kykqcx81q2364ji43khrryl27r1cjx9yxapa0"; - revision = "2"; - editedCabalFile = "118j0h29nqg2acqbzif2ffqnanjbwnqmv2kch9z7xiwqkz6iq8an"; + revision = "3"; + editedCabalFile = "11rhzpy4xiry39bbxzwrqff75f0f4g7z0vkr3v9l8rv3w40jlf7x"; libraryHaskellDepends = [ base dec ]; description = "Type level booleans"; license = lib.licenses.bsd3; @@ -240967,6 +241186,22 @@ self: { broken = true; }) {}; + "sockets-and-pipes" = callPackage + ({ mkDerivation, aeson, ascii, async, base, blaze-html, bytestring + , containers, network, safe-exceptions, stm, text, time + }: + mkDerivation { + pname = "sockets-and-pipes"; + version = "0.1"; + sha256 = "02xc2kddcz93d9yqdchml0yh9gypcx64315baj766adgf8np42nv"; + libraryHaskellDepends = [ + aeson ascii async base blaze-html bytestring containers network + safe-exceptions stm text time + ]; + description = "Support for the Sockets and Pipes book"; + license = lib.licenses.asl20; + }) {}; + "socketson" = callPackage ({ mkDerivation, aeson, base, base64-bytestring, bytestring, cereal , crypto-api, data-default, DRBG, either, errors, http-types @@ -245592,8 +245827,8 @@ self: { pname = "step-function"; version = "0.2"; sha256 = "1mg7zqqs32zdh1x1738kk0yydyksbhx3y3x8n31f7byk5fvzqq6j"; - revision = "4"; - editedCabalFile = "0zxjrsa54g65p7kf5mfpjb897d1add2dfp5dm4xfs5321rs31knv"; + revision = "5"; + editedCabalFile = "03xg6n7dyz73y3llbbahnlh46xfy2iq29s1jwjp22qxd4z6xndsa"; libraryHaskellDepends = [ base base-compat-batteries containers deepseq QuickCheck ]; @@ -245878,7 +246113,7 @@ self: { broken = true; }) {}; - "stm-hamt_1_2_0_5" = callPackage + "stm-hamt_1_2_0_6" = callPackage ({ mkDerivation, async, base, criterion, deferred-folds, focus , free, hashable, list-t, mwc-random, mwc-random-monad, primitive , primitive-extras, QuickCheck, quickcheck-instances, rebase @@ -245886,8 +246121,8 @@ self: { }: mkDerivation { pname = "stm-hamt"; - version = "1.2.0.5"; - sha256 = "09hz5v2ldinyl6brrl87f46wg16y9d1fnwb5v8s17ph00sb95lgg"; + version = "1.2.0.6"; + sha256 = "15jqj31h9ff4g2k3sq35nm122sy0hqapxf4fm5vlkfh33zdn28di"; libraryHaskellDepends = [ base deferred-folds focus hashable list-t primitive primitive-extras transformers @@ -252952,8 +253187,8 @@ self: { pname = "tar"; version = "0.5.1.1"; sha256 = "1ppim7cgmn7ng8zbdrwkxhhizc30h15h1c9cdlzamc5jcagl915k"; - revision = "2"; - editedCabalFile = "131f369a2vjzr26r7f2c2p534xvyw0s7cvgvih2ck56lqha58wbs"; + revision = "3"; + editedCabalFile = "0qjhii1lhvqav3pnm6z5ly40d9gwp7p3y4g7k26bhxgy31bx1pll"; libraryHaskellDepends = [ array base bytestring containers deepseq directory filepath time ]; @@ -261896,6 +262131,8 @@ self: { pname = "topograph"; version = "1.0.0.1"; sha256 = "1sd2gyirkdgwcll76zxw954wdsyxzajn59xa9zk55fbrsm6w24cv"; + revision = "1"; + editedCabalFile = "1cbpm16jk8x8xy0r3v8zdmwrdgxlp6zww03rmzbz0031hddpywrk"; libraryHaskellDepends = [ base base-compat base-orphans containers vector ]; @@ -263345,8 +263582,8 @@ self: { pname = "tree-diff"; version = "0.1"; sha256 = "1156nbqn0pn9lp4zjsy4vv5g5wmy4zxwmbqdgvq349rydynh3ng3"; - revision = "5"; - editedCabalFile = "1b60x9cgp7hn42hc97q866ybhg5hx3sp45j6gngpbwryg29r2p4h"; + revision = "6"; + editedCabalFile = "1wqfac660m9ggv6r85a7y29mk947hki9iydy124vdwcqzichja0d"; libraryHaskellDepends = [ aeson ansi-terminal ansi-wl-pprint base base-compat bytestring bytestring-builder containers hashable parsec parsers pretty @@ -263573,6 +263810,18 @@ self: { license = lib.licenses.bsd3; }) {}; + "tree-view_0_5_1" = callPackage + ({ mkDerivation, base, containers, mtl }: + mkDerivation { + pname = "tree-view"; + version = "0.5.1"; + sha256 = "1ya3m1qi83pn74wzffvbzj7wn6n5zny4yzzzf7wlfqszl96jhn2g"; + libraryHaskellDepends = [ base containers mtl ]; + description = "Render trees as foldable HTML and Unicode art"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "treefold" = callPackage ({ mkDerivation, base, containers, criterion, doctest, hedgehog , parallel, random @@ -269007,6 +269256,8 @@ self: { pname = "universe-instances-extended"; version = "1.1.2"; sha256 = "1yg3cacr56kk0r8vnqxa9cm1awb727qkysnhc7rn4h9pfb10a7sn"; + revision = "1"; + editedCabalFile = "017adjf6wbw56a81l69vd0gzhlvi6n1wplh85smq7l9m98wsh4wy"; libraryHaskellDepends = [ adjunctions base comonad containers universe-base ]; @@ -288536,8 +288787,8 @@ self: { pname = "zinza"; version = "0.2"; sha256 = "1sy4chm8zan0ixgvvq4vm3fzvhqykn315l333al84768nly9rjv8"; - revision = "1"; - editedCabalFile = "0pgrfx4vnc3m6rlmg5qj4skarq5y0ijz3swf3fyy57310lvifr0q"; + revision = "2"; + editedCabalFile = "17q1as97cazj2nkwdi31kkgaa3wrxpc8phdj6f9wr4jibbm3jyp6"; libraryHaskellDepends = [ base containers parsec text transformers ]; From bcadd3e19c5c44af62358ea3960ab0ec3aa44f34 Mon Sep 17 00:00:00 2001 From: Jakob Leifhelm Date: Sun, 21 Feb 2021 19:28:11 +0100 Subject: [PATCH 16/70] haskell-language-server: ghc 8.10.3 -> ghc 8.10.4 --- .../tools/haskell/haskell-language-server/withWrapper.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix b/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix index 4203564ae4a..364117577bc 100644 --- a/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix +++ b/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix @@ -1,4 +1,4 @@ -{ lib, supportedGhcVersions ? [ "865" "884" "8103" ], stdenv, haskellPackages +{ lib, supportedGhcVersions ? [ "865" "884" "8104" ], stdenv, haskellPackages , haskell }: # # The recommended way to override this package is From cf5345e6961872385fc37c084b5d2edecb472ab9 Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Mon, 22 Feb 2021 02:30:28 +0100 Subject: [PATCH 17/70] hackage-packages.nix: automatic Haskell package set update This update was generated by hackage2nix v2.16.0-13-gefcfbb2 from Hackage revision https://github.com/commercialhaskell/all-cabal-hashes/commit/f86c3f6d72c8164ab32cd2f6e5673c8fec303c96. --- .../haskell-modules/hackage-packages.nix | 254 ++++++++++++++++-- 1 file changed, 227 insertions(+), 27 deletions(-) diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 76ed05a480f..806aaa867b5 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -31999,6 +31999,8 @@ self: { pname = "approximate"; version = "0.3.2"; sha256 = "016i37c5imb0n8gsk7gzyiq8dhkjv0xnn5315kmn6lnrhpfm7yyk"; + revision = "1"; + editedCabalFile = "0r81fnsyfc8y7j2y2isjayq4gf6m9vsc2chw37g89zmknfsnilb7"; setupHaskellDepends = [ base Cabal cabal-doctest ]; libraryHaskellDepends = [ base binary bytes cereal comonad deepseq ghc-prim hashable lens @@ -32011,15 +32013,15 @@ self: { license = lib.licenses.bsd3; }) {}; - "approximate_0_3_3" = callPackage + "approximate_0_3_4" = callPackage ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq , ghc-prim, hashable, lens, log-domain, pointed, safecopy , semigroupoids, semigroups, vector }: mkDerivation { pname = "approximate"; - version = "0.3.3"; - sha256 = "1hvgx5m83zzpy2l0bbs39yvybhsxlq9919hp7wn27n5j0lk7wplk"; + version = "0.3.4"; + sha256 = "06akbrmy66nkgnnk3x87jss9qgv5y9m638rvxy57mfzibf925kbd"; libraryHaskellDepends = [ base binary bytes cereal comonad deepseq ghc-prim hashable lens log-domain pointed safecopy semigroupoids semigroups vector @@ -38352,8 +38354,8 @@ self: { pname = "base64-bytestring-type"; version = "1.0.1"; sha256 = "03kq4rjj6by02rf3hg815jfdqpdk0xygm5f46r2pn8mb99yd01zn"; - revision = "7"; - editedCabalFile = "1vry5qh9w1adwyfrlx8x2772knwmdvxgq2nfzng7vybll2cqph4c"; + revision = "8"; + editedCabalFile = "196m1ylkl9d03iymld08fhfnfcdydzd824v7ffl67ijmfxcvzcyn"; libraryHaskellDepends = [ aeson base base-compat base64-bytestring binary bytestring cereal deepseq hashable http-api-data QuickCheck serialise text @@ -59579,6 +59581,8 @@ self: { pname = "compensated"; version = "0.8.1"; sha256 = "1qr5nsg6fb6ib2wp29c1y05zdbydsng0sfg2k75qsh0avb2cgw7z"; + revision = "1"; + editedCabalFile = "1hsg6j8h700nixgnz823js5pm5ziq820nzds1b60j0a0plz94pin"; setupHaskellDepends = [ base Cabal cabal-doctest ]; libraryHaskellDepends = [ base bifunctors binary bytes cereal comonad deepseq distributive @@ -59592,15 +59596,15 @@ self: { license = lib.licenses.bsd3; }) {}; - "compensated_0_8_2" = callPackage + "compensated_0_8_3" = callPackage ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad , criterion, deepseq, distributive, hashable, lens, log-domain , safecopy, semigroupoids, semigroups, vector }: mkDerivation { pname = "compensated"; - version = "0.8.2"; - sha256 = "0mqy5c5wh4m3l78fbd20vnllpsn383q07kxl6j62iakcyhr1264p"; + version = "0.8.3"; + sha256 = "0xigi4pcw581d8kjbhdjkksyz9bgcgvq0j17br9z1x6a3hw1m39a"; libraryHaskellDepends = [ base bifunctors binary bytes cereal comonad deepseq distributive hashable lens log-domain safecopy semigroupoids semigroups vector @@ -70973,7 +70977,7 @@ self: { license = lib.licenses.asl20; }) {}; - "dbus_1_2_18" = callPackage + "dbus_1_2_19" = callPackage ({ mkDerivation, base, bytestring, cereal, conduit, containers , criterion, deepseq, directory, exceptions, extra, filepath, lens , network, parsec, process, QuickCheck, random, resourcet, split @@ -70982,8 +70986,8 @@ self: { }: mkDerivation { pname = "dbus"; - version = "1.2.18"; - sha256 = "15ggmggzgzf0xmj80rj14dyk83vra6yzm5pm92psnc4spn213p73"; + version = "1.2.19"; + sha256 = "1wcwh8c27v8vs7jaqzp3032wzx14v4mn7r2qhxhb77cppimrjqpg"; libraryHaskellDepends = [ base bytestring cereal conduit containers deepseq exceptions filepath lens network parsec random split template-haskell text @@ -122653,6 +122657,24 @@ self: { license = lib.licenses.mit; }) {}; + "hasty-hamiltonian_1_3_4" = callPackage + ({ mkDerivation, ad, base, kan-extensions, lens, mcmc-types + , mwc-probability, pipes, primitive, transformers + }: + mkDerivation { + pname = "hasty-hamiltonian"; + version = "1.3.4"; + sha256 = "0qvqh5d213lq02qq25s1a6z783836h5gi5zra99pprblpdffaazq"; + libraryHaskellDepends = [ + base kan-extensions lens mcmc-types mwc-probability pipes primitive + transformers + ]; + testHaskellDepends = [ ad base mwc-probability ]; + description = "Speedy traversal through parameter space"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "hat" = callPackage ({ mkDerivation, base, bytestring, containers, directory, filepath , haskeline, haskell-src-exts, old-locale, old-time, polyparse @@ -139560,7 +139582,7 @@ self: { license = lib.licenses.mit; }) {}; - "http-client_0_7_5" = callPackage + "http-client_0_7_6" = callPackage ({ mkDerivation, array, async, base, base64-bytestring , blaze-builder, bytestring, case-insensitive, containers, cookie , deepseq, directory, exceptions, filepath, ghc-prim, hspec @@ -139569,8 +139591,8 @@ self: { }: mkDerivation { pname = "http-client"; - version = "0.7.5"; - sha256 = "11p4szyrdl0ck2iixdrq2dcjz9dlv4pd36ymkipmq7c28l1cvy7k"; + version = "0.7.6"; + sha256 = "1458mq5kh5fjlkhk9cgaz6sc6533l2nm4r2jz80diy8qc6bpiwrk"; libraryHaskellDepends = [ array base base64-bytestring blaze-builder bytestring case-insensitive containers cookie deepseq exceptions filepath @@ -139889,6 +139911,35 @@ self: { license = lib.licenses.bsd3; }) {}; + "http-conduit_2_3_8" = callPackage + ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring + , case-insensitive, conduit, conduit-extra, connection, cookie + , data-default-class, hspec, http-client, http-client-tls + , http-types, HUnit, mtl, network, resourcet, streaming-commons + , temporary, text, time, tls, transformers, unliftio, unliftio-core + , utf8-string, wai, wai-conduit, warp, warp-tls + }: + mkDerivation { + pname = "http-conduit"; + version = "2.3.8"; + sha256 = "1bj24phbcb7s3k6v48l5gk82m3m23j8zy9l7c5ccxp3ghn9z5gng"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring conduit conduit-extra http-client + http-client-tls http-types mtl resourcet transformers unliftio-core + ]; + testHaskellDepends = [ + aeson base blaze-builder bytestring case-insensitive conduit + conduit-extra connection cookie data-default-class hspec + http-client http-types HUnit network resourcet streaming-commons + temporary text time tls transformers unliftio utf8-string wai + wai-conduit warp warp-tls + ]; + doCheck = false; + description = "HTTP client package with conduit interface and HTTPS support"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "http-conduit-browser" = callPackage ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring , case-insensitive, conduit, containers, cookie, data-default @@ -160718,6 +160769,27 @@ self: { license = lib.licenses.bsd3; }) {}; + "lens-regex_0_1_3" = callPackage + ({ mkDerivation, array, base, directory, doctest, filepath, lens + , regex-base, regex-posix, template-haskell + }: + mkDerivation { + pname = "lens-regex"; + version = "0.1.3"; + sha256 = "11zgdk46skj3g0436vilcgg4wvclixh07xjwqfcsfhffn0vn3mz4"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array base lens regex-base template-haskell + ]; + testHaskellDepends = [ + base directory doctest filepath regex-posix + ]; + description = "Lens powered regular expression"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "lens-regex-pcre" = callPackage ({ mkDerivation, base, bytestring, containers, gauge, hspec, lens , pcre-heavy, pcre-light, template-haskell, text @@ -173054,8 +173126,8 @@ self: { ({ mkDerivation, base, hspec, hspec-discover, rio, transformers }: mkDerivation { pname = "method"; - version = "0.2.0.0"; - sha256 = "0vgh0ri5r1jsfax5qafvkqqnkywk4qayaw54dwhh5i3p1n5cqkqa"; + version = "0.3.0.0"; + sha256 = "1a5i9sd5zz5kjpjpar3r5ak61x8fz5rrbb1iak1r2dcwlyk6rq25"; libraryHaskellDepends = [ base rio transformers ]; testHaskellDepends = [ base hspec rio transformers ]; testToolDepends = [ hspec-discover ]; @@ -175806,6 +175878,8 @@ self: { pname = "mod"; version = "0.1.2.1"; sha256 = "0fjcjk9jxwc2d1fm3kzamh9gi3lwnl2g6kz3z2hd43dszkay1mn1"; + revision = "1"; + editedCabalFile = "012slncmwh9i4fh31mdxn5xnpl9l309swrm5vlnibrxj3pxhmrxv"; libraryHaskellDepends = [ base deepseq integer-gmp primitive semirings vector ]; @@ -186162,8 +186236,10 @@ self: { }: mkDerivation { pname = "ngx-export-tools-extra"; - version = "0.6.1.1"; - sha256 = "1gqns0ifrmjd1013jfa9c03xwdmqicdvazjc9kkxyzw4mpjgjils"; + version = "0.6.2.0"; + sha256 = "01r6b7xsgn2dd42jh3xnvds21sccq5lchyiikk5v1vr055dddmpm"; + revision = "1"; + editedCabalFile = "0sab8vs3zycm4ykcayrynvd0rmyar9bmvd8b60dq1fzmnbmzzgg9"; libraryHaskellDepends = [ aeson array base base64 binary bytestring case-insensitive containers ede enclosed-exceptions http-client http-types network @@ -205469,6 +205545,8 @@ self: { pname = "postgresql-simple"; version = "0.6.4"; sha256 = "0rz2bklxp4pvbxb2w49h5p6pbwabn6d5d4j4mrya4fpa0d13k43d"; + revision = "1"; + editedCabalFile = "017qfhml58psv72qnyb2hg6r8jl1mj8jmr2q5p3hgd0lcsxiq0qi"; libraryHaskellDepends = [ aeson attoparsec base bytestring bytestring-builder case-insensitive containers hashable Only postgresql-libpq @@ -216935,6 +217013,24 @@ self: { license = lib.licenses.bsd3; }) {}; + "record-dot-preprocessor_0_2_8" = callPackage + ({ mkDerivation, base, extra, filepath, ghc, record-hasfield + , uniplate + }: + mkDerivation { + pname = "record-dot-preprocessor"; + version = "0.2.8"; + sha256 = "0ln7kw1f0l56ivzh77s1k1xa3nha3a4hs3bpmdi9apj21ffr5cb6"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base extra ghc uniplate ]; + executableHaskellDepends = [ base extra ]; + testHaskellDepends = [ base extra filepath record-hasfield ]; + description = "Preprocessor to allow record.field syntax"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "record-encode" = callPackage ({ mkDerivation, base, doctest, generics-sop, hspec, QuickCheck , vector @@ -225714,6 +225810,30 @@ self: { license = lib.licenses.publicDomain; }) {}; + "safecopy_0_10_4_1" = callPackage + ({ mkDerivation, array, base, bytestring, cereal, containers + , generic-data, HUnit, lens, lens-action, old-time, QuickCheck + , quickcheck-instances, tasty, tasty-quickcheck, template-haskell + , text, time, transformers, vector + }: + mkDerivation { + pname = "safecopy"; + version = "0.10.4.1"; + sha256 = "1p8kbf9js67zl2wr6y0605acy54xlpsih1zqkdy21cywz1kannbp"; + libraryHaskellDepends = [ + array base bytestring cereal containers generic-data old-time + template-haskell text time transformers vector + ]; + testHaskellDepends = [ + array base bytestring cereal containers HUnit lens lens-action + QuickCheck quickcheck-instances tasty tasty-quickcheck + template-haskell time vector + ]; + description = "Binary serialization with version control"; + license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + }) {}; + "safecopy-migrate" = callPackage ({ mkDerivation, base, base-prelude, cereal, containers, extra , haskell-src-meta, microlens, safecopy, template-haskell @@ -242433,6 +242553,24 @@ self: { license = lib.licenses.mit; }) {}; + "speedy-slice_0_3_2" = callPackage + ({ mkDerivation, base, containers, kan-extensions, lens, mcmc-types + , mwc-probability, pipes, primitive, transformers + }: + mkDerivation { + pname = "speedy-slice"; + version = "0.3.2"; + sha256 = "1bmy0hrrqgwbqsk1ckbmzy1hhcwlcjsclcskrdmzfq5afvq9kq3z"; + libraryHaskellDepends = [ + base kan-extensions lens mcmc-types mwc-probability pipes primitive + transformers + ]; + testHaskellDepends = [ base containers ]; + description = "Speedy slice sampling"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "spelling-suggest" = callPackage ({ mkDerivation, base, edit-distance, parseargs, phonetic-code , sqlite @@ -244803,6 +244941,22 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "staged-gg" = callPackage + ({ mkDerivation, base, containers, generic-deriving + , template-haskell, th-abstraction, th-lift + }: + mkDerivation { + pname = "staged-gg"; + version = "0.1"; + sha256 = "1apajw5ig7sax31i2zf842isnhk74x65hv9k8k3f6dhdxxg2dha4"; + libraryHaskellDepends = [ + base containers generic-deriving template-haskell th-abstraction + th-lift + ]; + description = "GHC.Generics style staged generics"; + license = lib.licenses.bsd3; + }) {}; + "stagen" = callPackage ({ mkDerivation, aeson, base, base-compat, blaze-html, bytestring , data-default, directory, feed, filemanip, json-feed, lucid @@ -265784,8 +265938,8 @@ self: { }: mkDerivation { pname = "twitter-types-lens"; - version = "0.10.0"; - sha256 = "1x9w68mr6r6354in9l4vmawk5symvfh2qlhjn2gd30m8b1mzbrjg"; + version = "0.10.1"; + sha256 = "07znqqb4lhhzlzvi1nl3m13cnskfakq4pnn52wpn554igxymgvsd"; libraryHaskellDepends = [ base lens template-haskell text time twitter-types ]; @@ -266977,17 +267131,15 @@ self: { }) {}; "typelevel-rewrite-rules" = callPackage - ({ mkDerivation, base, ghc, ghc-prim, ghc-tcplugins-extra - , term-rewriting, transformers, vinyl + ({ mkDerivation, base, containers, ghc, ghc-prim, term-rewriting + , transformers, vinyl }: mkDerivation { pname = "typelevel-rewrite-rules"; - version = "0.1"; - sha256 = "1gm3xbsi90dgppwhhhlmq1rwwnx9bxhm7zv9x4yr0952fwxrm8x8"; - revision = "1"; - editedCabalFile = "0wgryhys24671j46s58prbh7agrlxdcbains6qv37kp6xly726nj"; + version = "1.0"; + sha256 = "0by8zl16dzq0srdmr7p3hwdp1966gbdmzqp9h2548sj767r0ncmy"; libraryHaskellDepends = [ - base ghc ghc-prim ghc-tcplugins-extra term-rewriting transformers + base containers ghc ghc-prim term-rewriting transformers ]; testHaskellDepends = [ base ghc-prim vinyl ]; description = "Solve type equalities using custom type-level rewrite rules"; @@ -269487,6 +269639,23 @@ self: { license = lib.licenses.bsd3; }) {}; + "unix-recursive" = callPackage + ({ mkDerivation, base, bytestring, criterion, dir-traverse, hspec + , unix + }: + mkDerivation { + pname = "unix-recursive"; + version = "0.1.0.0"; + sha256 = "151ap7b3nzlaz2pfl144z4azfvxdw6l8zrn500nzl58hqr9n7awl"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base bytestring unix ]; + testHaskellDepends = [ base bytestring hspec unix ]; + benchmarkHaskellDepends = [ base criterion dir-traverse ]; + description = "Fast and flexible primitives for recursive file system IO on Posix systems"; + license = lib.licenses.bsd3; + }) {}; + "unix-simple" = callPackage ({ mkDerivation, base, bytestring, zenhack-prelude }: mkDerivation { @@ -273312,6 +273481,19 @@ self: { license = lib.licenses.bsd3; }) {}; + "vector-th-unbox_0_2_1_8" = callPackage + ({ mkDerivation, base, data-default, template-haskell, vector }: + mkDerivation { + pname = "vector-th-unbox"; + version = "0.2.1.8"; + sha256 = "1b6lx1n96b17xsc7mzvcj6k3fzf7xjghrrv77i94x9356hkab765"; + libraryHaskellDepends = [ base template-haskell vector ]; + testHaskellDepends = [ base data-default vector ]; + description = "Deriver for Data.Vector.Unboxed using Template Haskell"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "vectortiles" = callPackage ({ mkDerivation, base, bytestring, containers, criterion, deepseq , hashable, microlens, microlens-platform, mtl, protocol-buffers @@ -289097,6 +289279,24 @@ self: { license = lib.licenses.bsd3; }) {inherit (pkgs) zlib;}; + "zlib_0_6_2_3" = callPackage + ({ mkDerivation, base, bytestring, QuickCheck, tasty, tasty-hunit + , tasty-quickcheck, zlib + }: + mkDerivation { + pname = "zlib"; + version = "0.6.2.3"; + sha256 = "125wbayk8ifp0gp8cb52afck2ziwvqfrjzbmwmy52g6bz7fnnzw0"; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ zlib ]; + testHaskellDepends = [ + base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck + ]; + description = "Compression and decompression in the gzip and zlib formats"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {inherit (pkgs) zlib;}; + "zlib-bindings" = callPackage ({ mkDerivation, base, bytestring, hspec, QuickCheck, zlib }: mkDerivation { From 1bd9bbc335b986e13b26f89f0e629f41bb91eb2e Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Mon, 22 Feb 2021 22:39:15 +0100 Subject: [PATCH 18/70] haskellPackages.idris: unbreak by applying patches from master We need to fix two compilation errors caused by breaking changes in dependencies of idris 1.3.3: * haskeline >= 0.8 * megaparsec >= 0.9 For both there is a patch on idris master which we can just apply. Both can presumably removed as soon as the next release of idris 1 hits. Co-authored-by: Jake Gillberg --- .../haskell-modules/configuration-common.nix | 22 +++++++++++++++++-- .../configuration-hackage2nix.yaml | 1 - 2 files changed, 20 insertions(+), 3 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 2f3ea3a4533..372d0c8e5c3 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -684,8 +684,26 @@ self: super: { ''; }); - # The standard libraries are compiled separately. - idris = generateOptparseApplicativeCompletion "idris" (dontCheck super.idris); + # * The standard libraries are compiled separately. + # * We need multiple patches from master to fix compilation with + # updated dependencies (haskeline and megaparsec) which can be + # removed when the next idris release (1.3.4 probably) comes + # around. + idris = generateOptparseApplicativeCompletion "idris" + (doJailbreak (dontCheck + (appendPatches super.idris [ + # compatibility with haskeline >= 0.8 + (pkgs.fetchpatch { + url = "https://github.com/idris-lang/Idris-dev/commit/89a87cf666eb8b27190c779e72d0d76eadc1bc14.patch"; + sha256 = "0fv493zlpgjsf57w0sncd4vqfkabfczp3xazjjmqw54m9rsfix35"; + }) + # compatibility with megaparsec >= 0.9 + (pkgs.fetchpatch { + url = "https://github.com/idris-lang/Idris-dev/commit/6ea9bc913877d765048d7cdb7fc5aec60b196fac.patch"; + sha256 = "0yms74d1xdxd1c08dnp45nb1ddzq54n6hqgzxx0r494wy614ir8q"; + }) + ]) + )); # https://github.com/pontarius/pontarius-xmpp/issues/105 pontarius-xmpp = dontCheck super.pontarius-xmpp; diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml index e0fde52b017..f74abe73ff5 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml @@ -6996,7 +6996,6 @@ broken-packages: - identifiers - idiii - idna2008 - - idris - IDynamic - ieee-utils - iexcloud From 0ab4cdd46e941c4a73d45e0282b28ccc64540f6f Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Wed, 24 Feb 2021 02:30:34 +0100 Subject: [PATCH 19/70] hackage-packages.nix: automatic Haskell package set update This update was generated by hackage2nix v2.16.0-13-gefcfbb2 from Hackage revision https://github.com/commercialhaskell/all-cabal-hashes/commit/2542ffd97ec4140cc7c666bd9ce44831da72f489. --- .../haskell-modules/hackage-packages.nix | 848 +++++++++++++++--- 1 file changed, 715 insertions(+), 133 deletions(-) diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 806aaa867b5..efed3347736 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -23965,8 +23965,8 @@ self: { pname = "acts"; version = "0.3.1.0"; sha256 = "06bpayfa8vwj8dqlqp71nw2s9iwbffdknkk4hpazd4r1wvhnrg37"; - revision = "2"; - editedCabalFile = "1xc061cj6wxqyr79hdakmc3nnzdh46sj2sd7j9gfrvgmbipl895q"; + revision = "3"; + editedCabalFile = "01vjb8mp9ifbfknnibzc1yhimn5yli2vafpxs6adk0cdjna99g4w"; libraryHaskellDepends = [ base deepseq finitary finite-typelits groups ]; @@ -24979,8 +24979,8 @@ self: { pname = "aeson-optics"; version = "1.1.0.1"; sha256 = "1pfi84cl7w5bp7dwdhcyi8kchvbfjybqcp0sifqrn70dj2b50mf7"; - revision = "3"; - editedCabalFile = "1hxkahjf6znybqiv622n3syn5pp1a6jdpzq8ryrq9y45yczg82pi"; + revision = "4"; + editedCabalFile = "02g4438a6h2l0brvj1izagrsx9mgs1gqfds98vjzdsmamaqsm8fl"; libraryHaskellDepends = [ aeson attoparsec base base-compat bytestring optics-core optics-extra scientific text unordered-containers vector @@ -25184,6 +25184,37 @@ self: { broken = true; }) {}; + "aeson-schemas_1_3_3" = callPackage + ({ mkDerivation, aeson, aeson-qq, base, criterion, deepseq + , first-class-families, hashable, hint, interpolate, megaparsec + , QuickCheck, raw-strings-qq, tasty, tasty-golden, tasty-hunit + , tasty-quickcheck, template-haskell, text, th-orphans + , th-test-utils, unordered-containers + }: + mkDerivation { + pname = "aeson-schemas"; + version = "1.3.3"; + sha256 = "1dhi4pf8ariqr5g79cnr52rxfi1ywp2sv9sazw51rgv1k4gb3492"; + libraryHaskellDepends = [ + aeson base first-class-families hashable megaparsec + template-haskell text unordered-containers + ]; + testHaskellDepends = [ + aeson aeson-qq base deepseq first-class-families hashable hint + interpolate megaparsec QuickCheck raw-strings-qq tasty tasty-golden + tasty-hunit tasty-quickcheck template-haskell text th-orphans + th-test-utils unordered-containers + ]; + benchmarkHaskellDepends = [ + aeson base criterion deepseq first-class-families hashable + megaparsec template-haskell text th-test-utils unordered-containers + ]; + description = "Easily consume JSON data on-demand with type-safety"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "aeson-serialize" = callPackage ({ mkDerivation, aeson, base, cereal, hspec, HUnit }: mkDerivation { @@ -26523,6 +26554,52 @@ self: { broken = true; }) {}; + "algorithmic-composition-basic" = callPackage + ({ mkDerivation, base, bytestring, directory, foldable-ix + , mmsyn2-array, mmsyn3, mmsyn7l, mmsyn7ukr-common + , phonetic-languages-simplified-base, process + , ukrainian-phonetics-basic-array + }: + mkDerivation { + pname = "algorithmic-composition-basic"; + version = "0.1.1.0"; + sha256 = "0sxgysi596j77j3bfadvk6gcq9k70g0wqrq1mgxh4ypmc145psc1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring directory foldable-ix mmsyn2-array mmsyn3 mmsyn7l + mmsyn7ukr-common phonetic-languages-simplified-base process + ukrainian-phonetics-basic-array + ]; + executableHaskellDepends = [ + base bytestring directory foldable-ix mmsyn2-array mmsyn3 mmsyn7l + mmsyn7ukr-common phonetic-languages-simplified-base process + ukrainian-phonetics-basic-array + ]; + description = "Helps to create experimental music from a file (or its part) and a Ukrainian text"; + license = lib.licenses.mit; + }) {}; + + "algorithmic-composition-complex" = callPackage + ({ mkDerivation, algorithmic-composition-basic, base, bytestring + , directory, foldable-ix, mmsyn2-array, mmsyn3, mmsyn7l + , mmsyn7ukr-common, phonetic-languages-simplified-base, process + , ukrainian-phonetics-basic-array + }: + mkDerivation { + pname = "algorithmic-composition-complex"; + version = "0.1.0.0"; + sha256 = "12spldkdcjidaa95w46z5rvy1nsxn9blzhic8klkgx8jwvynixbl"; + libraryHaskellDepends = [ + algorithmic-composition-basic base bytestring directory foldable-ix + mmsyn2-array mmsyn3 mmsyn7l mmsyn7ukr-common + phonetic-languages-simplified-base process + ukrainian-phonetics-basic-array + ]; + description = "Helps to create more complex experimental music from a file (especially timbre)"; + license = lib.licenses.mit; + }) {}; + "align" = callPackage ({ mkDerivation, base, containers, transformers, vector }: mkDerivation { @@ -38087,6 +38164,21 @@ self: { license = lib.licenses.bsd3; }) {}; + "base16-lens_0_1_3_2" = callPackage + ({ mkDerivation, base, base16, bytestring, lens, text, text-short + }: + mkDerivation { + pname = "base16-lens"; + version = "0.1.3.2"; + sha256 = "04qz8gm969vlaxsk1j3rlpqph74qjkfr3rkpfkkxrfmxih6cm2fj"; + libraryHaskellDepends = [ + base base16 bytestring lens text text-short + ]; + description = "Optics for the Base16 library"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "base32" = callPackage ({ mkDerivation, base, bytestring, criterion, deepseq , ghc-byteorder, memory, QuickCheck, random-bytestring, tasty @@ -38146,6 +38238,21 @@ self: { license = lib.licenses.bsd3; }) {}; + "base32-lens_0_1_1_1" = callPackage + ({ mkDerivation, base, base32, bytestring, lens, text, text-short + }: + mkDerivation { + pname = "base32-lens"; + version = "0.1.1.1"; + sha256 = "0wam29m7vz5srrj135wmsbmg9qqhsidnwfhbicy0vmx342ai8bs6"; + libraryHaskellDepends = [ + base base32 bytestring lens text text-short + ]; + description = "Optics for the Base32 library"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "base32-z-bytestring" = callPackage ({ mkDerivation, base, bytestring, cpu, criterion, hedgehog, tasty , tasty-fail-fast, tasty-hedgehog, tasty-hspec, z-base32-bytestring @@ -38404,6 +38511,21 @@ self: { license = lib.licenses.bsd3; }) {}; + "base64-lens_0_3_1" = callPackage + ({ mkDerivation, base, base64, bytestring, lens, text, text-short + }: + mkDerivation { + pname = "base64-lens"; + version = "0.3.1"; + sha256 = "1iszvlc22h7crwqhcafy974l0l1rgxbcjf6lb5yxsvp6q66gzhrn"; + libraryHaskellDepends = [ + base base64 bytestring lens text text-short + ]; + description = "Optics for the Base64 library"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "base64-string" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -40663,6 +40785,24 @@ self: { broken = true; }) {}; + "binary-search_2_0_0" = callPackage + ({ mkDerivation, base, containers, directory, doctest, filepath + , hspec, QuickCheck, transformers + }: + mkDerivation { + pname = "binary-search"; + version = "2.0.0"; + sha256 = "13dp9wbf58k4rbr9ychf7p0zkrpzykxhh4fws741sk9mcjmrkgv7"; + libraryHaskellDepends = [ base containers transformers ]; + testHaskellDepends = [ + base directory doctest filepath hspec QuickCheck + ]; + description = "Binary and exponential searches"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "binary-serialise-cbor" = callPackage ({ mkDerivation, base, bytestring, cborg, serialise }: mkDerivation { @@ -47343,8 +47483,8 @@ self: { }: mkDerivation { pname = "byteslice"; - version = "0.2.5.0"; - sha256 = "0sl5jbfni6sx6srlfdpj0cb0pjw38cf3fyxsnaldbap2wfd3ncyr"; + version = "0.2.5.2"; + sha256 = "0nva9w086g6d7g6bjwk4ad14jz8z17m0m9fvzfxv90cx6wkmvph3"; libraryHaskellDepends = [ base bytestring primitive primitive-addr primitive-unlifted run-st tuples vector @@ -62209,16 +62349,15 @@ self: { }) {}; "connections" = callPackage - ({ mkDerivation, base, containers, finite-typelits, hedgehog - , transformers, universe-base - }: + ({ mkDerivation, base, containers, doctest, hedgehog }: mkDerivation { pname = "connections"; - version = "0.1.0"; - sha256 = "0lnskpdfgxjbkqlg82i1gxz8dsns36szyw1mv45nlq7jqspfspgp"; - libraryHaskellDepends = [ - base containers finite-typelits transformers universe-base - ]; + version = "0.2.0"; + sha256 = "1hvfqdjcj4mp2iyx0596710z4f8fm0jlgp819xf2s90rz1b360ya"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base containers ]; + executableHaskellDepends = [ base doctest ]; testHaskellDepends = [ base hedgehog ]; description = "Orders, Galois connections, and lattices"; license = lib.licenses.bsd3; @@ -71877,6 +72016,26 @@ self: { license = lib.licenses.mit; }) {}; + "declarative_0_5_4" = callPackage + ({ mkDerivation, base, hasty-hamiltonian, kan-extensions, lens + , mcmc-types, mighty-metropolis, mwc-probability, pipes, primitive + , speedy-slice, transformers + }: + mkDerivation { + pname = "declarative"; + version = "0.5.4"; + sha256 = "10dwdzl4gbxwvb068kz8kiprk18bwl79pkyhyyrmfzawf8zp3pha"; + libraryHaskellDepends = [ + base hasty-hamiltonian kan-extensions lens mcmc-types + mighty-metropolis mwc-probability pipes primitive speedy-slice + transformers + ]; + testHaskellDepends = [ base mwc-probability ]; + description = "DIY Markov Chains"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "decode-utf8" = callPackage ({ mkDerivation, api-opentheory-unicode, base, opentheory-unicode }: @@ -79877,8 +80036,8 @@ self: { }: mkDerivation { pname = "dtab"; - version = "1.1.1.1"; - sha256 = "1pxhvnm5vvgfxwm42s3w3i5nk0lx75xgsr1c487hkswip48fiyd6"; + version = "1.2"; + sha256 = "1mkk1jdw04294hljz3jxiz8403jq7srx6nalyjn1kj09yvws3d05"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -85478,6 +85637,35 @@ self: { license = lib.licenses.bsd3; }) {}; + "esqueleto_3_4_1_0" = callPackage + ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring + , conduit, containers, exceptions, hspec, monad-logger, mtl, mysql + , mysql-simple, persistent, persistent-mysql, persistent-postgresql + , persistent-sqlite, persistent-template, postgresql-libpq + , postgresql-simple, resourcet, tagged, text, time, transformers + , unliftio, unordered-containers, vector + }: + mkDerivation { + pname = "esqueleto"; + version = "3.4.1.0"; + sha256 = "1nm2xdl6an140gl5cw6ij7s6i6v2xfp98m8dwbwzns75nrgmsb73"; + libraryHaskellDepends = [ + aeson attoparsec base blaze-html bytestring conduit containers + monad-logger persistent resourcet tagged text time transformers + unliftio unordered-containers + ]; + testHaskellDepends = [ + aeson attoparsec base blaze-html bytestring conduit containers + exceptions hspec monad-logger mtl mysql mysql-simple persistent + persistent-mysql persistent-postgresql persistent-sqlite + persistent-template postgresql-libpq postgresql-simple resourcet + tagged text time transformers unliftio unordered-containers vector + ]; + description = "Type-safe EDSL for SQL queries on persistent backends"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "ess" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -98657,33 +98845,33 @@ self: { }) {}; "gemini-router" = callPackage - ({ mkDerivation, base, gemini-server, network-uri, transformers }: + ({ mkDerivation, base, gemini-server, HsOpenSSL, network-uri + , transformers + }: mkDerivation { pname = "gemini-router"; - version = "0.1.0.0"; - sha256 = "1k1fa4vi93ijj8yf1sfjgmy5kibs0z77z994pvzs1bm8sx73h8kr"; - revision = "1"; - editedCabalFile = "1pb52h8md6g422y5rj7nyy1mkgxccggfal27i42c3qsn8x9frrpz"; + version = "0.1.1.0"; + sha256 = "19aq9ri0ixkg0d5g4ickda75dvpq340lwkdxn0ndcbkis9xrvkv9"; libraryHaskellDepends = [ - base gemini-server network-uri transformers + base gemini-server HsOpenSSL network-uri transformers ]; description = "A simple Happstack-style Gemini router"; license = lib.licenses.bsd3; }) {}; "gemini-server" = callPackage - ({ mkDerivation, base, bytestring, hslogger, network, network-run - , network-uri, text, utf8-string + ({ mkDerivation, base, bytestring, hslogger, HsOpenSSL, network + , network-run, network-uri, text, utf8-string }: mkDerivation { pname = "gemini-server"; - version = "0.1.0.0"; - sha256 = "0m98dc66469gbnsra8sp0clrlbyzn817vnd7aini576g5gv4sxr5"; + version = "0.2.0.0"; + sha256 = "06sqy3c04s3cjx6p9rzfi23cq34bjs1wbigczcc66i6ahf4x1hz2"; revision = "1"; - editedCabalFile = "091wv6ar78dhhz1y6rknslxc2wh020b50n38928abl0a939gwvh9"; + editedCabalFile = "0zw9svhk5wmi56vqmw7630nqhp816xph9ldgc8l3jzspziz350fx"; libraryHaskellDepends = [ - base bytestring hslogger network network-run network-uri text - utf8-string + base bytestring hslogger HsOpenSSL network network-run network-uri + text utf8-string ]; description = "A lightweight server for the Gemini protocol"; license = lib.licenses.bsd3; @@ -99558,12 +99746,34 @@ self: { license = lib.licenses.bsd3; }) {}; + "generics-sop_0_5_1_1" = callPackage + ({ mkDerivation, base, criterion, deepseq, ghc-prim, sop-core + , template-haskell, th-abstraction + }: + mkDerivation { + pname = "generics-sop"; + version = "0.5.1.1"; + sha256 = "1n65wjdbb9fswa43ys5k6c746c905877lw5ij33y66iabj5w7dw1"; + libraryHaskellDepends = [ + base ghc-prim sop-core template-haskell th-abstraction + ]; + testHaskellDepends = [ base ]; + benchmarkHaskellDepends = [ + base criterion deepseq template-haskell + ]; + description = "Generic Programming using True Sums of Products"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "generics-sop-lens" = callPackage ({ mkDerivation, base, generics-sop, lens }: mkDerivation { pname = "generics-sop-lens"; version = "0.2.0.1"; sha256 = "1yl74pz6r2zf9sspzbqg6xvr6k9b5irq3c3pjrf5ih6hfrz4k1ks"; + revision = "1"; + editedCabalFile = "1y9v2imcrm8wyagv2d91x7zvdf358iz7460gqakhg9bgifjaylh1"; libraryHaskellDepends = [ base generics-sop lens ]; description = "Lenses for types in generics-sop"; license = lib.licenses.bsd3; @@ -101454,8 +101664,8 @@ self: { pname = "ghc-paths"; version = "0.1.0.12"; sha256 = "1164w9pqnf7rjm05mmfjznz7rrn415blrkk1kjc0gjvks1vfdjvf"; - revision = "1"; - editedCabalFile = "1gb4hn87a78j1c2y1adi81y03irzkaxywscjkphfajsxc7f0ydw5"; + revision = "2"; + editedCabalFile = "07f81larq1ddxq2m2vyq05sdhfmz0whf2c3i5cdq57pkhijxppxg"; setupHaskellDepends = [ base Cabal directory ]; libraryHaskellDepends = [ base ]; description = "Knowledge of GHC's installation directories"; @@ -101547,6 +101757,28 @@ self: { license = lib.licenses.bsd3; }) {}; + "ghc-prof_1_4_1_8" = callPackage + ({ mkDerivation, attoparsec, base, containers, directory, filepath + , process, scientific, tasty, tasty-hunit, temporary, text, time + }: + mkDerivation { + pname = "ghc-prof"; + version = "1.4.1.8"; + sha256 = "02k6il0a6cdr5dvf5x6gpjyn9vzn43kahqdsq5lzjvw5c6l0462p"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + attoparsec base containers scientific text time + ]; + testHaskellDepends = [ + attoparsec base containers directory filepath process tasty + tasty-hunit temporary text + ]; + description = "Library for parsing GHC time and allocation profiling reports"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "ghc-prof-aeson" = callPackage ({ mkDerivation, aeson, base, bytestring, hspec, text, vector }: mkDerivation { @@ -103257,8 +103489,8 @@ self: { }: mkDerivation { pname = "gi-gtk-declarative"; - version = "0.6.3"; - sha256 = "1cxh1r7ylj6d13nyjxdkvgp7h6fqzbi4zndl95lykki129jhfwkk"; + version = "0.7.0"; + sha256 = "0j6yk2qr88yrxs8vdwcqv6jzisjl0x1j932ssim8ay98z4r6y8gg"; libraryHaskellDepends = [ base containers data-default-class gi-glib gi-gobject gi-gtk haskell-gi haskell-gi-base haskell-gi-overloading mtl text @@ -103278,17 +103510,20 @@ self: { "gi-gtk-declarative-app-simple" = callPackage ({ mkDerivation, async, base, gi-gdk, gi-glib, gi-gobject, gi-gtk , gi-gtk-declarative, haskell-gi, haskell-gi-base - , haskell-gi-overloading, pipes, pipes-concurrency, text + , haskell-gi-overloading, hspec, pipes, pipes-concurrency, text }: mkDerivation { pname = "gi-gtk-declarative-app-simple"; - version = "0.6.3"; - sha256 = "1dyz6sfj352lacs3bk4lxbv9dmlpqp27kzl9vz8bq4321d5nfav9"; + version = "0.7.0"; + sha256 = "0ygp70yfj530czfw6an3yp9y883q4lwky45rxdslyf1ifk8dn6rf"; libraryHaskellDepends = [ async base gi-gdk gi-glib gi-gobject gi-gtk gi-gtk-declarative haskell-gi haskell-gi-base haskell-gi-overloading pipes pipes-concurrency text ]; + testHaskellDepends = [ + async base gi-gtk gi-gtk-declarative hspec pipes + ]; description = "Declarative GTK+ programming in Haskell in the style of Pux"; license = lib.licenses.mpl20; hydraPlatforms = lib.platforms.none; @@ -104039,8 +104274,8 @@ self: { }: mkDerivation { pname = "git-annex"; - version = "8.20210127"; - sha256 = "1hsmaw70lfza1g5j6b9zbwqkkr374m18p7qb4nl952pj42a46vv3"; + version = "8.20210223"; + sha256 = "07wxf44pdh9d1pxqympgyfbkk8vk0pqbgxma0mkadlkdr6c9z832"; configureFlags = [ "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime" "-fnetworkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser" @@ -117239,8 +117474,8 @@ self: { }: mkDerivation { pname = "hascard"; - version = "0.5.0.0"; - sha256 = "1lic3s5z3rq2m3hpf9626k8k3a8vrx267afavzvzcngkfdl3bfap"; + version = "0.5.0.1"; + sha256 = "08j3bi6a04pkkf99ghw2h7z1bdisby0d3hyqv559a1pxwpbi7k22"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -120938,26 +121173,26 @@ self: { }) {}; "haskoin-core" = callPackage - ({ mkDerivation, aeson, array, base, base16-bytestring, bytestring - , cereal, conduit, containers, cryptonite, deepseq, entropy - , hashable, hspec, hspec-discover, HUnit, lens, lens-aeson, memory - , mtl, murmur3, network, QuickCheck, safe, scientific + ({ mkDerivation, aeson, array, base, base16, binary, bytes + , bytestring, cereal, conduit, containers, cryptonite, deepseq + , entropy, hashable, hspec, hspec-discover, HUnit, lens, lens-aeson + , memory, mtl, murmur3, network, QuickCheck, safe, scientific , secp256k1-haskell, split, string-conversions, text, time , transformers, unordered-containers, vector }: mkDerivation { pname = "haskoin-core"; - version = "0.19.0"; - sha256 = "0yyrka8hr6jsl7w59j3xmnvzq4gnwz4gybjar2zq1g096shdpk7c"; + version = "0.20.0"; + sha256 = "10pdpg75r2gch32p3mkiz82qip9rwkc5lrq0zxy13pqrmxdy162k"; libraryHaskellDepends = [ - aeson array base base16-bytestring bytestring cereal conduit + aeson array base base16 binary bytes bytestring cereal conduit containers cryptonite deepseq entropy hashable hspec memory mtl murmur3 network QuickCheck safe scientific secp256k1-haskell split string-conversions text time transformers unordered-containers vector ]; testHaskellDepends = [ - aeson array base base16-bytestring bytestring cereal conduit + aeson array base base16 binary bytes bytestring cereal conduit containers cryptonite deepseq entropy hashable hspec HUnit lens lens-aeson memory mtl murmur3 network QuickCheck safe scientific secp256k1-haskell split string-conversions text time transformers @@ -121078,45 +121313,46 @@ self: { }) {}; "haskoin-store" = callPackage - ({ mkDerivation, aeson, aeson-pretty, base, base64, bytestring - , cereal, conduit, containers, data-default, deepseq, ekg-core - , ekg-statsd, filepath, foldl, hashable, haskoin-core, haskoin-node - , haskoin-store-data, hedis, hspec, hspec-discover, http-types - , lens, monad-control, monad-logger, mtl, network, nqe + ({ mkDerivation, aeson, aeson-pretty, base, base16, base64, bytes + , bytestring, cereal, conduit, containers, data-default, deepseq + , ekg-core, ekg-statsd, filepath, foldl, hashable, haskoin-core + , haskoin-node, haskoin-store-data, hedis, hspec, hspec-discover + , http-types, lens, monad-control, monad-logger, mtl, network, nqe , optparse-applicative, QuickCheck, random, rocksdb-haskell-jprupp , rocksdb-query, scotty, stm, string-conversions, text, time , transformers, unliftio, unordered-containers, wai, warp, wreq }: mkDerivation { pname = "haskoin-store"; - version = "0.46.6"; - sha256 = "13qqq08bh1a07zvd5rkfgyvh2ln0261q2hybjkjigw05mhrblf5c"; + version = "0.47.3"; + sha256 = "0z3rhxfnk1985lmfzajipkzajya2vrfh0p5c66kk03vysvssjzpi"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - aeson aeson-pretty base bytestring cereal conduit containers - data-default deepseq ekg-core ekg-statsd foldl hashable + aeson aeson-pretty base base16 bytes bytestring cereal conduit + containers data-default deepseq ekg-core ekg-statsd foldl hashable haskoin-core haskoin-node haskoin-store-data hedis http-types lens monad-control monad-logger mtl network nqe random rocksdb-haskell-jprupp rocksdb-query scotty stm string-conversions text time transformers unliftio unordered-containers wai warp wreq ]; executableHaskellDepends = [ - aeson aeson-pretty base bytestring cereal conduit containers - data-default deepseq ekg-core ekg-statsd filepath foldl hashable - haskoin-core haskoin-node haskoin-store-data hedis http-types lens - monad-control monad-logger mtl network nqe optparse-applicative - random rocksdb-haskell-jprupp rocksdb-query scotty stm - string-conversions text time transformers unliftio + aeson aeson-pretty base base16 bytes bytestring cereal conduit + containers data-default deepseq ekg-core ekg-statsd filepath foldl + hashable haskoin-core haskoin-node haskoin-store-data hedis + http-types lens monad-control monad-logger mtl network nqe + optparse-applicative random rocksdb-haskell-jprupp rocksdb-query + scotty stm string-conversions text time transformers unliftio unordered-containers wai warp wreq ]; testHaskellDepends = [ - aeson aeson-pretty base base64 bytestring cereal conduit containers - data-default deepseq ekg-core ekg-statsd foldl hashable - haskoin-core haskoin-node haskoin-store-data hedis hspec http-types - lens monad-control monad-logger mtl network nqe QuickCheck random - rocksdb-haskell-jprupp rocksdb-query scotty stm string-conversions - text time transformers unliftio unordered-containers wai warp wreq + aeson aeson-pretty base base16 base64 bytes bytestring cereal + conduit containers data-default deepseq ekg-core ekg-statsd foldl + hashable haskoin-core haskoin-node haskoin-store-data hedis hspec + http-types lens monad-control monad-logger mtl network nqe + QuickCheck random rocksdb-haskell-jprupp rocksdb-query scotty stm + string-conversions text time transformers unliftio + unordered-containers wai warp wreq ]; testToolDepends = [ hspec-discover ]; description = "Storage and index for Bitcoin and Bitcoin Cash"; @@ -121126,25 +121362,26 @@ self: { }) {}; "haskoin-store-data" = callPackage - ({ mkDerivation, aeson, base, bytestring, cereal, containers - , data-default, deepseq, hashable, haskoin-core, hspec + ({ mkDerivation, aeson, base, binary, bytes, bytestring, cereal + , containers, data-default, deepseq, hashable, haskoin-core, hspec , hspec-discover, http-client, http-types, lens, mtl, network , QuickCheck, scotty, string-conversions, text , unordered-containers, wreq }: mkDerivation { pname = "haskoin-store-data"; - version = "0.46.6"; - sha256 = "0a71gg790ix0z1q99m7cri4bpql222yprmj0vnvmacprnbihw77n"; + version = "0.47.3"; + sha256 = "0i7jf832q2lv8h82sf4y3a81j8y4ipw653q32jfnxhjjbnfxccly"; libraryHaskellDepends = [ - aeson base bytestring cereal containers data-default deepseq - hashable haskoin-core http-client http-types lens mtl network - scotty string-conversions text unordered-containers wreq + aeson base binary bytes bytestring cereal containers data-default + deepseq hashable haskoin-core http-client http-types lens mtl + network scotty string-conversions text unordered-containers wreq ]; testHaskellDepends = [ - aeson base bytestring cereal containers data-default deepseq - hashable haskoin-core hspec http-client http-types lens mtl network - QuickCheck scotty string-conversions text unordered-containers wreq + aeson base binary bytes bytestring cereal containers data-default + deepseq hashable haskoin-core hspec http-client http-types lens mtl + network QuickCheck scotty string-conversions text + unordered-containers wreq ]; testToolDepends = [ hspec-discover ]; description = "Data for Haskoin Store"; @@ -137209,8 +137446,8 @@ self: { }: mkDerivation { pname = "hspec-dirstream"; - version = "1.0.0.2"; - sha256 = "1df6rjgwj6rw78dh1ihswk7sgh72c8aqnaaj4r9k0gjq30hkdlfr"; + version = "1.0.0.3"; + sha256 = "1wzz718rw3nfzjgkigy5si7n6igjs5h8z8xsj1vhcivly4adzrrw"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base dirstream filepath hspec hspec-core pipes pipes-safe @@ -139350,10 +139587,8 @@ self: { }: mkDerivation { pname = "htoml-megaparsec"; - version = "2.1.0.3"; - sha256 = "1fpvfrib4igcmwhfms1spxr2b78srhrh4hrflrlgdgdn9x1m5w1x"; - revision = "3"; - editedCabalFile = "074r8wr9xar40ybm6wqg2s0k32kiapbjm8k3djp4lz6gjxyw7nc8"; + version = "2.1.0.4"; + sha256 = "08pka0z97b461bf45nvh9gymbvbwhn2dh70dy7x22xmzrigxnxw1"; libraryHaskellDepends = [ base composition-prelude containers deepseq megaparsec mtl text time unordered-containers vector @@ -144814,8 +145049,6 @@ self: { ]; description = "Functional Programming Language with Dependent Types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gmp;}; "ieee" = callPackage @@ -147380,6 +147613,31 @@ self: { license = lib.licenses.bsd3; }) {}; + "insert-ordered-containers_0_2_4" = callPackage + ({ mkDerivation, aeson, base, base-compat, hashable + , indexed-traversable, lens, optics-core, optics-extra, QuickCheck + , semigroupoids, semigroups, tasty, tasty-quickcheck, text + , transformers, unordered-containers + }: + mkDerivation { + pname = "insert-ordered-containers"; + version = "0.2.4"; + sha256 = "174maygil2mffjz2ssqawlmv36413m65zp3ng67hzij4dh8piz7x"; + libraryHaskellDepends = [ + aeson base base-compat hashable indexed-traversable lens + optics-core optics-extra semigroupoids semigroups text transformers + unordered-containers + ]; + testHaskellDepends = [ + aeson base base-compat hashable lens QuickCheck semigroupoids + semigroups tasty tasty-quickcheck text transformers + unordered-containers + ]; + description = "Associative containers retaining insertion order for traversals"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "inserts" = callPackage ({ mkDerivation, attoparsec, base, bytestring, dlist }: mkDerivation { @@ -174311,6 +174569,24 @@ self: { license = lib.licenses.mit; }) {}; + "mime-mail_0_5_1" = callPackage + ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring + , filepath, hspec, process, random, text + }: + mkDerivation { + pname = "mime-mail"; + version = "0.5.1"; + sha256 = "1s1wp8v1xlvw3r4qk1lv9zpm99ihka7a785zjl6i3fq1maqq955g"; + libraryHaskellDepends = [ + base base64-bytestring blaze-builder bytestring filepath process + random text + ]; + testHaskellDepends = [ base blaze-builder bytestring hspec text ]; + description = "Compose MIME email messages"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "mime-mail-ses" = callPackage ({ mkDerivation, base, base16-bytestring, base64-bytestring , byteable, bytestring, case-insensitive, conduit, cryptohash @@ -174739,8 +175015,8 @@ self: { ({ mkDerivation, async, base }: mkDerivation { pname = "minisat"; - version = "0.1.2"; - sha256 = "089jam2cbwf4m16sgb9wh4zkgbmpfsg647lng3kyjs5d3m02i5dd"; + version = "0.1.3"; + sha256 = "172l1zn3ls0s55llnp4z1kgf388bs5vq4a8qys2x7dqk9zmgpbqb"; libraryHaskellDepends = [ async base ]; description = "A Haskell bundle of the Minisat SAT solver"; license = lib.licenses.bsd3; @@ -176444,6 +176720,8 @@ self: { pname = "monad-chronicle"; version = "1.0.0.1"; sha256 = "1p9w9f5sw4adxxrgfba0vxs5kdhl82ibnwfqal7nrrhp3v86imbg"; + revision = "1"; + editedCabalFile = "097f5wvzx10i9zgx4gn7wm81z7dfyhj9lx8jyy4n90j0adpbjryq"; libraryHaskellDepends = [ base data-default-class mtl semigroupoids these transformers transformers-compat @@ -186729,21 +187007,26 @@ self: { }) {}; "nix-tree" = callPackage - ({ mkDerivation, aeson, async, base, brick, bytestring, containers - , deepseq, directory, filepath, hashable, hrfsize, lens, parallel + ({ mkDerivation, aeson, base, brick, bytestring, containers + , deepseq, directory, filepath, hashable, hedgehog, hrfsize , protolude, text, transformers, typed-process , unordered-containers, vty }: mkDerivation { pname = "nix-tree"; - version = "0.1.3.1"; - sha256 = "1rihvfvfsrkgvq87bli9gzpbv1ny93n21cf31bid1b3g3cwadffp"; + version = "0.1.4"; + sha256 = "1hbb4p6yz8c7c49yxqvzmiq9knpsm958pk9vbj12jii3ihdf0pl6"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ - aeson async base brick bytestring containers deepseq directory - filepath hashable hrfsize lens parallel protolude text transformers - typed-process unordered-containers vty + aeson base brick bytestring containers deepseq directory filepath + hashable hrfsize protolude text transformers typed-process + unordered-containers vty + ]; + testHaskellDepends = [ + aeson base brick bytestring containers deepseq directory filepath + hashable hedgehog hrfsize protolude text transformers typed-process + unordered-containers vty ]; description = "Interactively browse a Nix store paths dependencies"; license = lib.licenses.bsd3; @@ -190100,6 +190383,24 @@ self: { license = lib.licenses.bsd3; }) {}; + "one-liner_2_0" = callPackage + ({ mkDerivation, base, bifunctors, contravariant, ghc-prim, HUnit + , linear-base, profunctors, tagged, transformers + }: + mkDerivation { + pname = "one-liner"; + version = "2.0"; + sha256 = "0al9wavxx23xbalqw0cdlhq01kx8kyhg33fipwmn5617z3ddir6v"; + libraryHaskellDepends = [ + base bifunctors contravariant ghc-prim linear-base profunctors + tagged transformers + ]; + testHaskellDepends = [ base contravariant HUnit ]; + description = "Constraint-based generics"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "one-liner-instances" = callPackage ({ mkDerivation, base, one-liner, random }: mkDerivation { @@ -190626,6 +190927,8 @@ self: { pname = "openapi3"; version = "3.0.1.0"; sha256 = "03icxn4zbk6yasj6wca7qdg5cac5fadr4qcxyn4gblkffmqkb5lc"; + revision = "1"; + editedCabalFile = "017mikhl12iyrgn40mmis3m05bfjxmg9y09nsk7i8xfjzkqcnly0"; isLibrary = true; isExecutable = true; setupHaskellDepends = [ base Cabal cabal-doctest ]; @@ -191711,6 +192014,35 @@ self: { license = lib.licenses.bsd3; }) {}; + "optics_0_4" = callPackage + ({ mkDerivation, array, base, bytestring, containers, criterion + , indexed-profunctors, inspection-testing, lens, mtl, optics-core + , optics-extra, optics-th, QuickCheck, random, tasty, tasty-hunit + , tasty-quickcheck, template-haskell, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "optics"; + version = "0.4"; + sha256 = "18hdfmay7v2qsbq0ylzrfk3hrgax8bzs65bdmjrmck4is8vbs6h5"; + libraryHaskellDepends = [ + array base containers mtl optics-core optics-extra optics-th + transformers + ]; + testHaskellDepends = [ + base containers indexed-profunctors inspection-testing mtl + optics-core QuickCheck random tasty tasty-hunit tasty-quickcheck + template-haskell + ]; + benchmarkHaskellDepends = [ + base bytestring containers criterion lens transformers + unordered-containers vector + ]; + description = "Optics as an abstract interface"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "optics-core" = callPackage ({ mkDerivation, array, base, containers, indexed-profunctors , transformers @@ -191726,6 +192058,23 @@ self: { license = lib.licenses.bsd3; }) {}; + "optics-core_0_4" = callPackage + ({ mkDerivation, array, base, containers, indexed-profunctors + , indexed-traversable, transformers + }: + mkDerivation { + pname = "optics-core"; + version = "0.4"; + sha256 = "1kyxdfzha4xjym96yahrwhpbzqracks2di2lx1x34sjcn165rxry"; + libraryHaskellDepends = [ + array base containers indexed-profunctors indexed-traversable + transformers + ]; + description = "Optics as an abstract interface: core definitions"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "optics-extra" = callPackage ({ mkDerivation, array, base, bytestring, containers, hashable , indexed-profunctors, mtl, optics-core, text, transformers @@ -191735,8 +192084,8 @@ self: { pname = "optics-extra"; version = "0.3"; sha256 = "15vnznmi4h9xrrp7dk6fqgz9cwlqlmdr2h4nx1n5q6hi2ic1bmm4"; - revision = "1"; - editedCabalFile = "0bizzsgmq7b337wpraavgss7r0c5vp2n2gwl8h4xa0qxx0d1wm1p"; + revision = "2"; + editedCabalFile = "13x3mavf2bi25ns03b93b5ghhkyivwxf6idn0wqs9fdiih1xvhv8"; libraryHaskellDepends = [ array base bytestring containers hashable indexed-profunctors mtl optics-core text transformers unordered-containers vector @@ -191745,6 +192094,25 @@ self: { license = lib.licenses.bsd3; }) {}; + "optics-extra_0_4" = callPackage + ({ mkDerivation, array, base, bytestring, containers, hashable + , indexed-profunctors, indexed-traversable-instances, mtl + , optics-core, text, transformers, unordered-containers, vector + }: + mkDerivation { + pname = "optics-extra"; + version = "0.4"; + sha256 = "1ynhyw22rwvvh5yglybmb6skhpgqk4gh9w2w4dh8kb7myzcwfj1s"; + libraryHaskellDepends = [ + array base bytestring containers hashable indexed-profunctors + indexed-traversable-instances mtl optics-core text transformers + unordered-containers vector + ]; + description = "Extra utilities and instances for optics-core"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "optics-th" = callPackage ({ mkDerivation, base, containers, mtl, optics-core, tagged , template-haskell, th-abstraction, transformers @@ -191764,6 +192132,24 @@ self: { license = lib.licenses.bsd3; }) {}; + "optics-th_0_4" = callPackage + ({ mkDerivation, base, containers, mtl, optics-core, tagged + , template-haskell, th-abstraction, transformers + }: + mkDerivation { + pname = "optics-th"; + version = "0.4"; + sha256 = "1qddzwhzlhhp1902irswjj18aa5ziavn4klhy7najxjwndilb55y"; + libraryHaskellDepends = [ + base containers mtl optics-core template-haskell th-abstraction + transformers + ]; + testHaskellDepends = [ base optics-core tagged ]; + description = "Optics construction using TemplateHaskell"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "optics-vl" = callPackage ({ mkDerivation, base, indexed-profunctors, optics-core , profunctors @@ -191772,6 +192158,8 @@ self: { pname = "optics-vl"; version = "0.2.1"; sha256 = "1xrkak0cn2imgqr641wzysgynykyj438m3ywgdm9h14k17inv55v"; + revision = "1"; + editedCabalFile = "0ba6fk4djs3gm305km8c870h76mg8q1dyy899cll0scc6l9jgbyc"; libraryHaskellDepends = [ base indexed-profunctors optics-core profunctors ]; @@ -207192,14 +207580,14 @@ self: { license = lib.licenses.bsd3; }) {}; - "pretty-diff_0_4_0_0" = callPackage + "pretty-diff_0_4_0_2" = callPackage ({ mkDerivation, base, data-default, Diff, tasty, tasty-hunit , tasty-test-reporter, text }: mkDerivation { pname = "pretty-diff"; - version = "0.4.0.0"; - sha256 = "10fsa49pd0d5rvl0093x2hrcbv44hq7xc9d2x369ygd6q7pxkbnz"; + version = "0.4.0.2"; + sha256 = "0wa70is5pmad4f0spj5hmi56y290k1xizs4zwlrgry65r8c1qgns"; libraryHaskellDepends = [ base data-default Diff text ]; testHaskellDepends = [ base data-default Diff tasty tasty-hunit tasty-test-reporter text @@ -212426,10 +212814,8 @@ self: { }: mkDerivation { pname = "quantification"; - version = "0.5.1"; - sha256 = "1abr0rb3q13klrz6199gpl4d07s5y8j56i8gvpy8nqgyi7awznx9"; - revision = "1"; - editedCabalFile = "1q18l6wv57d0386p75ykkcpc18cdnzpbxdxbr5bdx02wj5v4vq8f"; + version = "0.5.2"; + sha256 = "0ngy44xlbxhq8gzvp9fs71pchzqgy2bpqqfm3wna666c1034srxf"; libraryHaskellDepends = [ aeson base binary containers ghc-prim hashable path-pieces text unordered-containers vector @@ -227685,8 +228071,8 @@ self: { }: mkDerivation { pname = "scientific-notation"; - version = "0.1.2.0"; - sha256 = "19yfg032ppiy70y28fbildxp4h6y4krs9ayh7a8sdbxibpqb82cx"; + version = "0.1.3.0"; + sha256 = "1sdqyf3538n2yz29p2b4jvafa9vlgmr3aqn2x4hifmjx0176xm03"; libraryHaskellDepends = [ base bytebuild bytesmith natural-arithmetic ]; @@ -228698,6 +229084,27 @@ self: { platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ]; }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_ttf;}; + "sdl2-ttf_2_1_2" = callPackage + ({ mkDerivation, base, bytestring, SDL2, sdl2, SDL2_ttf + , template-haskell, text, th-abstraction, transformers + }: + mkDerivation { + pname = "sdl2-ttf"; + version = "2.1.2"; + sha256 = "0jg3dg4g876shbcxlgcjwfd0g76ih3xh8f1hc79qxg6j48khxbpd"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring sdl2 template-haskell text th-abstraction + transformers + ]; + libraryPkgconfigDepends = [ SDL2 SDL2_ttf ]; + description = "Bindings to SDL2_ttf"; + license = lib.licenses.bsd3; + platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ]; + hydraPlatforms = lib.platforms.none; + }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_ttf;}; + "sdnv" = callPackage ({ mkDerivation, base, binary, bytestring }: mkDerivation { @@ -228720,6 +229127,17 @@ self: { license = lib.licenses.bsd3; }) {}; + "sdp-binary" = callPackage + ({ mkDerivation, base, binary, sdp }: + mkDerivation { + pname = "sdp-binary"; + version = "0.2"; + sha256 = "09wripyza10b7cy1w00j2vna1hmld1ijrd081faz88brkahzhdgq"; + libraryHaskellDepends = [ base binary sdp ]; + description = "Binary instances for SDP"; + license = lib.licenses.bsd3; + }) {}; + "sdp-deepseq" = callPackage ({ mkDerivation, base, deepseq, sdp }: mkDerivation { @@ -228761,6 +229179,19 @@ self: { license = lib.licenses.bsd3; }) {}; + "sdp4unordered" = callPackage + ({ mkDerivation, base, sdp, sdp-hashable, unordered-containers }: + mkDerivation { + pname = "sdp4unordered"; + version = "0.2"; + sha256 = "0y24ia2p2wsrdk05nikip369fzjh6b3jk59nss4xn4823p15vwsv"; + libraryHaskellDepends = [ + base sdp sdp-hashable unordered-containers + ]; + description = "SDP classes for unordered containers"; + license = lib.licenses.bsd3; + }) {}; + "sdp4vector" = callPackage ({ mkDerivation, base, QuickCheck, quickcheck-instances, sdp , sdp-quickcheck, test-framework, test-framework-quickcheck2 @@ -232012,6 +232443,8 @@ self: { pname = "servant-openapi3"; version = "2.0.1.1"; sha256 = "1cyzyljmdfr3gigdszcpj1i7l698fnxpc9hr83mzspm6qcmbqmgf"; + revision = "1"; + editedCabalFile = "0j2b3zv5qk5xfi17jwwn456pqpf27aqgy6fmbyqvn8df83rcij5j"; setupHaskellDepends = [ base Cabal cabal-doctest ]; libraryHaskellDepends = [ aeson aeson-pretty base base-compat bytestring hspec http-media @@ -232107,14 +232540,14 @@ self: { "servant-polysemy" = callPackage ({ mkDerivation, base, deepseq, http-client, http-client-tls, lens - , mtl, polysemy, polysemy-plugin, polysemy-zoo, servant-client - , servant-server, servant-swagger, servant-swagger-ui, swagger2 - , text, wai, warp + , mtl, polysemy, polysemy-plugin, polysemy-zoo, servant + , servant-client, servant-server, servant-swagger + , servant-swagger-ui, swagger2, text, wai, warp }: mkDerivation { pname = "servant-polysemy"; - version = "0.1.1"; - sha256 = "074c1x51am3ffl9lzhq090h8a6xd9gjf154mhp51glb4m4f6kr15"; + version = "0.1.2"; + sha256 = "05qk2kl90lqszwhi1yqnj63zkx3qvd6jbaxsxjw68k7ppsjvnyks"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -232123,7 +232556,7 @@ self: { ]; executableHaskellDepends = [ base deepseq http-client http-client-tls lens mtl polysemy - polysemy-plugin polysemy-zoo servant-client servant-server + polysemy-plugin polysemy-zoo servant servant-client servant-server servant-swagger servant-swagger-ui swagger2 text wai warp ]; description = "Utilities for using servant in a polysemy stack"; @@ -237970,6 +238403,29 @@ self: { license = lib.licenses.gpl2; }) {}; + "skylighting_0_10_3" = callPackage + ({ mkDerivation, base, binary, blaze-html, bytestring, containers + , directory, filepath, pretty-show, skylighting-core, text + }: + mkDerivation { + pname = "skylighting"; + version = "0.10.3"; + sha256 = "0bhy0y3d8czv2m92snbqqh5b8xywf74xwc1qml98vy6im0s545ad"; + configureFlags = [ "-fexecutable" ]; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary bytestring containers skylighting-core + ]; + executableHaskellDepends = [ + base blaze-html bytestring containers directory filepath + pretty-show text + ]; + description = "syntax highlighting library"; + license = lib.licenses.gpl2; + hydraPlatforms = lib.platforms.none; + }) {}; + "skylighting-core" = callPackage ({ mkDerivation, aeson, ansi-terminal, attoparsec, base , base64-bytestring, binary, blaze-html, bytestring @@ -238001,6 +238457,38 @@ self: { license = lib.licenses.bsd3; }) {}; + "skylighting-core_0_10_3" = callPackage + ({ mkDerivation, aeson, ansi-terminal, attoparsec, base + , base64-bytestring, binary, blaze-html, bytestring + , case-insensitive, colour, containers, criterion, Diff, directory + , filepath, HUnit, hxt, mtl, pretty-show, QuickCheck, random, safe + , tasty, tasty-golden, tasty-hunit, tasty-quickcheck, text + , transformers, utf8-string + }: + mkDerivation { + pname = "skylighting-core"; + version = "0.10.3"; + sha256 = "00avd17l2fqvss2cnndmina3vp809x784gdyaf1bwmkcsfnl8d3c"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson ansi-terminal attoparsec base base64-bytestring binary + blaze-html bytestring case-insensitive colour containers directory + filepath hxt mtl safe text transformers utf8-string + ]; + testHaskellDepends = [ + aeson base bytestring containers Diff directory filepath HUnit + pretty-show QuickCheck random tasty tasty-golden tasty-hunit + tasty-quickcheck text utf8-string + ]; + benchmarkHaskellDepends = [ + base containers criterion directory filepath text + ]; + description = "syntax highlighting library"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "skylighting-extensions" = callPackage ({ mkDerivation, base, containers, skylighting, skylighting-modding , text @@ -242874,6 +243362,8 @@ self: { pname = "split"; version = "0.2.3.4"; sha256 = "0ahzdjcxw5wywr3w4msspia99k6fkckddam1m5506h4z9h8fa7r7"; + revision = "1"; + editedCabalFile = "06pmlvyrz4rr7rsrghpyrdypprphm9522rvnz4l3i8333n4pb304"; libraryHaskellDepends = [ base ]; testHaskellDepends = [ base QuickCheck ]; description = "Combinator library for splitting lists"; @@ -247977,8 +248467,8 @@ self: { ({ mkDerivation, base, lens, strict }: mkDerivation { pname = "strict-lens"; - version = "0.4.0.1"; - sha256 = "0hwrbrjhgkh83474mci3ipg8nqims7b18w7i6xajz3xxq3cik5vn"; + version = "0.4.0.2"; + sha256 = "1dsgr53q0sdivrxc7jmbqjd65hav9zwjqc8zfbyybkr1ww17bhf5"; libraryHaskellDepends = [ base lens strict ]; description = "Lenses for types in strict package"; license = lib.licenses.bsd3; @@ -248007,6 +248497,8 @@ self: { pname = "strict-optics"; version = "0.4.0.1"; sha256 = "1x4p2fksljd9xfy4mxdz5pxcskxz2qg2ma28d6y4j2v4728r0x8a"; + revision = "1"; + editedCabalFile = "1rlkslqkicw7zzmy88kvbnlcyyx2afm3vs8y51gazz1bs0b73p0f"; libraryHaskellDepends = [ base optics-core strict ]; description = "Optics for types in strict package"; license = lib.licenses.bsd3; @@ -249502,8 +249994,8 @@ self: { ({ mkDerivation, base }: mkDerivation { pname = "successors"; - version = "0.1.0.1"; - sha256 = "1m5flnn2rswc3380dccnfnhmyjp1dqr23dljd0515jxawbgjkzmg"; + version = "0.1.0.2"; + sha256 = "0q6sfxxzc0ws1iky79iyx7sf7l3jqdwxz9ngsi11km1bp7rd8ycw"; libraryHaskellDepends = [ base ]; description = "An applicative functor to manage successors"; license = lib.licenses.mit; @@ -250663,11 +251155,12 @@ self: { "swisstable" = callPackage ({ mkDerivation, base, criterion, deepseq, hashable, hashtables , primitive, QuickCheck, tasty, tasty-discover, tasty-hunit, vector + , weigh }: mkDerivation { pname = "swisstable"; - version = "0.1.0.2"; - sha256 = "0zffsavnxnwhzxgbwpqg38gnjywgfdk60hbg0wvpggk1zaw0ylr1"; + version = "0.1.0.3"; + sha256 = "1d1vk1j8r2lwxkx2l4l1fmm8z9ascp7hq52al7qjn4bir177b92q"; libraryHaskellDepends = [ base hashable primitive vector ]; testHaskellDepends = [ base hashable primitive QuickCheck tasty tasty-discover tasty-hunit @@ -250676,7 +251169,7 @@ self: { testToolDepends = [ tasty-discover ]; benchmarkHaskellDepends = [ base criterion deepseq hashable hashtables primitive QuickCheck - vector + vector weigh ]; description = "SwissTable hash map"; license = lib.licenses.bsd3; @@ -253425,6 +253918,19 @@ self: { license = lib.licenses.bsd3; }) {}; + "tardis_0_4_3_0" = callPackage + ({ mkDerivation, base, mmorph, mtl }: + mkDerivation { + pname = "tardis"; + version = "0.4.3.0"; + sha256 = "1ffmpdvnmr1s3rh3kpqqscsbz2rq4s7k8nfc93zw9m4mchg37waw"; + libraryHaskellDepends = [ base mmorph mtl ]; + testHaskellDepends = [ base ]; + description = "Bidirectional state monad transformer"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "target" = callPackage ({ mkDerivation, aeson, array, base, bytestring, cassava , containers, data-timeout, deepseq, directory, exceptions @@ -265374,16 +265880,17 @@ self: { }) {}; "twee" = callPackage - ({ mkDerivation, base, containers, jukebox, pretty, split, twee-lib + ({ mkDerivation, ansi-terminal, base, containers, jukebox, pretty + , split, symbol, twee-lib }: mkDerivation { pname = "twee"; - version = "2.2"; - sha256 = "0wmjmgkf5piwqzrk08ij7mc3s82gpg7j5x4bk96njj06gm4lc38v"; + version = "2.3"; + sha256 = "1fg8khaa5zkfyh2jawh2m7jyy3a4kbd755qa09gwg9b7y9wijamr"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ - base containers jukebox pretty split twee-lib + ansi-terminal base containers jukebox pretty split symbol twee-lib ]; description = "An equational theorem prover"; license = lib.licenses.bsd3; @@ -265393,14 +265900,15 @@ self: { "twee-lib" = callPackage ({ mkDerivation, base, containers, dlist, ghc-prim, pretty - , primitive, transformers, vector + , primitive, random, transformers, uglymemo, vector }: mkDerivation { pname = "twee-lib"; - version = "2.2"; - sha256 = "0v99hhnxpzi5581s4bfxhbpnmvlbqnrrr3pdkfvicz2b146mhhgr"; + version = "2.3"; + sha256 = "1ba98apscp1f4k9917an27aqymnr8gj8pkwj7g2ci02fh7dan9b9"; libraryHaskellDepends = [ - base containers dlist ghc-prim pretty primitive transformers vector + base containers dlist ghc-prim pretty primitive random transformers + uglymemo vector ]; description = "An equational theorem prover"; license = lib.licenses.bsd3; @@ -268772,8 +269280,8 @@ self: { ({ mkDerivation, base, containers, logict, mtl }: mkDerivation { pname = "unification-fd"; - version = "0.10.0.1"; - sha256 = "15hrnmgr0pqq43fwgxc168r08xjgfhr2nchmz5blq46vwrh6gx2v"; + version = "0.11.0"; + sha256 = "1agfnp94n6lgqb0g5v4vzdkpzcz74niw659ss6a03d5qghr1r6l4"; libraryHaskellDepends = [ base containers logict mtl ]; description = "Simple generic unification algorithms"; license = lib.licenses.bsd3; @@ -273481,12 +273989,12 @@ self: { license = lib.licenses.bsd3; }) {}; - "vector-th-unbox_0_2_1_8" = callPackage + "vector-th-unbox_0_2_1_9" = callPackage ({ mkDerivation, base, data-default, template-haskell, vector }: mkDerivation { pname = "vector-th-unbox"; - version = "0.2.1.8"; - sha256 = "1b6lx1n96b17xsc7mzvcj6k3fzf7xjghrrv77i94x9356hkab765"; + version = "0.2.1.9"; + sha256 = "0jbzm31d91kxn8m0h6iplj54h756q6f4zzdrnb2w7rzz5zskgqyl"; libraryHaskellDepends = [ base template-haskell vector ]; testHaskellDepends = [ base data-default vector ]; description = "Deriver for Data.Vector.Unboxed using Template Haskell"; @@ -273788,6 +274296,27 @@ self: { license = lib.licenses.bsd3; }) {}; + "versions_4_0_3" = callPackage + ({ mkDerivation, base, deepseq, hashable, megaparsec, microlens + , parser-combinators, QuickCheck, tasty, tasty-hunit + , tasty-quickcheck, text + }: + mkDerivation { + pname = "versions"; + version = "4.0.3"; + sha256 = "0rp62aih4blpahymqlkrfzywdqb1mkhy6f021vp74ljknpch4scf"; + libraryHaskellDepends = [ + base deepseq hashable megaparsec parser-combinators text + ]; + testHaskellDepends = [ + base megaparsec microlens QuickCheck tasty tasty-hunit + tasty-quickcheck text + ]; + description = "Types and parsers for software version numbers"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "vflow-types" = callPackage ({ mkDerivation, aeson, base, bytestring, ip, json-alt , json-autotype, neat-interpolation, QuickCheck, quickcheck-classes @@ -274823,6 +275352,42 @@ self: { license = lib.licenses.bsd3; }) {}; + "vty_5_33" = callPackage + ({ mkDerivation, ansi-terminal, base, binary, blaze-builder + , bytestring, Cabal, containers, deepseq, directory, filepath + , hashable, HUnit, microlens, microlens-mtl, microlens-th, mtl + , parallel, parsec, QuickCheck, quickcheck-assertions, random + , smallcheck, stm, string-qq, terminfo, test-framework + , test-framework-hunit, test-framework-smallcheck, text + , transformers, unix, utf8-string, vector + }: + mkDerivation { + pname = "vty"; + version = "5.33"; + sha256 = "0qsx4lwlkp6mwyr7rm1r9dg5ic1lc1awqgyag0nj1qgj2gnv6nc9"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ansi-terminal base binary blaze-builder bytestring containers + deepseq directory filepath hashable microlens microlens-mtl + microlens-th mtl parallel parsec stm terminfo text transformers + unix utf8-string vector + ]; + executableHaskellDepends = [ + base containers directory filepath microlens microlens-mtl mtl + ]; + testHaskellDepends = [ + base blaze-builder bytestring Cabal containers deepseq HUnit + microlens microlens-mtl mtl QuickCheck quickcheck-assertions random + smallcheck stm string-qq terminfo test-framework + test-framework-hunit test-framework-smallcheck text unix + utf8-string vector + ]; + description = "A simple terminal UI library"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "vty-examples" = callPackage ({ mkDerivation, array, base, bytestring, Cabal, containers , data-default, deepseq, lens, mtl, parallel, parsec, QuickCheck @@ -283892,6 +284457,23 @@ self: { broken = true; }) {}; + "yahoo-prices" = callPackage + ({ mkDerivation, base, bytestring, cassava, hspec, lens, QuickCheck + , time, vector, wreq + }: + mkDerivation { + pname = "yahoo-prices"; + version = "0.1.0.1"; + sha256 = "0r0cjhnbskhyfswzv37vfichvpsay2n0pi4bwyis52szddhn4cxx"; + libraryHaskellDepends = [ + base bytestring cassava lens time vector wreq + ]; + testHaskellDepends = [ base bytestring hspec QuickCheck time ]; + doHaddock = false; + description = "A wrapper around Yahoo API for downloading market data"; + license = lib.licenses.mit; + }) {}; + "yahoo-web-search" = callPackage ({ mkDerivation, base, HTTP, network, xml }: mkDerivation { From cd98de0816ea0ea159f4e09cc3509b5085579a8a Mon Sep 17 00:00:00 2001 From: Masanori Ogino <167209+omasanori@users.noreply.github.com> Date: Wed, 24 Feb 2021 04:02:47 +0900 Subject: [PATCH 20/70] foundationdb60: fix build - Add missing #include, mainly - Add missing 'std::' - Remove prototype conflicting with the libc's definition Signed-off-by: Masanori Ogino <167209+omasanori@users.noreply.github.com> --- pkgs/servers/foundationdb/default.nix | 1 + .../patches/include-fixes-6.0.patch | 137 ++++++++++++++++++ 2 files changed, 138 insertions(+) create mode 100644 pkgs/servers/foundationdb/patches/include-fixes-6.0.patch diff --git a/pkgs/servers/foundationdb/default.nix b/pkgs/servers/foundationdb/default.nix index 10d517179c2..e1cb2e29a05 100644 --- a/pkgs/servers/foundationdb/default.nix +++ b/pkgs/servers/foundationdb/default.nix @@ -69,6 +69,7 @@ in with builtins; { patches = [ ./patches/ldflags-6.0.patch + ./patches/include-fixes-6.0.patch ]; }; diff --git a/pkgs/servers/foundationdb/patches/include-fixes-6.0.patch b/pkgs/servers/foundationdb/patches/include-fixes-6.0.patch new file mode 100644 index 00000000000..93959def44f --- /dev/null +++ b/pkgs/servers/foundationdb/patches/include-fixes-6.0.patch @@ -0,0 +1,137 @@ +diff --git a/fdbrpc/ContinuousSample.h b/fdbrpc/ContinuousSample.h +index 54ff1b109..577c228ae 100644 +--- a/fdbrpc/ContinuousSample.h ++++ b/fdbrpc/ContinuousSample.h +@@ -26,6 +26,7 @@ + #include "flow/IRandom.h" + #include + #include ++#include + + template + class ContinuousSample { +diff --git a/fdbrpc/Smoother.h b/fdbrpc/Smoother.h +index 3ed8e6e98..f3e4504b6 100644 +--- a/fdbrpc/Smoother.h ++++ b/fdbrpc/Smoother.h +@@ -23,6 +23,7 @@ + #pragma once + + #include "flow/flow.h" ++#include + + struct Smoother { + // Times (t) are expected to be nondecreasing +@@ -50,7 +51,7 @@ struct Smoother { + double elapsed = t - time; + if(elapsed) { + time = t; +- estimate += (total-estimate) * (1-exp( -elapsed/eFoldingTime )); ++ estimate += (total-estimate) * (1-std::exp( -elapsed/eFoldingTime )); + } + } + +@@ -83,11 +84,11 @@ struct TimerSmoother { + void update(double t) { + double elapsed = t - time; + time = t; +- estimate += (total-estimate) * (1-exp( -elapsed/eFoldingTime )); ++ estimate += (total-estimate) * (1-std::exp( -elapsed/eFoldingTime )); + } + + double eFoldingTime; + double time, total, estimate; + }; + +-#endif +\ No newline at end of file ++#endif +diff --git a/fdbserver/Knobs.cpp b/fdbserver/Knobs.cpp +index a924bc905..0dc70e7ac 100644 +--- a/fdbserver/Knobs.cpp ++++ b/fdbserver/Knobs.cpp +@@ -20,6 +20,7 @@ + + #include "Knobs.h" + #include "fdbrpc/Locality.h" ++#include + + ServerKnobs const* SERVER_KNOBS = new ServerKnobs(); + +diff --git a/flow/Knobs.cpp b/flow/Knobs.cpp +index 2d706dddd..5dbe08861 100644 +--- a/flow/Knobs.cpp ++++ b/flow/Knobs.cpp +@@ -20,6 +20,7 @@ + + #include "Knobs.h" + #include "flow/flow.h" ++#include + + FlowKnobs const* FLOW_KNOBS = new FlowKnobs(); + +@@ -128,7 +129,7 @@ FlowKnobs::FlowKnobs(bool randomize, bool isSimulated) { + init( MAX_METRICS, 600 ); + init( MAX_METRIC_SIZE, 2500 ); + init( MAX_METRIC_LEVEL, 25 ); +- init( METRIC_LEVEL_DIVISOR, log(4) ); ++ init( METRIC_LEVEL_DIVISOR, std::log(4) ); + init( METRIC_LIMIT_START_QUEUE_SIZE, 10 ); // The queue size at which to start restricting logging by disabling levels + init( METRIC_LIMIT_RESPONSE_FACTOR, 10 ); // The additional queue size at which to disable logging of another level (higher == less restrictive) + +diff --git a/flow/Platform.cpp b/flow/Platform.cpp +index a754c8747..4d47fad32 100644 +--- a/flow/Platform.cpp ++++ b/flow/Platform.cpp +@@ -98,6 +98,8 @@ + #include + /* Needed for crash handler */ + #include ++/* Needed for major() and minor() with recent glibc */ ++#include + #endif + + #ifdef __APPLE__ +diff --git a/flow/Profiler.actor.cpp b/flow/Profiler.actor.cpp +index 4603dcb77..78eda7278 100644 +--- a/flow/Profiler.actor.cpp ++++ b/flow/Profiler.actor.cpp +@@ -35,8 +35,6 @@ + + extern volatile int profilingEnabled; + +-static uint64_t gettid() { return syscall(__NR_gettid); } +- + struct SignalClosure { + void (* func)(int, siginfo_t*, void*, void*); + void *userdata; +diff --git a/flow/TDMetric.actor.h b/flow/TDMetric.actor.h +index 306352c39..fc63e12f9 100755 +--- a/flow/TDMetric.actor.h ++++ b/flow/TDMetric.actor.h +@@ -35,6 +35,7 @@ + #include "genericactors.actor.h" + #include "CompressedInt.h" + #include ++#include + #include + + struct MetricNameRef { +@@ -799,7 +800,7 @@ struct EventMetric : E, ReferenceCounted>, MetricUtilMAX_METRIC_LEVEL-1; + else +- l = std::min(FLOW_KNOBS->MAX_METRIC_LEVEL-1, (int64_t)(::log(1.0/x) / FLOW_KNOBS->METRIC_LEVEL_DIVISOR)); ++ l = std::min(FLOW_KNOBS->MAX_METRIC_LEVEL-1, (int64_t)(std::log(1.0/x) / FLOW_KNOBS->METRIC_LEVEL_DIVISOR)); + + if(!canLog(l)) + return 0; +@@ -1274,7 +1275,7 @@ public: + l = std::min( + FLOW_KNOBS->MAX_METRIC_LEVEL-1, + (int64_t)( +- log((toggleTime - tv.time) / x) / ++ std::log((toggleTime - tv.time) / x) / + FLOW_KNOBS->METRIC_LEVEL_DIVISOR + ) + ); From 116108e2b690e716e1c5f349d5c92c5d2963b1ae Mon Sep 17 00:00:00 2001 From: Dmitry Kalinkin Date: Tue, 23 Feb 2021 23:56:37 -0500 Subject: [PATCH 21/70] herwig: 7.2.1 -> 7.2.2 thepeg: 2.2.1 -> 2.2.2 --- pkgs/development/libraries/physics/herwig/default.nix | 4 ++-- pkgs/development/libraries/physics/thepeg/default.nix | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/pkgs/development/libraries/physics/herwig/default.nix b/pkgs/development/libraries/physics/herwig/default.nix index d3f6bcb7474..69a8c781d5b 100644 --- a/pkgs/development/libraries/physics/herwig/default.nix +++ b/pkgs/development/libraries/physics/herwig/default.nix @@ -2,11 +2,11 @@ stdenv.mkDerivation rec { pname = "herwig"; - version = "7.2.1"; + version = "7.2.2"; src = fetchurl { url = "https://www.hepforge.org/archive/herwig/Herwig-${version}.tar.bz2"; - sha256 = "11m6xvardnk0i8x8b3dpwg4c4ncq0xmlfg2n5r5qmh6544pz7zyl"; + sha256 = "10y3fb33zsinr0z3hzap9rsbcqhy1yjqnv4b4vz21g7mdlw6pq2k"; }; nativeBuildInputs = [ autoconf automake libtool ]; diff --git a/pkgs/development/libraries/physics/thepeg/default.nix b/pkgs/development/libraries/physics/thepeg/default.nix index d5a272955f4..031277f8e0c 100644 --- a/pkgs/development/libraries/physics/thepeg/default.nix +++ b/pkgs/development/libraries/physics/thepeg/default.nix @@ -2,11 +2,11 @@ stdenv.mkDerivation rec { pname = "thepeg"; - version = "2.2.1"; + version = "2.2.2"; src = fetchurl { url = "https://www.hepforge.org/archive/thepeg/ThePEG-${version}.tar.bz2"; - sha256 = "13x5gssv22mpa2w6i0vaalwcr57170vh3b4xrw8mrm3abqhwgav3"; + sha256 = "0gif4vb9lw2px2qdywqm7x0frbv0h5gq9lq36c50f2hv77a5bgwp"; }; buildInputs = [ boost fastjet gsl hepmc2 lhapdf rivet zlib ]; From 669c286d27cfc2c6a5a714b94fc0f8c1871fa835 Mon Sep 17 00:00:00 2001 From: Dmitry Kalinkin Date: Wed, 24 Feb 2021 00:30:11 -0500 Subject: [PATCH 22/70] herwig,thepeg: mark as gpl3Only --- pkgs/development/libraries/physics/herwig/default.nix | 2 +- pkgs/development/libraries/physics/thepeg/default.nix | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/libraries/physics/herwig/default.nix b/pkgs/development/libraries/physics/herwig/default.nix index 69a8c781d5b..0a7e9b4d948 100644 --- a/pkgs/development/libraries/physics/herwig/default.nix +++ b/pkgs/development/libraries/physics/herwig/default.nix @@ -28,7 +28,7 @@ stdenv.mkDerivation rec { meta = with lib; { description = "A multi-purpose particle physics event generator"; homepage = "https://herwig.hepforge.org/"; - license = licenses.gpl3; + license = licenses.gpl3Only; maintainers = with maintainers; [ veprbl ]; platforms = platforms.unix; broken = stdenv.isAarch64; # doesn't compile: ignoring return value of 'FILE* freopen... diff --git a/pkgs/development/libraries/physics/thepeg/default.nix b/pkgs/development/libraries/physics/thepeg/default.nix index 031277f8e0c..ed92889b5b2 100644 --- a/pkgs/development/libraries/physics/thepeg/default.nix +++ b/pkgs/development/libraries/physics/thepeg/default.nix @@ -22,7 +22,7 @@ stdenv.mkDerivation rec { meta = with lib; { description = "Toolkit for High Energy Physics Event Generation"; homepage = "https://herwig.hepforge.org/"; - license = licenses.gpl3; + license = licenses.gpl3Only; maintainers = with maintainers; [ veprbl ]; platforms = platforms.unix; }; From 2c7b8290c629460edea2f08fb80f827934420e3e Mon Sep 17 00:00:00 2001 From: Vladimir Serov Date: Thu, 25 Feb 2021 00:35:31 +0300 Subject: [PATCH 23/70] atom: 1.48.0 -> 1.54.0 --- pkgs/applications/editors/atom/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/editors/atom/default.nix b/pkgs/applications/editors/atom/default.nix index e7a9a26f066..87bb235a481 100644 --- a/pkgs/applications/editors/atom/default.nix +++ b/pkgs/applications/editors/atom/default.nix @@ -3,8 +3,8 @@ let versions = { atom = { - version = "1.48.0"; - sha256 = "1693bxbylf6jhld9bdcr5pigk36wqlbj89praldpz9s96yxig9s1"; + version = "1.54.0"; + sha256 = "sha256-21AURgomEjuiTzeJ4MIx0mkyVi0b0mVdmFsFGNLXRP4"; }; atom-beta = { From a4c39dea04de9f39363b2da8aeaf66698e7defb5 Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Thu, 25 Feb 2021 02:30:25 +0100 Subject: [PATCH 24/70] hackage-packages.nix: automatic Haskell package set update This update was generated by hackage2nix v2.16.0-13-gefcfbb2 from Hackage revision https://github.com/commercialhaskell/all-cabal-hashes/commit/39ba3e58bb7d2a43df9b7c402c5393ccdc88fd00. --- .../haskell-modules/hackage-packages.nix | 269 ++++++++++++++++-- 1 file changed, 251 insertions(+), 18 deletions(-) diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index efed3347736..5dc81e6aab8 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -9420,6 +9420,43 @@ self: { broken = true; }) {}; + "HTF_0_14_0_6" = callPackage + ({ mkDerivation, aeson, aeson-pretty, array, base + , base64-bytestring, bytestring, Cabal, containers, cpphs, Diff + , directory, filepath, haskell-src, HUnit, lifted-base + , monad-control, mtl, old-time, pretty, process, QuickCheck, random + , regex-compat, template-haskell, temporary, text, time, unix + , unordered-containers, vector, xmlgen + }: + mkDerivation { + pname = "HTF"; + version = "0.14.0.6"; + sha256 = "0lm4va3nnb9yli56vfkj7h816k0cnrdjnd3d9x44m706bh3avksq"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal process ]; + libraryHaskellDepends = [ + aeson array base base64-bytestring bytestring containers cpphs Diff + directory haskell-src HUnit lifted-base monad-control mtl old-time + pretty process QuickCheck random regex-compat text time unix vector + xmlgen + ]; + libraryToolDepends = [ cpphs ]; + executableHaskellDepends = [ + array base cpphs directory HUnit mtl old-time random text + ]; + executableToolDepends = [ cpphs ]; + testHaskellDepends = [ + aeson aeson-pretty base bytestring directory filepath HUnit mtl + process random regex-compat template-haskell temporary text + unordered-containers + ]; + description = "The Haskell Test Framework"; + license = lib.licenses.lgpl21; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "HTTP" = callPackage ({ mkDerivation, array, base, bytestring, deepseq, httpd-shed , HUnit, mtl, network, network-uri, parsec, pureMD5, split @@ -26600,6 +26637,22 @@ self: { license = lib.licenses.mit; }) {}; + "algorithmic-composition-frequency-shift" = callPackage + ({ mkDerivation, algorithmic-composition-basic, base, directory + , doublezip, mmsyn3, mmsyn7l, process + }: + mkDerivation { + pname = "algorithmic-composition-frequency-shift"; + version = "0.1.0.0"; + sha256 = "0m7pjxczi3w7r3srq76b30xjiqv9w6238xl2hm7s8gwnam8ha7r5"; + libraryHaskellDepends = [ + algorithmic-composition-basic base directory doublezip mmsyn3 + mmsyn7l process + ]; + description = "Helps to create experimental music. Uses SoX inside."; + license = lib.licenses.mit; + }) {}; + "align" = callPackage ({ mkDerivation, base, containers, transformers, vector }: mkDerivation { @@ -31967,6 +32020,38 @@ self: { license = lib.licenses.bsd3; }) {}; + "apply-refact_0_9_1_0" = callPackage + ({ mkDerivation, base, containers, directory, extra, filemanip + , filepath, ghc, ghc-boot-th, ghc-exactprint, optparse-applicative + , process, refact, silently, syb, tasty, tasty-expected-failure + , tasty-golden, transformers, uniplate, unix-compat + }: + mkDerivation { + pname = "apply-refact"; + version = "0.9.1.0"; + sha256 = "1b9ib5ix643aagzsw5vk8d789a784pggsm6qv36bxkcsx89s2bjm"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers directory extra filemanip ghc ghc-boot-th + ghc-exactprint process refact syb transformers uniplate unix-compat + ]; + executableHaskellDepends = [ + base containers directory extra filemanip filepath ghc ghc-boot-th + ghc-exactprint optparse-applicative process refact syb transformers + uniplate unix-compat + ]; + testHaskellDepends = [ + base containers directory extra filemanip filepath ghc ghc-boot-th + ghc-exactprint optparse-applicative process refact silently syb + tasty tasty-expected-failure tasty-golden transformers uniplate + unix-compat + ]; + description = "Perform refactorings specified by the refact library"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "apportionment" = callPackage ({ mkDerivation, base, containers, utility-ht }: mkDerivation { @@ -33117,8 +33202,8 @@ self: { }: mkDerivation { pname = "array-chunks"; - version = "0.1.2.0"; - sha256 = "0x2hkc587ki4ncpsdrhby04dr4gxvf0v5qj5kda7kfl2814srixi"; + version = "0.1.3.0"; + sha256 = "0alf0d4ifla7i47pl7xqmrhcwsky56rp4b76qgmh19kji8mfcq5z"; libraryHaskellDepends = [ base primitive run-st ]; testHaskellDepends = [ base primitive QuickCheck quickcheck-classes tasty tasty-hunit @@ -79160,6 +79245,17 @@ self: { license = "GPL"; }) {}; + "doublezip" = callPackage + ({ mkDerivation, base, foldable-ix }: + mkDerivation { + pname = "doublezip"; + version = "0.1.0.0"; + sha256 = "0bf9jb688kj5f0cjb2ma6744aj2hkslkpc96frljm73h6pyqvwz6"; + libraryHaskellDepends = [ base foldable-ix ]; + description = "Some special functions to work with lists (with zip)"; + license = lib.licenses.mit; + }) {}; + "doublify-toolkit" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -79583,17 +79679,16 @@ self: { }) {}; "drama" = callPackage - ({ mkDerivation, base, criterion, ki, transformers, unagi-chan }: + ({ mkDerivation, base, ki, transformers, unagi-chan }: mkDerivation { pname = "drama"; - version = "0.2.0.0"; - sha256 = "00blv7fi0ibvjc2qqn30ybhsshbzsdpkjp32fhg1m7h7wvlzi312"; + version = "0.3.0.0"; + sha256 = "17smzrvpaah2lcc2467dd61lns53q4n0bf0pl9glsv04j9kv2nl9"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base ki transformers unagi-chan ]; executableHaskellDepends = [ base ]; - benchmarkHaskellDepends = [ base criterion ]; - description = "Simple actor library for Haskell"; + description = "Actor library for Haskell"; license = lib.licenses.bsd3; }) {}; @@ -101251,6 +101346,30 @@ self: { license = lib.licenses.bsd3; }) {}; + "ghc-exactprint_0_6_4" = callPackage + ({ mkDerivation, base, bytestring, containers, Diff, directory + , filemanip, filepath, free, ghc, ghc-boot, ghc-paths, HUnit, mtl + , silently, syb + }: + mkDerivation { + pname = "ghc-exactprint"; + version = "0.6.4"; + sha256 = "0a6baza962d4pz2m02hxmh8234i47zkizmwhsy68namr05dmlgpw"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers directory filepath free ghc ghc-boot + ghc-paths mtl syb + ]; + testHaskellDepends = [ + base bytestring containers Diff directory filemanip filepath ghc + ghc-boot ghc-paths HUnit mtl silently syb + ]; + description = "ExactPrint for GHC"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "ghc-gc-tune" = callPackage ({ mkDerivation, base, directory, filepath, process }: mkDerivation { @@ -140230,6 +140349,8 @@ self: { pname = "http-date"; version = "0.0.10"; sha256 = "1g3b895894mrscnm32x3a2nax3xvsp8aji11f0qd44xh7kz249zs"; + revision = "1"; + editedCabalFile = "13pq2x29pzh6ylp2crs33q9nkawwymaim6ma4x6hf0s3qdr7vzfh"; libraryHaskellDepends = [ array attoparsec base bytestring time ]; testHaskellDepends = [ base bytestring doctest hspec old-locale time @@ -140238,6 +140359,23 @@ self: { license = lib.licenses.bsd3; }) {}; + "http-date_0_0_11" = callPackage + ({ mkDerivation, array, attoparsec, base, bytestring, doctest + , hspec, old-locale, time + }: + mkDerivation { + pname = "http-date"; + version = "0.0.11"; + sha256 = "1lzlrj2flcnz3k5kfhf11nk5n8m6kcya0lkwrsnzxgfr3an27y9j"; + libraryHaskellDepends = [ array attoparsec base bytestring time ]; + testHaskellDepends = [ + base bytestring doctest hspec old-locale time + ]; + description = "HTTP Date parser/formatter"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "http-directory" = callPackage ({ mkDerivation, base, bytestring, hspec, html-conduit, http-client , http-client-tls, http-date, http-types, network-uri, text, time @@ -141966,6 +142104,22 @@ self: { broken = true; }) {}; + "hw-aws-sqs-conduit" = callPackage + ({ mkDerivation, amazonka, amazonka-sqs, base, conduit, lens, mtl + , text + }: + mkDerivation { + pname = "hw-aws-sqs-conduit"; + version = "0.1.0.0"; + sha256 = "112nf8yqpb0cl4vb7h21r0nf13hz5419vkk2z5235db75ap6bbcc"; + libraryHaskellDepends = [ + amazonka amazonka-sqs base conduit lens mtl text + ]; + testHaskellDepends = [ base ]; + description = "AWS SQS conduit"; + license = lib.licenses.bsd3; + }) {}; + "hw-balancedparens" = callPackage ({ mkDerivation, base, bytestring, criterion, deepseq, directory , doctest, doctest-discover, generic-lens, hedgehog, hspec @@ -142702,6 +142856,21 @@ self: { license = lib.licenses.bsd3; }) {}; + "hw-playground-linear" = callPackage + ({ mkDerivation, base, hedgehog, hmatrix, hmatrix-csv, hspec + , hspec-discover, hw-hspec-hedgehog, text + }: + mkDerivation { + pname = "hw-playground-linear"; + version = "0.1.0.0"; + sha256 = "039bkjgwa14v9qjmblipv4qd19lg3y2qn78khv0rbqka1haxnhn9"; + libraryHaskellDepends = [ base hmatrix hmatrix-csv text ]; + testHaskellDepends = [ base hedgehog hspec hw-hspec-hedgehog ]; + testToolDepends = [ hspec-discover ]; + description = "Primitive functions and data types"; + license = lib.licenses.bsd3; + }) {}; + "hw-prim" = callPackage ({ mkDerivation, base, bytestring, criterion, deepseq, directory , doctest, doctest-discover, exceptions, ghc-prim, hedgehog, hspec @@ -160668,7 +160837,7 @@ self: { license = lib.licenses.bsd2; }) {}; - "lens_5" = callPackage + "lens_5_0_1" = callPackage ({ mkDerivation, array, assoc, base, base-compat, base-orphans , bifunctors, bytestring, call-stack, comonad, containers , contravariant, criterion, deepseq, distributive, exceptions @@ -160682,8 +160851,8 @@ self: { }: mkDerivation { pname = "lens"; - version = "5"; - sha256 = "06nvmg9aan4s4ldq3c2a4z15r29hsxyvbjid2yvskmlw5pvwpncy"; + version = "5.0.1"; + sha256 = "0gzwx4b758phm51hz5i4bbkbvjw1ka7qj04zd9l9sh9n6s9ksm7c"; libraryHaskellDepends = [ array assoc base base-orphans bifunctors bytestring call-stack comonad containers contravariant distributive exceptions filepath @@ -215413,6 +215582,19 @@ self: { broken = true; }) {}; + "ranged-list" = callPackage + ({ mkDerivation, base, doctest, typecheck-plugin-nat-simple }: + mkDerivation { + pname = "ranged-list"; + version = "0.1.0.0"; + sha256 = "0v0a80g17r8dap28gm83wnk32m3snlmw1r51vvwfb74a4q3613w8"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base typecheck-plugin-nat-simple ]; + testHaskellDepends = [ base doctest typecheck-plugin-nat-simple ]; + description = "The list like structure whose length or range of length can be specified"; + license = lib.licenses.bsd3; + }) {}; + "rangemin" = callPackage ({ mkDerivation, base, containers, primitive, vector }: mkDerivation { @@ -229160,6 +229342,17 @@ self: { license = lib.licenses.bsd3; }) {}; + "sdp-io" = callPackage + ({ mkDerivation, base, fmr, sdp }: + mkDerivation { + pname = "sdp-io"; + version = "0.2"; + sha256 = "06rrfsxzfi3vbjsm1d4cm2f4x7035y0zhp869f3bjasf2r4mzsp4"; + libraryHaskellDepends = [ base fmr sdp ]; + description = "SDP IO extension"; + license = lib.licenses.bsd3; + }) {}; + "sdp-quickcheck" = callPackage ({ mkDerivation, base, criterion, ghc-prim, QuickCheck, sdp , sdp-deepseq, test-framework, test-framework-quickcheck2 @@ -229179,6 +229372,44 @@ self: { license = lib.licenses.bsd3; }) {}; + "sdp4bytestring" = callPackage + ({ mkDerivation, base, bytestring, QuickCheck, quickcheck-instances + , sdp, sdp-io, sdp-quickcheck, test-framework + , test-framework-quickcheck2 + }: + mkDerivation { + pname = "sdp4bytestring"; + version = "0.2"; + sha256 = "119r7rhrsbv3c5dlwq5lf6lpjdybr5vl9lnvffcl6dvh8bym4g86"; + revision = "1"; + editedCabalFile = "1kwi2y9l7mnq5m9kr8731fjy50mz32qp1i966m9wg5bd9kximaga"; + libraryHaskellDepends = [ base bytestring sdp sdp-io ]; + testHaskellDepends = [ + base bytestring QuickCheck quickcheck-instances sdp sdp-io + sdp-quickcheck test-framework test-framework-quickcheck2 + ]; + description = "SDP wrapper for ByteString"; + license = lib.licenses.bsd3; + }) {}; + + "sdp4text" = callPackage + ({ mkDerivation, base, QuickCheck, quickcheck-instances, sdp + , sdp-io, sdp-quickcheck, test-framework + , test-framework-quickcheck2, text + }: + mkDerivation { + pname = "sdp4text"; + version = "0.2"; + sha256 = "12gq2rjddl2q4y045jixcar6v6s73qmqy4j30d22nvdyyqdjrxc8"; + libraryHaskellDepends = [ base sdp sdp-io text ]; + testHaskellDepends = [ + base QuickCheck quickcheck-instances sdp sdp-io sdp-quickcheck + test-framework test-framework-quickcheck2 text + ]; + description = "SDP wrapper for Text"; + license = lib.licenses.bsd3; + }) {}; + "sdp4unordered" = callPackage ({ mkDerivation, base, sdp, sdp-hashable, unordered-containers }: mkDerivation { @@ -241802,6 +242033,8 @@ self: { pname = "sockets-and-pipes"; version = "0.1"; sha256 = "02xc2kddcz93d9yqdchml0yh9gypcx64315baj766adgf8np42nv"; + revision = "2"; + editedCabalFile = "0rfkw9hq50xvrkb6wyp4g48pj0v6y4z1apmcba1svzwgni9am93d"; libraryHaskellDepends = [ aeson ascii async base blaze-html bytestring containers network safe-exceptions stm text time @@ -268956,10 +269189,8 @@ self: { }: mkDerivation { pname = "unfoldable"; - version = "1.0"; - sha256 = "0ilzv4ks76f9fx12ilsam0v232fm2mvvsz6s50p0nllldwgkgm6a"; - revision = "2"; - editedCabalFile = "0lnqjgh8nyq6w94swn0m7syl0bx6a2ml7s9sqp449inpdb8f8jaj"; + version = "1.0.1"; + sha256 = "1h1zps55adzhfsfq1bgwc235qywpad9z7rfqid81l4405pi5zw83"; libraryHaskellDepends = [ base containers ghc-prim one-liner QuickCheck random transformers ]; @@ -269280,8 +269511,8 @@ self: { ({ mkDerivation, base, containers, logict, mtl }: mkDerivation { pname = "unification-fd"; - version = "0.11.0"; - sha256 = "1agfnp94n6lgqb0g5v4vzdkpzcz74niw659ss6a03d5qghr1r6l4"; + version = "0.11.1"; + sha256 = "0xvc3xa0yhxjxd1nf6d1cnixlbjaz2ww08hg1vldsf6c1h4lvs05"; libraryHaskellDepends = [ base containers logict mtl ]; description = "Simple generic unification algorithms"; license = lib.licenses.bsd3; @@ -275365,6 +275596,8 @@ self: { pname = "vty"; version = "5.33"; sha256 = "0qsx4lwlkp6mwyr7rm1r9dg5ic1lc1awqgyag0nj1qgj2gnv6nc9"; + revision = "1"; + editedCabalFile = "1in66nd2xkb6mxxzazny900pz1xj83iqsql42c0rwk72chnnb8cd"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -279840,8 +280073,8 @@ self: { pname = "windns"; version = "0.1.0.1"; sha256 = "016d1cf51jqvhbzlf5kbizv4l4dymradac1420rl47q2k5faczq8"; - revision = "1"; - editedCabalFile = "17d44pzi4q5yvrygimdrwdrabz62s1ylw918w28sxgcvj64ir22g"; + revision = "2"; + editedCabalFile = "129amxjf05b6vi9ln8ijxry062av8bmv3wnng0jis71fyw8ldr0p"; libraryHaskellDepends = [ base bytestring deepseq ]; librarySystemDepends = [ dnsapi ]; description = "Domain Name Service (DNS) lookup via the /dnsapi.dll standard library"; From 532e499f11625c9be0c61f95b11e7c2ab0e1ad4e Mon Sep 17 00:00:00 2001 From: Vladimir Serov Date: Thu, 25 Feb 2021 00:36:49 +0300 Subject: [PATCH 25/70] atom-beta: 1.49.0 -> 1.55.0; marked as broken --- pkgs/applications/editors/atom/default.nix | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/pkgs/applications/editors/atom/default.nix b/pkgs/applications/editors/atom/default.nix index 87bb235a481..875f8612fde 100644 --- a/pkgs/applications/editors/atom/default.nix +++ b/pkgs/applications/editors/atom/default.nix @@ -8,13 +8,14 @@ let }; atom-beta = { - version = "1.49.0"; + version = "1.55.0"; beta = 0; - sha256 = "1fr6m4a7shdj3wpn6g4n95cqpkkg2x9srwjf7bqxv9f3d5jb1y33"; + sha256 = "sha256-PICkTt54cPkDJVnXBTtSHUQVbmosOpZfVAiD5A3/n+Q="; + broken = true; }; }; - common = pname: {version, sha256, beta ? null}: + common = pname: {version, sha256, beta ? null, broken ? false}: let fullVersion = version + lib.optionalString (beta != null) "-beta${toString beta}"; name = "${pname}-${fullVersion}"; in stdenv.mkDerivation { @@ -88,6 +89,7 @@ let license = licenses.mit; maintainers = with maintainers; [ offline ysndr ]; platforms = platforms.x86_64; + inherit broken; }; }; in lib.mapAttrs common versions From 0b1942a4d4fff278e9784a30097cdcd8e2b04f63 Mon Sep 17 00:00:00 2001 From: Tim Steinbach Date: Thu, 25 Feb 2021 16:40:42 +0000 Subject: [PATCH 26/70] =?UTF-8?q?sbt-extras:=202021-02-04=20=E2=86=92=2020?= =?UTF-8?q?21-02-24?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../build-managers/sbt-extras/default.nix | 25 ++++--------------- 1 file changed, 5 insertions(+), 20 deletions(-) diff --git a/pkgs/development/tools/build-managers/sbt-extras/default.nix b/pkgs/development/tools/build-managers/sbt-extras/default.nix index 06bf2c54678..4a0d0ef087e 100644 --- a/pkgs/development/tools/build-managers/sbt-extras/default.nix +++ b/pkgs/development/tools/build-managers/sbt-extras/default.nix @@ -1,31 +1,16 @@ -{ lib -, stdenv -, fetchFromGitHub -, which -, curl -, makeWrapper -, jdk -, writeScript -, common-updater-scripts -, cacert -, git -, nixfmt -, nix -, jq -, coreutils -, gnused -}: +{ lib, stdenv, fetchFromGitHub, which, curl, makeWrapper, jdk, writeScript +, common-updater-scripts, cacert, git, nixfmt, nix, jq, coreutils, gnused }: stdenv.mkDerivation rec { pname = "sbt-extras"; - rev = "830b72140583e2790bbd3649890ac8ef5371d0c6"; - version = "2021-02-04"; + rev = "f080234ba899bb49b0cf977b3683e6446b38c477"; + version = "2021-02-24"; src = fetchFromGitHub { owner = "paulp"; repo = "sbt-extras"; inherit rev; - sha256 = "0wq2mf8s254ns0sss5q394c1j2rnvl42x9l6kkrav505hbx0gyq6"; + sha256 = "01n25s60ssxls8lkwrni91k35622lyaizymmprcqh243dg3g2qiv"; }; dontBuild = true; From 804999f37e783e8aa7f1f80af4b2c2fdafb5344a Mon Sep 17 00:00:00 2001 From: Hunter Jones Date: Wed, 24 Feb 2021 14:20:13 -0600 Subject: [PATCH 27/70] siril: 0.99.6 -> 0.99.8.1 --- .../science/astronomy/siril/default.nix | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/pkgs/applications/science/astronomy/siril/default.nix b/pkgs/applications/science/astronomy/siril/default.nix index cd78b644eb0..e51d181266a 100644 --- a/pkgs/applications/science/astronomy/siril/default.nix +++ b/pkgs/applications/science/astronomy/siril/default.nix @@ -1,18 +1,18 @@ -{ lib, stdenv, fetchFromGitLab, fetchFromGitHub, pkg-config, meson, ninja, - git, criterion, wrapGAppsHook, gtk3, libconfig, gnuplot, opencv, - fftwFloat, cfitsio, gsl, exiv2, curl, librtprocess, ffmpeg, - libraw, libtiff, libpng, libjpeg, libheif, ffms +{ lib, stdenv, fetchFromGitLab, pkg-config, meson, ninja, wrapGAppsHook +, git, criterion, gtk3, libconfig, gnuplot, opencv, json-glib +, fftwFloat, cfitsio, gsl, exiv2, librtprocess, wcslib, ffmpeg +, libraw, libtiff, libpng, libjpeg, libheif, ffms }: stdenv.mkDerivation rec { pname = "siril"; - version = "0.99.6"; + version = "0.99.8.1"; src = fetchFromGitLab { owner = "free-astro"; repo = pname; rev = version; - sha256 = "06vh8x45gv0gwlnqjwxglf12jmpdaxkiv5sixkqh20420wabx3ha"; + sha256 = "0h3slgpj6zdc0rwmyr9zb0vgf53283hpwb7h26skdswmggsk90i5"; }; nativeBuildInputs = [ @@ -20,8 +20,8 @@ stdenv.mkDerivation rec { ]; buildInputs = [ - gtk3 cfitsio gsl exiv2 gnuplot curl opencv fftwFloat librtprocess - libconfig libraw libtiff libpng libjpeg libheif ffms ffmpeg + gtk3 cfitsio gsl exiv2 gnuplot opencv fftwFloat librtprocess wcslib + libconfig libraw libtiff libpng libjpeg libheif ffms ffmpeg json-glib ]; # Necessary because project uses default build dir for flatpaks/snaps @@ -37,8 +37,8 @@ stdenv.mkDerivation rec { meta = with lib; { homepage = "https://www.siril.org/"; - description = "Astronomical image processing tool"; - license = licenses.gpl3; + description = "Astrophotographic image processing tool"; + license = licenses.gpl3Plus; maintainers = with maintainers; [ hjones2199 ]; platforms = [ "x86_64-linux" ]; }; From 407a992fd60fdf67bd53764fa3369ce0e2e14c8c Mon Sep 17 00:00:00 2001 From: Victor Luft Date: Thu, 25 Feb 2021 12:34:44 -0500 Subject: [PATCH 28/70] sublime-merge-dev: 2037 -> 2046 --- .../applications/version-management/sublime-merge/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/version-management/sublime-merge/default.nix b/pkgs/applications/version-management/sublime-merge/default.nix index 7b01ab21f49..983c1ca557f 100644 --- a/pkgs/applications/version-management/sublime-merge/default.nix +++ b/pkgs/applications/version-management/sublime-merge/default.nix @@ -9,8 +9,8 @@ in { } {}; sublime-merge-dev = common { - buildVersion = "2037"; - sha256 = "1s0g18l2msmnn6w7f126andh2dygm9l94fxxhsi64v74mkawqg82"; + buildVersion = "2046"; + sha256 = "04laygxr4vm6mawlfmdn2vj0dwj1swab39znsgb1d6rhysz62kjd"; dev = true; } {}; } From 298113eaf7cb3da93fb9003368e1b3d5db616845 Mon Sep 17 00:00:00 2001 From: Victor Luft Date: Thu, 25 Feb 2021 12:34:58 -0500 Subject: [PATCH 29/70] sublime-merge: 2039 -> 2047 --- .../applications/version-management/sublime-merge/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/version-management/sublime-merge/default.nix b/pkgs/applications/version-management/sublime-merge/default.nix index 983c1ca557f..1ca04a1634a 100644 --- a/pkgs/applications/version-management/sublime-merge/default.nix +++ b/pkgs/applications/version-management/sublime-merge/default.nix @@ -4,8 +4,8 @@ let common = opts: callPackage (import ./common.nix opts); in { sublime-merge = common { - buildVersion = "2039"; - sha256 = "0l82408jli7g6nc267bnnnz0zz015lvpwva5fxj53mval32ii4i8"; + buildVersion = "2047"; + sha256 = "03a0whifhx9py25l96xpqhb4p6hi9qmnrk2bxz6gh02sinsp3mia"; } {}; sublime-merge-dev = common { From 9c3ccb1a32a8ba9a33d87230037727ad985dfb20 Mon Sep 17 00:00:00 2001 From: Ben Buscarino Date: Thu, 25 Feb 2021 12:44:19 -0500 Subject: [PATCH 30/70] libfaketime: fix clang patch --- .../0001-Remove-unsupported-clang-flags.patch | 20 ++++--------------- 1 file changed, 4 insertions(+), 16 deletions(-) diff --git a/pkgs/development/libraries/libfaketime/0001-Remove-unsupported-clang-flags.patch b/pkgs/development/libraries/libfaketime/0001-Remove-unsupported-clang-flags.patch index 84ee18084c2..7dfad497800 100644 --- a/pkgs/development/libraries/libfaketime/0001-Remove-unsupported-clang-flags.patch +++ b/pkgs/development/libraries/libfaketime/0001-Remove-unsupported-clang-flags.patch @@ -1,25 +1,13 @@ -From f974fe07de9e6820bb1de50b31e480296d1d97b7 Mon Sep 17 00:00:00 2001 -From: Christian Kampka -Date: Wed, 25 Nov 2020 20:09:50 +0100 -Subject: [PATCH] Remove unsupported clang flags - ---- - src/Makefile | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - diff --git a/src/Makefile b/src/Makefile -index f13a6bb..b305150 100644 +index 2af4804..bcff809 100644 --- a/src/Makefile +++ b/src/Makefile -@@ -69,7 +69,7 @@ PREFIX ?= /usr/local +@@ -80,7 +80,7 @@ PREFIX ?= /usr/local LIBDIRNAME ?= /lib/faketime PLATFORM ?=$(shell uname) --CFLAGS += -std=gnu99 -Wall -Wextra -Werror -Wno-nonnull-compare -DFAKE_PTHREAD -DFAKE_STAT -DFAKE_SLEEP -DFAKE_TIMERS -DFAKE_INTERNAL_CALLS -fPIC -DPREFIX='"'$(PREFIX)'"' -DLIBDIRNAME='"'$(LIBDIRNAME)'"' $(FAKETIME_COMPILE_CFLAGS) -+CFLAGS += -std=gnu99 -Wall -Wextra -DFAKE_PTHREAD -DFAKE_STAT -DFAKE_SLEEP -DFAKE_TIMERS -DFAKE_INTERNAL_CALLS -fPIC -DPREFIX='"'$(PREFIX)'"' -DLIBDIRNAME='"'$(LIBDIRNAME)'"' $(FAKETIME_COMPILE_CFLAGS) +-CFLAGS += -std=gnu99 -Wall -Wextra -Werror -Wno-nonnull-compare -DFAKE_PTHREAD -DFAKE_STAT -DFAKE_UTIME -DFAKE_SLEEP -DFAKE_TIMERS -DFAKE_INTERNAL_CALLS -fPIC -DPREFIX='"'$(PREFIX)'"' -DLIBDIRNAME='"'$(LIBDIRNAME)'"' $(FAKETIME_COMPILE_CFLAGS) ++CFLAGS += -std=gnu99 -Wall -Wextra -DFAKE_PTHREAD -DFAKE_STAT -DFAKE_UTIME -DFAKE_SLEEP -DFAKE_TIMERS -DFAKE_INTERNAL_CALLS -fPIC -DPREFIX='"'$(PREFIX)'"' -DLIBDIRNAME='"'$(LIBDIRNAME)'"' $(FAKETIME_COMPILE_CFLAGS) ifeq ($(PLATFORM),SunOS) CFLAGS += -D__EXTENSIONS__ -D_XOPEN_SOURCE=600 endif --- -2.28.0 - From efb24801f8141ca437f9545cbf6ebeca9ee3bd85 Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Thu, 25 Feb 2021 20:37:13 +0100 Subject: [PATCH 31/70] Stackage Nightly 2021-02-25 --- .../configuration-hackage2nix.yaml | 526 +++++++++--------- 1 file changed, 268 insertions(+), 258 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml index f74abe73ff5..dccc462acd1 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml @@ -78,7 +78,7 @@ default-package-overrides: - hls-plugin-api < 0.7.1.0 # for hls 0.9.0 - hls-retrie-plugin < 0.1.1.1 # for hls 0.9.0 - # Stackage Nightly 2021-02-12 + # Stackage Nightly 2021-02-25 - abstract-deque ==0.3 - abstract-par ==0.3.3 - AC-Angle ==1.0 @@ -88,11 +88,11 @@ default-package-overrides: - ad ==4.4.1 - adjunctions ==4.4 - adler32 ==0.1.2.0 - - aeson ==1.5.5.1 + - aeson ==1.5.6.0 - aeson-attoparsec ==0.0.0 - aeson-better-errors ==0.9.1.0 - aeson-casing ==0.2.0.0 - - aeson-combinators ==0.0.4.0 + - aeson-combinators ==0.0.4.1 - aeson-commit ==1.3 - aeson-compat ==0.3.9 - aeson-default ==0.9.1.0 @@ -103,7 +103,7 @@ default-package-overrides: - aeson-picker ==0.1.0.5 - aeson-pretty ==0.8.8 - aeson-qq ==0.8.3 - - aeson-schemas ==1.3.2 + - aeson-schemas ==1.3.3 - aeson-with ==0.1.2.0 - aeson-yak ==0.1.1.3 - aeson-yaml ==1.1.0.0 @@ -213,24 +213,24 @@ default-package-overrides: - amazonka-workspaces ==1.6.1 - amazonka-xray ==1.6.1 - amqp ==0.20.0.1 - - amqp-utils ==0.4.5.0 + - amqp-utils ==0.4.5.1 - annotated-wl-pprint ==0.7.0 - ansi-terminal ==0.10.3 - ansi-wl-pprint ==0.6.9 - ANum ==0.2.0.2 - - ap-normalize ==0.1.0.0 - apecs ==0.9.2 - apecs-gloss ==0.2.4 - apecs-physics ==0.4.5 - api-field-json-th ==0.1.0.2 - api-maker ==0.1.0.0 - - app-settings ==0.2.0.12 + - ap-normalize ==0.1.0.0 - appar ==0.1.8 - appendmap ==0.1.5 - - apply-refact ==0.9.0.0 + - apply-refact ==0.9.1.0 - apportionment ==0.0.0.3 - - approximate ==0.3.2 + - approximate ==0.3.4 - approximate-equality ==1.1.0.2 + - app-settings ==0.2.0.12 - arbor-lru-cache ==0.1.1.1 - arbor-postgres ==0.0.5 - arithmoi ==0.11.0.1 @@ -239,12 +239,12 @@ default-package-overrides: - ascii ==1.0.1.4 - ascii-case ==1.0.0.4 - ascii-char ==1.0.0.8 + - asciidiagram ==1.3.3.3 - ascii-group ==1.0.0.4 - ascii-predicates ==1.0.0.4 - ascii-progress ==0.3.3.0 - ascii-superset ==1.0.1.4 - ascii-th ==1.0.0.4 - - asciidiagram ==1.3.3.3 - asif ==6.0.4 - asn1-encoding ==0.9.6 - asn1-parse ==0.9.5 @@ -252,7 +252,7 @@ default-package-overrides: - assert-failure ==0.1.2.5 - assoc ==1.0.2 - astro ==0.4.2.1 - - async ==2.2.2 + - async ==2.2.3 - async-extra ==0.2.0.0 - async-pool ==0.9.1 - async-refresh ==0.3.0.0 @@ -272,8 +272,8 @@ default-package-overrides: - authenticate ==1.3.5 - authenticate-oauth ==1.6.0.1 - auto ==0.4.3.1 - - auto-update ==0.1.6 - autoexporter ==1.1.20 + - auto-update ==0.1.6 - avers ==0.0.17.1 - avro ==0.5.2.0 - aws-cloudfront-signed-cookies ==0.2.0.6 @@ -281,25 +281,25 @@ default-package-overrides: - backtracking ==0.1.0 - bank-holidays-england ==0.2.0.6 - barbies ==2.0.2.0 - - base-compat ==0.11.2 - - base-compat-batteries ==0.11.2 - - base-orphans ==0.8.4 - - base-prelude ==1.4 - - base-unicode-symbols ==0.2.4.2 - base16 ==0.3.0.1 - base16-bytestring ==0.1.1.7 - - base16-lens ==0.1.3.0 + - base16-lens ==0.1.3.2 - base32 ==0.2.0.0 - - base32-lens ==0.1.0.0 + - base32-lens ==0.1.1.1 - base32string ==0.9.1 - base58-bytestring ==0.1.0 - base58string ==0.10.0 - base64 ==0.4.2.3 - base64-bytestring ==1.1.0.0 - base64-bytestring-type ==1.0.1 - - base64-lens ==0.3.0 + - base64-lens ==0.3.1 - base64-string ==0.2 + - base-compat ==0.11.2 + - base-compat-batteries ==0.11.2 - basement ==0.0.11 + - base-orphans ==0.8.4 + - base-prelude ==1.4 + - base-unicode-symbols ==0.2.4.2 - basic-prelude ==0.7.0 - bazel-runfiles ==0.12 - bbdb ==0.8 @@ -312,8 +312,8 @@ default-package-overrides: - bibtex ==0.1.0.6 - bifunctors ==5.5.10 - bimap ==0.4.0 - - bimap-server ==0.1.0.1 - bimaps ==0.1.0.2 + - bimap-server ==0.1.0.1 - bin ==0.1 - binary-conduit ==1.3.1 - binary-ext ==2.0.4 @@ -323,7 +323,7 @@ default-package-overrides: - binary-orphans ==1.0.1 - binary-parser ==0.5.6 - binary-parsers ==0.2.4.0 - - binary-search ==1.0.0.3 + - binary-search ==2.0.0 - binary-shared ==0.8.3 - binary-tagged ==0.3 - bindings-DSL ==1.0.25 @@ -332,10 +332,10 @@ default-package-overrides: - bindings-uname ==0.1 - bins ==0.1.2.0 - bitarray ==0.0.1.1 - - bits ==0.5.2 - - bits-extra ==0.0.2.0 + - bits ==0.5.3 - bitset-word8 ==0.1.1.2 - - bitvec ==1.0.3.0 + - bits-extra ==0.0.2.0 + - bitvec ==1.1.1.0 - bitwise-enum ==1.0.0.3 - blake2 ==0.3.0 - blanks ==0.5.0 @@ -360,8 +360,8 @@ default-package-overrides: - boring ==0.1.3 - both ==0.1.1.1 - bound ==2.0.3 - - bounded-queue ==1.0.0 - BoundedChan ==1.0.3.0 + - bounded-queue ==1.0.0 - boundingboxes ==0.2.3 - bower-json ==1.0.0.1 - boxes ==0.1.5 @@ -379,12 +379,12 @@ default-package-overrides: - butcher ==1.3.3.2 - bv ==0.5 - bv-little ==1.1.1 - - byte-count-reader ==0.10.1.2 - - byte-order ==0.1.2.0 - byteable ==0.1.1 + - byte-count-reader ==0.10.1.2 - bytedump ==1.0 + - byte-order ==0.1.2.0 - byteorder ==1.0.4 - - bytes ==0.17 + - bytes ==0.17.1 - byteset ==0.1.1.0 - bytestring-builder ==0.10.8.2.0 - bytestring-conversion ==0.3.1 @@ -398,7 +398,6 @@ default-package-overrides: - bzlib-conduit ==0.3.0.2 - c14n ==0.1.0.1 - c2hs ==0.28.7 - - ca-province-codes ==1.0.0.0 - cabal-appimage ==0.3.0.2 - cabal-debian ==5.1 - cabal-doctest ==1.0.8 @@ -411,12 +410,13 @@ default-package-overrides: - calendar-recycling ==0.0.0.1 - call-stack ==0.2.0 - can-i-haz ==0.3.1.0 + - ca-province-codes ==1.0.0.0 - cardano-coin-selection ==1.0.1 - carray ==0.1.6.8 - casa-client ==0.0.1 - casa-types ==0.0.1 - - case-insensitive ==1.2.1.0 - cased ==0.1.0.0 + - case-insensitive ==1.2.1.0 - cases ==0.1.4 - casing ==0.1.4.1 - cassava ==0.5.2.0 @@ -436,7 +436,7 @@ default-package-overrides: - chan ==0.0.4.1 - ChannelT ==0.0.0.7 - character-cases ==0.1.0.6 - - charset ==0.3.7.1 + - charset ==0.3.8 - charsetdetect-ae ==1.1.0.4 - Chart ==1.9.3 - chaselev-deque ==0.5.0.5 @@ -459,6 +459,7 @@ default-package-overrides: - cipher-rc4 ==0.1.4 - circle-packing ==0.1.0.6 - circular ==0.3.1.1 + - citeproc ==0.3.0.7 - clash-ghc ==1.2.5 - clash-lib ==1.2.5 - clash-prelude ==1.2.5 @@ -476,13 +477,13 @@ default-package-overrides: - cmark ==0.6 - cmark-gfm ==0.2.2 - cmark-lucid ==0.1.0.0 - - cmdargs ==0.10.20 + - cmdargs ==0.10.21 + - codec-beam ==0.2.0 + - codec-rpm ==0.2.2 + - code-page ==0.2.1 - co-log ==0.4.0.1 - co-log-concurrent ==0.5.0.0 - co-log-core ==0.2.1.1 - - code-page ==0.2.1 - - codec-beam ==0.2.0 - - codec-rpm ==0.2.2 - Color ==0.3.0 - colorful-monoids ==0.2.1.3 - colorize-haskell ==1.0.1 @@ -491,12 +492,15 @@ default-package-overrides: - combinatorial ==0.1.0.1 - comfort-array ==0.4 - comfort-graph ==0.0.3.1 + - commonmark ==0.1.1.4 + - commonmark-extensions ==0.2.0.4 + - commonmark-pandoc ==0.2.0.1 - commutative ==0.0.2 - comonad ==5.0.8 - comonad-extras ==4.0.1 - compactmap ==0.1.4.2.1 - compdata ==0.12.1 - - compensated ==0.8.1 + - compensated ==0.8.3 - compiler-warnings ==0.1.0 - composable-associations ==0.1.0.0 - composable-associations-aeson ==0.1.0.0 @@ -529,8 +533,8 @@ default-package-overrides: - conferer-aeson ==1.0.0.0 - conferer-hspec ==1.0.0.0 - conferer-warp ==1.0.0.0 - - config-ini ==0.2.4.0 - ConfigFile ==1.1.4 + - config-ini ==0.2.4.0 - configurator ==0.3.0.0 - configurator-export ==0.1.0.1 - configurator-pg ==0.2.5 @@ -538,8 +542,8 @@ default-package-overrides: - connection-pool ==0.2.2 - console-style ==0.0.2.1 - constraint ==0.1.4.0 - - constraint-tuples ==0.1.2 - constraints ==0.12 + - constraint-tuples ==0.1.2 - construct ==0.3 - contravariant ==1.5.3 - contravariant-extras ==0.3.5.2 @@ -567,21 +571,22 @@ default-package-overrides: - cron ==0.7.0 - crypto-api ==0.13.3 - crypto-cipher-types ==0.0.9 - - crypto-enigma ==0.1.1.6 - - crypto-numbers ==0.2.7 - - crypto-pubkey ==0.2.8 - - crypto-pubkey-types ==0.4.3 - - crypto-random ==0.0.9 - - crypto-random-api ==0.2.0 - cryptocompare ==0.1.2 + - crypto-enigma ==0.1.1.6 - cryptohash ==0.11.9 - cryptohash-cryptoapi ==0.1.4 - cryptohash-md5 ==0.11.100.1 - cryptohash-sha1 ==0.11.100.1 - cryptohash-sha256 ==0.11.102.0 + - cryptohash-sha512 ==0.11.100.1 - cryptonite ==0.27 - cryptonite-conduit ==0.2.2 - cryptonite-openssl ==0.7 + - crypto-numbers ==0.2.7 + - crypto-pubkey ==0.2.8 + - crypto-pubkey-types ==0.4.3 + - crypto-random ==0.0.9 + - crypto-random-api ==0.2.0 - csp ==1.4.0 - css-syntax ==0.1.0.0 - css-text ==0.1.3.0 @@ -618,6 +623,7 @@ default-package-overrides: - data-default-instances-dlist ==0.0.1 - data-default-instances-old-locale ==0.0.1 - data-diverse ==4.7.0.0 + - datadog ==0.2.5.0 - data-dword ==0.3.2 - data-endian ==0.1.1 - data-fix ==0.3.1 @@ -636,7 +642,6 @@ default-package-overrides: - data-reify ==0.6.3 - data-serializer ==0.3.4.1 - data-textual ==0.3.0.3 - - datadog ==0.2.5.0 - dataurl ==0.1.0.0 - DAV ==1.3.4 - DBFunctor ==0.1.1.1 @@ -645,19 +650,19 @@ default-package-overrides: - debian ==4.0.2 - debian-build ==0.10.2.0 - debug-trace-var ==0.2.0 - - dec ==0.0.3 + - dec ==0.0.4 - Decimal ==0.5.1 - - declarative ==0.5.3 + - declarative ==0.5.4 - deepseq-generics ==0.2.0.0 - deepseq-instances ==0.1.0.1 - - deferred-folds ==0.9.15 + - deferred-folds ==0.9.16 - dejafu ==2.4.0.1 - dense-linear-algebra ==0.1.0.0 - depq ==0.4.1.0 - deque ==0.4.3 - - derive-topdown ==0.0.2.2 - deriveJsonNoPrefix ==0.1.0.1 - - deriving-aeson ==0.2.6 + - derive-topdown ==0.0.2.2 + - deriving-aeson ==0.2.6.1 - deriving-compat ==0.5.10 - derulo ==1.0.10 - dhall ==1.38.0 @@ -665,17 +670,17 @@ default-package-overrides: - dhall-json ==1.7.5 - dhall-lsp-server ==1.0.13 - dhall-yaml ==1.2.5 - - di-core ==1.0.4 - - di-monad ==1.3.1 - - diagrams-solve ==0.1.2 + - diagrams-solve ==0.1.3 - dialogflow-fulfillment ==0.1.1.3 + - di-core ==1.0.4 - dictionary-sharing ==0.1.0.0 - Diff ==0.4.0 - digest ==0.0.1.2 - digits ==0.3.1 - dimensional ==1.3 - - direct-sqlite ==2.3.26 + - di-monad ==1.3.1 - directory-tree ==0.12.1 + - direct-sqlite ==2.3.26 - dirichlet ==0.1.0.2 - discount ==0.1.1 - disk-free-space ==0.1.0.1 @@ -687,8 +692,6 @@ default-package-overrides: - dlist-instances ==0.1.1.1 - dlist-nonempty ==0.1.1 - dns ==4.0.1 - - do-list ==1.0.1 - - do-notation ==0.1.0.2 - dockerfile ==0.2.0 - doclayout ==0.3 - doctemplates ==0.9 @@ -697,6 +700,8 @@ default-package-overrides: - doctest-exitcode-stdio ==0.0 - doctest-lib ==0.1 - doldol ==0.4.1.2 + - do-list ==1.0.1 + - do-notation ==0.1.0.2 - dot ==0.3 - dotenv ==0.8.0.7 - dotgen ==0.4.3 @@ -717,7 +722,7 @@ default-package-overrides: - Earley ==0.13.0.1 - easy-file ==0.2.2 - Ebnf2ps ==1.0.15 - - echo ==0.1.3 + - echo ==0.1.4 - ecstasy ==0.2.1.0 - ed25519 ==0.0.5.0 - edit-distance ==0.2.2.1 @@ -736,24 +741,24 @@ default-package-overrides: - elerea ==2.9.0 - elf ==0.30 - eliminators ==0.7 + - elm2nix ==0.2.1 - elm-bridge ==0.6.1 - elm-core-sources ==1.0.0 - elm-export ==0.6.0.1 - - elm2nix ==0.2.1 - - elynx ==0.5.0.1 - - elynx-markov ==0.5.0.1 - - elynx-nexus ==0.5.0.1 - - elynx-seq ==0.5.0.1 - - elynx-tools ==0.5.0.1 - - elynx-tree ==0.5.0.1 + - elynx ==0.5.0.2 + - elynx-markov ==0.5.0.2 + - elynx-nexus ==0.5.0.2 + - elynx-seq ==0.5.0.2 + - elynx-tools ==0.5.0.2 + - elynx-tree ==0.5.0.2 - email-validate ==2.3.2.13 - emojis ==0.1 - enclosed-exceptions ==1.0.3 - ENIG ==0.0.1.0 - entropy ==0.4.1.6 - - enum-subset-generate ==0.1.0.0 - enummapset ==0.6.0.3 - enumset ==0.0.5 + - enum-subset-generate ==0.1.0.0 - envelope ==0.2.2.0 - envparse ==0.4.1 - envy ==2.1.0.0 @@ -767,33 +772,33 @@ default-package-overrides: - error-or-utils ==0.1.1 - errors ==2.3.0 - errors-ext ==0.4.2 - - ersatz ==0.4.8 - - esqueleto ==3.4.0.1 + - ersatz ==0.4.9 + - esqueleto ==3.4.1.0 - essence-of-live-coding ==0.2.4 - essence-of-live-coding-gloss ==0.2.4 - essence-of-live-coding-pulse ==0.2.4 - essence-of-live-coding-quickcheck ==0.2.4 - etc ==0.4.1.0 - eve ==0.1.9.0 - - event-list ==0.1.2 - eventful-core ==0.2.0 - eventful-test-helpers ==0.2.0 + - event-list ==0.1.2 - eventstore ==1.4.1 - every ==0.0.1 - exact-combinatorics ==0.2.0.9 - exact-pi ==0.5.0.1 - exception-hierarchy ==0.1.0.4 - exception-mtl ==0.4.0.1 + - exceptions ==0.10.4 - exception-transformers ==0.4.0.9 - exception-via ==0.1.0.0 - - exceptions ==0.10.4 - executable-path ==0.0.3.1 - exit-codes ==1.0.0 - exomizer ==1.0.0 - - exp-pairs ==0.2.1.0 - experimenter ==0.1.0.4 - expiring-cache-map ==0.0.6.1 - explicit-exception ==0.1.10 + - exp-pairs ==0.2.1.0 - express ==0.1.3 - extended-reals ==0.2.4.0 - extensible-effects ==5.0.0.1 @@ -808,7 +813,7 @@ default-package-overrides: - fakefs ==0.3.0.2 - fakepull ==0.3.0.2 - fast-digits ==0.3.0.0 - - fast-logger ==3.0.2 + - fast-logger ==3.0.3 - fast-math ==1.0.2 - fb ==2.1.1 - feature-flags ==0.1.0.1 @@ -820,10 +825,10 @@ default-package-overrides: - fgl ==5.7.0.3 - file-embed ==0.0.13.0 - file-embed-lzma ==0 - - file-modules ==0.1.2.4 - - file-path-th ==0.1.0.0 - filelock ==0.1.1.5 - filemanip ==0.3.6.3 + - file-modules ==0.1.2.4 + - file-path-th ==0.1.0.0 - filepattern ==0.1.2 - fileplow ==0.1.0.0 - filtrable ==0.1.4.0 @@ -853,11 +858,11 @@ default-package-overrides: - fn ==0.3.0.2 - focus ==1.0.2 - focuslist ==0.1.0.2 + - foldable1 ==0.1.0.0 - fold-debounce ==0.2.0.9 - fold-debounce-conduit ==0.2.0.5 - - foldable1 ==0.1.0.0 - foldl ==1.4.10 - - folds ==0.7.5 + - folds ==0.7.6 - follow-file ==0.0.3 - FontyFruity ==0.5.3.5 - foreign-store ==0.2 @@ -869,10 +874,10 @@ default-package-overrides: - foundation ==0.0.25 - free ==5.1.5 - free-categories ==0.2.0.2 - - free-vl ==0.1.4 - freenect ==1.2.1 - freer-simple ==1.2.1.1 - freetype2 ==0.2.0 + - free-vl ==0.1.4 - friendly-time ==0.4.1 - from-sum ==0.2.3.0 - frontmatter ==0.1.0.2 @@ -882,14 +887,14 @@ default-package-overrides: - ftp-client-conduit ==0.5.0.5 - funcmp ==1.9 - function-builder ==0.3.0.1 - - functor-classes-compat ==1 + - functor-classes-compat ==1.0.1 - fusion-plugin ==0.2.2 - fusion-plugin-types ==0.1.0 - fuzzcheck ==0.1.1 - fuzzy ==0.1.0.0 - fuzzy-dates ==0.1.1.2 - - fuzzy-time ==0.1.0.0 - fuzzyset ==0.2.0 + - fuzzy-time ==0.1.0.0 - gauge ==0.2.5 - gd ==3000.7.3 - gdp ==0.0.3.0 @@ -905,9 +910,9 @@ default-package-overrides: - generic-lens-core ==2.0.0.0 - generic-monoid ==0.1.0.1 - generic-optics ==2.0.0.0 - - generic-random ==1.3.0.1 - GenericPretty ==1.2.2 - - generics-sop ==0.5.1.0 + - generic-random ==1.3.0.1 + - generics-sop ==0.5.1.1 - generics-sop-lens ==0.2.0.1 - geniplate-mirror ==0.7.7 - genvalidity ==0.11.0.0 @@ -939,24 +944,24 @@ default-package-overrides: - ghc-check ==0.5.0.3 - ghc-core ==0.5.6 - ghc-events ==0.15.1 - - ghc-exactprint ==0.6.3.4 + - ghc-exactprint ==0.6.4 + - ghcid ==0.8.7 + - ghci-hexcalc ==0.1.1.0 + - ghcjs-codemirror ==0.0.0.2 - ghc-lib ==8.10.4.20210206 - ghc-lib-parser ==8.10.4.20210206 - ghc-lib-parser-ex ==8.10.0.19 - ghc-parser ==0.2.2.0 - ghc-paths ==0.1.0.12 - - ghc-prof ==1.4.1.7 + - ghc-prof ==1.4.1.8 - ghc-source-gen ==0.4.0.0 - ghc-syntax-highlighter ==0.0.6.0 - ghc-tcplugins-extra ==0.4.1 - ghc-trace-events ==0.1.2.1 - ghc-typelits-extra ==0.4.2 - ghc-typelits-knownnat ==0.7.5 - - ghc-typelits-natnormalise ==0.7.3 + - ghc-typelits-natnormalise ==0.7.4 - ghc-typelits-presburger ==0.5.2.0 - - ghci-hexcalc ==0.1.1.0 - - ghcid ==0.8.7 - - ghcjs-codemirror ==0.0.0.2 - ghost-buster ==0.1.1.0 - gi-atk ==2.0.22 - gi-cairo ==1.0.24 @@ -974,10 +979,9 @@ default-package-overrides: - gi-gtk ==3.0.36 - gi-gtk-hs ==0.3.9 - gi-harfbuzz ==0.0.3 - - gi-pango ==1.0.23 - - gi-xlib ==2.0.9 - ginger ==0.10.1.0 - gingersnap ==0.3.1.0 + - gi-pango ==1.0.23 - githash ==0.1.5.0 - github ==0.26 - github-release ==1.3.6 @@ -986,6 +990,7 @@ default-package-overrides: - github-webhooks ==0.15.0 - gitlab-haskell ==0.2.5 - gitrev ==1.3.1 + - gi-xlib ==2.0.9 - gl ==0.9 - glabrous ==2.0.2 - GLFW-b ==3.3.0.0 @@ -1000,11 +1005,11 @@ default-package-overrides: - gothic ==0.1.5 - gpolyline ==0.1.0.1 - graph-core ==0.3.0.0 - - graph-wrapper ==0.2.6.0 - graphite ==0.10.0.1 - graphql-client ==1.1.0 - graphs ==0.7.1 - graphviz ==2999.20.1.0 + - graph-wrapper ==0.2.6.0 - gravatar ==0.8.0 - greskell ==1.2.0.1 - greskell-core ==0.1.3.6 @@ -1032,7 +1037,7 @@ default-package-overrides: - HasBigDecimal ==0.1.1 - hasbolt ==0.1.4.4 - hashable ==1.3.0.0 - - hashable-time ==0.2.0.2 + - hashable-time ==0.2.1 - hashids ==1.0.2.4 - hashing ==0.1.0.1 - hashmap ==1.3.3 @@ -1057,7 +1062,7 @@ default-package-overrides: - hasql-pool ==0.5.2 - hasql-queue ==1.2.0.2 - hasql-transaction ==1.0.0.1 - - hasty-hamiltonian ==1.3.3 + - hasty-hamiltonian ==1.3.4 - HaTeX ==3.22.3.0 - HaXml ==1.25.5 - haxr ==3000.11.4.1 @@ -1088,9 +1093,9 @@ default-package-overrides: - hgeometry ==0.11.0.0 - hgeometry-combinatorial ==0.11.0.0 - hgrev ==0.2.6 - - hi-file-parser ==0.1.0.0 - hidapi ==0.1.5 - - hie-bios ==0.7.2 + - hie-bios ==0.7.4 + - hi-file-parser ==0.1.0.0 - higher-leveldb ==0.6.0.0 - highlighting-kate ==0.6.4 - hinfo ==0.0.3.0 @@ -1110,7 +1115,6 @@ default-package-overrides: - hmatrix-vector-sized ==0.1.3.0 - hmm-lapack ==0.4 - hmpfr ==0.4.4 - - hnix-store-core ==0.2.0.0 - hnock ==0.4.0 - hoauth2 ==1.16.0 - hocon ==0.1.0.4 @@ -1122,23 +1126,22 @@ default-package-overrides: - hostname-validate ==1.0.0 - hourglass ==0.2.12 - hourglass-orphans ==0.1.0.0 - - hp2pretty ==0.9 + - hp2pretty ==0.10 - hpack ==0.34.4 - hpack-dhall ==0.5.2 - hpc-codecov ==0.2.0.1 - hpc-lcov ==1.0.1 - hprotoc ==2.4.17 - hruby ==0.3.8 - - hs-bibutils ==6.10.0.0 - - hs-functors ==0.1.7.1 - - hs-GeoIP ==0.3 - - hs-php-session ==0.0.9.3 - hsass ==0.8.0 + - hs-bibutils ==6.10.0.0 - hsc2hs ==0.68.7 - hscolour ==1.24.4 - hsdns ==1.8 - hsebaysdk ==0.4.1.0 - hsemail ==2.2.1 + - hs-functors ==0.1.7.1 + - hs-GeoIP ==0.3 - hsini ==0.5.1.2 - hsinstall ==2.6 - HSlippyMap ==3.0.1 @@ -1172,6 +1175,7 @@ default-package-overrides: - hspec-tables ==0.0.1 - hspec-wai ==0.10.1 - hspec-wai-json ==0.10.1 + - hs-php-session ==0.0.9.3 - hsshellscript ==3.4.5 - HStringTemplate ==0.8.7 - HSvm ==0.1.1.3.22 @@ -1179,12 +1183,13 @@ default-package-overrides: - HsYAML-aeson ==0.2.0.0 - hsyslog ==5.0.2 - htaglib ==1.2.0 - - HTF ==0.14.0.5 + - HTF ==0.14.0.6 - html ==1.0.1.2 - html-conduit ==1.3.2.1 - html-entities ==1.1.4.3 - html-entity-map ==0.1.0.0 - htoml ==1.0.0.3 + - http2 ==2.0.5 - HTTP ==4000.3.15 - http-api-data ==0.4.1.1 - http-client ==0.6.4.1 @@ -1192,18 +1197,17 @@ default-package-overrides: - http-client-overrides ==0.1.1.0 - http-client-tls ==0.3.5.3 - http-common ==0.8.2.1 - - http-conduit ==2.3.7.4 - - http-date ==0.0.10 + - http-conduit ==2.3.8 + - http-date ==0.0.11 - http-directory ==0.1.8 - http-download ==0.2.0.0 + - httpd-shed ==0.4.1.1 - http-link-header ==1.0.3.1 - http-media ==0.8.0.0 - http-query ==0.1.0 - http-reverse-proxy ==0.6.0 - http-streams ==0.8.7.2 - http-types ==0.12.3 - - http2 ==2.0.5 - - httpd-shed ==0.4.1.1 - human-readable-duration ==0.2.1.4 - HUnit ==1.6.1.0 - HUnit-approx ==1.1.1.1 @@ -1216,6 +1220,7 @@ default-package-overrides: - hw-conduit-merges ==0.2.1.0 - hw-diagnostics ==0.0.1.0 - hw-dsv ==0.4.1.0 + - hweblib ==0.6.3 - hw-eliasfano ==0.1.2.0 - hw-excess ==0.2.3.0 - hw-fingertree ==0.1.2.0 @@ -1240,7 +1245,6 @@ default-package-overrides: - hw-string-parse ==0.0.0.4 - hw-succinct ==0.1.0.1 - hw-xml ==0.5.1.0 - - hweblib ==0.6.3 - hxt ==9.3.1.21 - hxt-charproperties ==9.5.0.0 - hxt-css ==0.1.0.3 @@ -1252,8 +1256,8 @@ default-package-overrides: - hxt-unicode ==9.0.2.4 - hybrid-vectors ==0.2.2 - hyper ==0.2.1.0 - - hyperloglog ==0.4.3 - - hyphenation ==0.8 + - hyperloglog ==0.4.4 + - hyphenation ==0.8.1 - iconv ==0.4.1.3 - identicon ==0.2.2 - ieee754 ==0.8.0 @@ -1277,7 +1281,7 @@ default-package-overrides: - indexed-traversable ==0.1.1 - infer-license ==0.2.0 - inflections ==0.4.0.6 - - influxdb ==1.9.0 + - influxdb ==1.9.1 - ini ==0.4.1 - inj ==1.0 - inline-c ==0.9.1.4 @@ -1285,19 +1289,19 @@ default-package-overrides: - inline-r ==0.10.4 - inliterate ==0.1.0 - input-parsers ==0.1.0.1 - - insert-ordered-containers ==0.2.3.1 - - inspection-testing ==0.4.2.4 + - insert-ordered-containers ==0.2.4 + - inspection-testing ==0.4.3.0 - instance-control ==0.1.2.0 - integer-logarithms ==1.0.3.1 - integer-roots ==1.0 - integration ==0.2.1 - - intern ==0.9.3 + - intern ==0.9.4 - interpolate ==0.2.1 - interpolatedstring-perl6 ==1.0.2 - interpolation ==0.1.1.1 - interpolator ==1.1.0.2 - IntervalMap ==0.6.1.2 - - intervals ==0.9.1 + - intervals ==0.9.2 - intro ==0.9.0.0 - intset-imperative ==0.1.0.0 - invariant ==0.5.4 @@ -1324,16 +1328,16 @@ default-package-overrides: - iso3166-country-codes ==0.20140203.8 - iso639 ==0.1.0.3 - iso8601-time ==0.1.5 - - it-has ==0.2.0.0 - iterable ==3.0 - - ix-shapable ==0.1.0 + - it-has ==0.2.0.0 - ixset-typed ==0.5 - ixset-typed-binary-instance ==0.1.0.2 - ixset-typed-conversions ==0.1.2.0 - ixset-typed-hashable-instance ==0.1.0.2 + - ix-shapable ==0.1.0 - jack ==0.7.1.4 - jalaali ==1.0.0.0 - - jira-wiki-markup ==1.3.2 + - jira-wiki-markup ==1.3.3 - jose ==0.8.4 - jose-jwt ==0.9.0 - js-chart ==2.9.4.1 @@ -1341,9 +1345,9 @@ default-package-overrides: - js-flot ==0.8.3 - js-jquery ==3.3.1 - json-feed ==1.0.12 + - jsonpath ==0.2.0.0 - json-rpc ==1.0.3 - json-rpc-generic ==0.2.1.5 - - jsonpath ==0.2.0.0 - JuicyPixels ==3.3.5 - JuicyPixels-blurhash ==0.1.0.3 - JuicyPixels-extra ==0.4.1 @@ -1351,7 +1355,7 @@ default-package-overrides: - junit-xml ==0.1.0.2 - justified-containers ==0.3.0.0 - jwt ==0.10.0 - - kan-extensions ==5.2.1 + - kan-extensions ==5.2.2 - kanji ==3.4.1 - katip ==0.8.5.0 - katip-logstash ==0.1.0.0 @@ -1376,7 +1380,7 @@ default-package-overrides: - language-bash ==0.9.2 - language-c ==0.8.3 - language-c-quote ==0.12.2.1 - - language-docker ==9.1.2 + - language-docker ==9.1.3 - language-java ==0.2.9 - language-javascript ==0.7.1.0 - language-protobuf ==1.0.1 @@ -1393,14 +1397,14 @@ default-package-overrides: - lawful ==0.1.0.0 - lazy-csv ==0.5.1 - lazyio ==0.1.0.4 - - lca ==0.3.1 + - lca ==0.4 - leancheck ==0.9.3 - leancheck-instances ==0.0.4 - leapseconds-announced ==2017.1.0.1 - learn-physics ==0.6.5 - lens ==4.19.2 - - lens-action ==0.2.4 - - lens-aeson ==1.1 + - lens-action ==0.2.5 + - lens-aeson ==1.1.1 - lens-csv ==0.1.1.0 - lens-datetime ==0.3 - lens-family ==2.0.0 @@ -1409,7 +1413,7 @@ default-package-overrides: - lens-misc ==0.0.2.0 - lens-process ==0.4.0.0 - lens-properties ==4.11.1 - - lens-regex ==0.1.1 + - lens-regex ==0.1.3 - lens-regex-pcre ==1.1.0.0 - lenz ==0.4.2.0 - leveldb-haskell ==0.6.5 @@ -1422,22 +1426,22 @@ default-package-overrides: - libyaml ==0.1.2 - LibZip ==1.0.1 - life-sync ==1.1.1.0 - - lift-generics ==0.2 - lifted-async ==0.10.1.2 - lifted-base ==0.2.3.12 + - lift-generics ==0.2 - line ==4.0.1 - - linear ==1.21.4 + - linear ==1.21.5 - linear-circuit ==0.1.0.2 - linenoise ==0.3.2 - linux-file-extents ==0.2.0.0 - linux-namespaces ==0.1.3.0 - liquid-fixpoint ==0.8.10.2 - List ==0.6.2 + - ListLike ==4.7.4 - list-predicate ==0.1.0.1 + - listsafe ==0.1.0.1 - list-singleton ==1.0.0.5 - list-t ==1.0.4 - - ListLike ==4.7.4 - - listsafe ==0.1.0.1 - ListTree ==0.2.3 - little-logger ==0.3.1 - little-rio ==0.2.2 @@ -1449,7 +1453,7 @@ default-package-overrides: - locators ==0.3.0.3 - loch-th ==0.2.2 - lockfree-queue ==0.2.3.1 - - log-domain ==0.13 + - log-domain ==0.13.1 - logfloat ==0.13.3.3 - logging ==3.0.5 - logging-facade ==0.3.0 @@ -1467,11 +1471,11 @@ default-package-overrides: - lz4-frame-conduit ==0.1.0.1 - lzma ==0.0.0.3 - lzma-conduit ==1.2.1 - - machines ==0.7.1 + - machines ==0.7.2 - magic ==1.1 - magico ==0.0.2.1 - - main-tester ==0.2.0.1 - mainland-pretty ==0.7.0.1 + - main-tester ==0.2.0.1 - makefile ==1.1.0.0 - managed ==1.0.8 - MapWith ==0.2.0.0 @@ -1483,9 +1487,9 @@ default-package-overrides: - massiv-persist ==0.1.0.0 - massiv-serialise ==0.1.0.0 - massiv-test ==0.1.6.1 + - mathexpr ==0.3.0.0 - math-extras ==0.1.1.0 - math-functions ==0.3.4.1 - - mathexpr ==0.3.0.0 - matplotlib ==0.7.5 - matrices ==0.5.0 - matrix ==0.3.6.1 @@ -1497,9 +1501,9 @@ default-package-overrides: - mbox-utility ==0.0.3.1 - mcmc ==0.4.0.0 - mcmc-types ==1.0.3 - - med-module ==0.1.2.1 - medea ==1.2.0 - median-stream ==0.7.0.0 + - med-module ==0.1.2.1 - megaparsec ==9.0.1 - megaparsec-tests ==9.0.1 - membrain ==0.0.0.2 @@ -1525,15 +1529,15 @@ default-package-overrides: - midair ==0.2.0.1 - midi ==0.2.2.2 - mighty-metropolis ==2.0.0 - - mime-mail ==0.5.0 + - mime-mail ==0.5.1 - mime-mail-ses ==0.4.3 - mime-types ==0.1.0.9 - - min-max-pqueue ==0.1.0.2 - mini-egison ==1.0.0 - minimal-configuration ==0.1.4 - minimorph ==0.3.0.0 - minio-hs ==1.5.3 - miniutter ==0.5.1.1 + - min-max-pqueue ==0.1.0.2 - mintty ==0.1.2 - missing-foreign ==0.1.1 - MissingH ==1.4.3.0 @@ -1543,20 +1547,22 @@ default-package-overrides: - mmark ==0.0.7.2 - mmark-cli ==0.0.5.0 - mmark-ext ==0.2.1.2 - - mmorph ==1.1.4 + - mmorph ==1.1.5 - mnist-idx ==0.1.2.8 - - mock-time ==0.1.0 - mockery ==0.3.5 + - mock-time ==0.1.0 - mod ==0.1.2.1 - model ==0.5 - - modern-uri ==0.3.3.1 + - modern-uri ==0.3.4.0 - modular ==0.1.0.8 - monad-chronicle ==1.0.0.1 - monad-control ==1.0.2.3 - monad-control-aligned ==0.0.1.1 - monad-coroutine ==0.9.0.4 - monad-extras ==0.6.0 + - monadic-arrays ==0.2.2 - monad-journal ==0.8.1 + - monadlist ==0.0.2 - monad-logger ==0.3.36 - monad-logger-json ==0.1.0.0 - monad-logger-logstash ==0.1.0.0 @@ -1565,28 +1571,26 @@ default-package-overrides: - monad-memo ==0.5.3 - monad-metrics ==0.2.2.0 - monad-par ==0.3.5 - - monad-par-extras ==0.3.3 - monad-parallel ==0.7.2.3 + - monad-par-extras ==0.3.3 - monad-peel ==0.2.1.2 - monad-primitive ==0.1 - monad-products ==4.0.1 + - MonadPrompt ==1.0.0.5 + - MonadRandom ==0.5.2 - monad-resumption ==0.1.4.0 - monad-skeleton ==0.1.5 - monad-st ==0.2.4.1 + - monads-tf ==0.1.0.3 - monad-time ==0.3.1.0 - monad-unlift ==0.2.0 - monad-unlift-ref ==0.2.1 - - monadic-arrays ==0.2.2 - - monadlist ==0.0.2 - - MonadPrompt ==1.0.0.5 - - MonadRandom ==0.5.2 - - monads-tf ==0.1.0.3 - mongoDB ==2.7.0.0 + - monoid-subclasses ==1.0.1 + - monoid-transformer ==0.0.4 - mono-traversable ==1.0.15.1 - mono-traversable-instances ==0.1.1.0 - mono-traversable-keys ==0.1.0 - - monoid-subclasses ==1.0.1 - - monoid-transformer ==0.0.4 - more-containers ==0.2.2.0 - morpheus-graphql ==0.16.0 - morpheus-graphql-client ==0.16.0 @@ -1599,14 +1603,14 @@ default-package-overrides: - mpi-hs-cereal ==0.1.0.0 - mtl-compat ==0.2.2 - mtl-prelude ==2.0.3.1 - - multi-containers ==0.1.1 - multiarg ==0.30.0.10 + - multi-containers ==0.1.1 - multimap ==1.2.1 - multipart ==0.2.1 - multiset ==0.3.4.3 - multistate ==0.8.0.3 - - murmur-hash ==0.1.0.9 - murmur3 ==1.0.4 + - murmur-hash ==0.1.0.9 - MusicBrainz ==0.4.1 - mustache ==2.3.1 - mutable-containers ==0.3.4 @@ -1653,21 +1657,22 @@ default-package-overrides: - newtype-generics ==0.6 - nicify-lib ==1.0.1 - NineP ==0.0.2.1 + - nix-derivation ==1.1.1 - nix-paths ==1.0.1 - - no-value ==1.0.0.0 - - non-empty ==0.3.2 - - non-empty-sequence ==0.2.0.4 - - non-negative ==0.1.2 - nonce ==1.0.7 - nondeterminism ==1.4 + - non-empty ==0.3.2 - nonempty-containers ==0.3.4.1 - - nonempty-vector ==0.2.1.0 - nonemptymap ==0.0.6.0 + - non-empty-sequence ==0.2.0.4 + - nonempty-vector ==0.2.1.0 + - non-negative ==0.1.2 - not-gloss ==0.7.7.0 + - no-value ==1.0.0.0 - nowdoc ==0.1.1.0 - nqe ==0.6.3 - - nri-env-parser ==0.1.0.3 - - nri-prelude ==0.3.0.0 + - nri-env-parser ==0.1.0.4 + - nri-prelude ==0.4.0.0 - nsis ==0.3.3 - numbers ==3000.2.0.2 - numeric-extras ==0.1 @@ -1679,9 +1684,9 @@ default-package-overrides: - nvim-hs ==2.1.0.4 - nvim-hs-contrib ==2.0.0.0 - nvim-hs-ghcid ==2.0.0.0 - - o-clock ==1.2.0.1 - oauthenticated ==0.2.1.0 - ObjectName ==1.1.0.1 + - o-clock ==1.2.0.1 - odbc ==0.2.2 - oeis2 ==1.0.4 - ofx ==0.4.4.0 @@ -1694,9 +1699,9 @@ default-package-overrides: - Only ==0.1 - oo-prototypes ==0.1.0.0 - opaleye ==0.7.1.0 - - open-browser ==0.2.1.0 - OpenAL ==1.7.0.5 - openapi3 ==3.0.1.0 + - open-browser ==0.2.1.0 - openexr-write ==0.1.0.2 - OpenGL ==3.0.3.0 - OpenGLRaw ==3.3.4.0 @@ -1728,6 +1733,8 @@ default-package-overrides: - pager ==0.1.1.0 - pagination ==0.2.1 - pagure-cli ==0.2 + - pandoc ==2.11.4 + - pandoc-plot ==1.0.2.1 - pandoc-types ==1.22 - pantry ==0.5.1.4 - parallel ==3.2.2.0 @@ -1760,10 +1767,10 @@ default-package-overrides: - pattern-arrows ==0.0.2 - pava ==0.1.1.0 - pcg-random ==0.1.3.7 + - pcre2 ==1.1.4 - pcre-heavy ==1.0.0.2 - pcre-light ==0.4.1.0 - pcre-utils ==0.1.8.1.1 - - pcre2 ==1.1.4 - pdfinfo ==1.5.4 - peano ==0.1.0.1 - pem ==0.2.4 @@ -1786,8 +1793,8 @@ default-package-overrides: - persistent-test ==2.0.3.5 - persistent-typed-db ==0.1.0.2 - pg-harness-client ==0.6.0 - - pg-transact ==0.3.1.1 - pgp-wordlist ==0.1.0.3 + - pg-transact ==0.3.1.1 - phantom-state ==0.2.1.2 - pid1 ==0.1.2.0 - pinboard ==0.10.2.0 @@ -1795,7 +1802,7 @@ default-package-overrides: - pipes-aeson ==0.4.1.8 - pipes-attoparsec ==0.5.1.5 - pipes-binary ==0.4.2 - - pipes-bytestring ==2.1.6 + - pipes-bytestring ==2.1.7 - pipes-concurrency ==2.0.12 - pipes-csv ==1.4.3 - pipes-extras ==1.0.15 @@ -1805,9 +1812,9 @@ default-package-overrides: - pipes-network ==0.6.5 - pipes-network-tls ==0.4 - pipes-ordered-zip ==1.1.0 - - pipes-parse ==3.0.8 + - pipes-parse ==3.0.9 - pipes-random ==1.0.0.5 - - pipes-safe ==2.3.2 + - pipes-safe ==2.3.3 - pipes-wai ==3.2.0 - pkcs10 ==0.2.0.0 - pkgtreediff ==0.4 @@ -1826,7 +1833,6 @@ default-package-overrides: - port-utils ==0.2.1.0 - posix-paths ==0.2.1.6 - possibly ==1.0.0.0 - - post-mess-age ==0.2.1.0 - postgres-options ==0.2.0.0 - postgresql-binary ==0.12.3.3 - postgresql-libpq ==0.9.4.3 @@ -1835,31 +1841,32 @@ default-package-overrides: - postgresql-simple ==0.6.4 - postgresql-typed ==0.6.1.2 - postgrest ==7.0.1 + - post-mess-age ==0.2.1.0 - pptable ==0.3.0.0 - pqueue ==1.4.1.3 - prairie ==0.0.1.0 - prefix-units ==0.2.0 - prelude-compat ==0.0.0.2 - prelude-safeenum ==0.1.1.2 - - pretty-class ==1.0.1.1 - - pretty-diff ==0.2.0.3 - - pretty-hex ==1.1 - - pretty-relative-time ==0.2.0.0 - - pretty-show ==1.10 - - pretty-simple ==4.0.0.0 - - pretty-sop ==0.2.0.3 - - pretty-terminal ==0.1.0.0 - prettyclass ==1.0.0.0 + - pretty-class ==1.0.1.1 + - pretty-diff ==0.4.0.2 + - pretty-hex ==1.1 - prettyprinter ==1.7.0 - prettyprinter-ansi-terminal ==1.1.2 - prettyprinter-compat-annotated-wl-pprint ==1.1 - prettyprinter-compat-ansi-wl-pprint ==1.0.1 - prettyprinter-compat-wl-pprint ==1.0.0.1 - prettyprinter-convert-ansi-wl-pprint ==1.1.1 + - pretty-relative-time ==0.2.0.0 + - pretty-show ==1.10 + - pretty-simple ==4.0.0.0 + - pretty-sop ==0.2.0.3 + - pretty-terminal ==0.1.0.0 - primes ==0.2.1.0 - primitive ==0.7.1.0 - primitive-addr ==0.1.0.2 - - primitive-extras ==0.8 + - primitive-extras ==0.10.1 - primitive-unaligned ==0.1.1.1 - primitive-unlifted ==0.1.3.0 - print-console-colors ==0.1.0.0 @@ -1869,20 +1876,14 @@ default-package-overrides: - product-profunctors ==0.11.0.2 - profiterole ==0.1 - profunctors ==5.5.2 - - project-template ==0.2.1.0 - projectroot ==0.2.0.1 + - project-template ==0.2.1.0 - prometheus ==2.2.2 - prometheus-client ==1.0.1 - prometheus-wai-middleware ==1.0.1.0 - promises ==0.3 - prompt ==0.1.1.2 - prospect ==0.1.0.0 - - proto-lens ==0.7.0.0 - - proto-lens-optparse ==0.1.1.7 - - proto-lens-protobuf-types ==0.7.0.0 - - proto-lens-protoc ==0.7.0.0 - - proto-lens-runtime ==0.7.0.0 - - proto-lens-setup ==0.4.0.4 - proto3-wire ==1.1.0 - protobuf ==0.2.1.3 - protobuf-simple ==0.1.1.0 @@ -1890,6 +1891,12 @@ default-package-overrides: - protocol-buffers-descriptor ==2.4.17 - protocol-radius ==0.0.1.1 - protocol-radius-test ==0.1.0.1 + - proto-lens ==0.7.0.0 + - proto-lens-optparse ==0.1.1.7 + - proto-lens-protobuf-types ==0.7.0.0 + - proto-lens-protoc ==0.7.0.0 + - proto-lens-runtime ==0.7.0.0 + - proto-lens-setup ==0.4.0.4 - protolude ==0.3.0 - proxied ==0.3.1 - psqueues ==0.2.7.2 @@ -1930,44 +1937,45 @@ default-package-overrides: - ramus ==0.1.2 - rando ==0.0.0.4 - random ==1.1 - - random-bytestring ==0.1.3.2 + - random-bytestring ==0.1.4 - random-fu ==0.2.7.4 - random-shuffle ==0.0.4 - random-source ==0.3.0.8 - random-tree ==0.6.0.5 - range ==0.3.0.2 - - range-set-list ==0.1.3.1 + - ranged-list ==0.1.0.0 - Ranged-sets ==0.4.0 + - range-set-list ==0.1.3.1 - rank1dynamic ==0.4.1 - rank2classes ==1.4.1 - Rasterific ==0.7.5.3 - rasterific-svg ==0.3.3.2 - - rate-limit ==1.4.2 - ratel ==1.0.13 + - rate-limit ==1.4.2 - ratel-wai ==1.1.4 - rattle ==0.2 - - raw-strings-qq ==1.1 + - Rattus ==0.5 - rawfilepath ==0.2.4 - rawstring-qm ==0.2.3.0 - - rcu ==0.2.4 + - raw-strings-qq ==1.1 + - rcu ==0.2.5 - rdf ==0.1.0.4 - rdtsc ==1.3.0.1 - re2 ==0.3 + - readable ==0.3.1 - read-editor ==0.1.0.2 - read-env-var ==1.0.0.0 - - readable ==0.3.1 - - reanimate ==1.1.3.2 - - reanimate-svg ==0.13.0.0 + - reanimate ==1.1.3.3 + - reanimate-svg ==0.13.0.1 - rebase ==1.6.1 - - record-dot-preprocessor ==0.2.7 + - record-dot-preprocessor ==0.2.8 - record-hasfield ==1.0 - - record-wrangler ==0.1.1.0 - records-sop ==0.1.0.3 - - recursion-schemes ==5.2.1 + - record-wrangler ==0.1.1.0 + - recursion-schemes ==5.2.2 - reducers ==3.12.3 - - ref-fd ==0.4.0.2 - - ref-tf ==0.4.0.2 - refact ==0.3.0.2 + - ref-fd ==0.4.0.2 - refined ==0.6.2 - reflection ==2.1.6 - reform ==0.2.7.4 @@ -1975,11 +1983,12 @@ default-package-overrides: - reform-hamlet ==0.0.5.3 - reform-happstack ==0.2.5.4 - RefSerialize ==0.4.0 + - ref-tf ==0.4.0.2 - regex ==1.1.0.0 - regex-applicative ==0.3.4 - regex-applicative-text ==0.1.0.1 - - regex-base ==0.94.0.0 - - regex-compat ==0.95.2.0 + - regex-base ==0.94.0.1 + - regex-compat ==0.95.2.1 - regex-compat-tdfa ==0.95.1.4 - regex-pcre ==0.95.0.0 - regex-pcre-builtin ==0.95.1.3.8.43 @@ -2013,6 +2022,7 @@ default-package-overrides: - rev-state ==0.1.2 - rfc1751 ==0.1.3 - rfc5051 ==0.2 + - rhbzquery ==0.4.3 - rhine ==0.7.0 - rhine-gloss ==0.7.0 - rigel-viz ==0.2.0.0 @@ -2032,15 +2042,15 @@ default-package-overrides: - runmemo ==1.0.0.1 - rvar ==0.2.0.6 - safe ==0.3.19 + - safecopy ==0.10.4.1 - safe-decimal ==0.2.0.0 - safe-exceptions ==0.1.7.1 - safe-foldable ==0.1.0.0 + - safeio ==0.0.5.0 - safe-json ==1.1.1.1 - safe-money ==0.9 - - safe-tensor ==0.2.1.0 - - safecopy ==0.10.3.1 - - safeio ==0.0.5.0 - SafeSemaphore ==0.10.1 + - safe-tensor ==0.2.1.0 - salak ==0.3.6 - salak-yaml ==0.3.5.3 - saltine ==0.1.1.1 @@ -2062,7 +2072,7 @@ default-package-overrides: - sdl2-gfx ==0.2 - sdl2-image ==2.0.0 - sdl2-mixer ==1.1.0 - - sdl2-ttf ==2.1.1 + - sdl2-ttf ==2.1.2 - search-algorithms ==0.3.1 - secp256k1-haskell ==0.5.0 - securemem ==0.1.10 @@ -2078,8 +2088,8 @@ default-package-overrides: - semigroupoid-extras ==5 - semigroupoids ==5.3.5 - semigroups ==0.19.1 - - semiring-simple ==1.0.0.1 - semirings ==0.6 + - semiring-simple ==1.0.0.1 - semver ==0.4.0.1 - sendfile ==0.7.11.1 - seqalign ==0.2.0.4 @@ -2111,7 +2121,7 @@ default-package-overrides: - servant-swagger-ui ==0.3.4.3.37.2 - servant-swagger-ui-core ==0.3.4 - serverless-haskell ==0.12.5 - - serversession ==1.0.1 + - serversession ==1.0.2 - serversession-frontend-wai ==1.0 - ses-html ==0.4.0.0 - set-cover ==0.1.1 @@ -2125,9 +2135,9 @@ default-package-overrides: - shared-memory ==0.2.0.0 - shell-conduit ==5.0.0 - shell-escape ==0.2.0 - - shell-utility ==0.1 - shellmet ==0.0.3.1 - shelltestrunner ==1.9 + - shell-utility ==0.1 - shelly ==1.9.0 - shikensu ==0.3.11 - shortcut-links ==0.5.1.1 @@ -2157,12 +2167,12 @@ default-package-overrides: - skein ==1.0.9.4 - skews ==0.1.0.3 - skip-var ==0.1.1.0 - - skylighting ==0.10.2 - - skylighting-core ==0.10.2 + - skylighting ==0.10.3 + - skylighting-core ==0.10.3 - slack-api ==0.12 - slack-progressbar ==0.1.0.1 - slist ==0.1.1.0 - - slynx ==0.5.0.1 + - slynx ==0.5.0.2 - smallcheck ==1.2.1 - smash ==0.1.1.0 - smash-aeson ==0.1.0.0 @@ -2190,7 +2200,7 @@ default-package-overrides: - spatial-math ==0.5.0.1 - special-values ==0.1.0.0 - speculate ==0.4.2 - - speedy-slice ==0.3.1 + - speedy-slice ==0.3.2 - Spintax ==0.3.5 - splice ==0.6.1.1 - splint ==1.0.1.3 @@ -2198,16 +2208,16 @@ default-package-overrides: - splitmix ==0.1.0.3 - spoon ==0.3.1 - spreadsheet ==0.1.3.8 - - sql-words ==0.1.6.4 - sqlcli ==0.2.2.0 - sqlcli-odbc ==0.2.0.1 - sqlite-simple ==0.4.18.0 + - sql-words ==0.1.6.4 - squeal-postgresql ==0.7.0.1 - squeather ==0.6.0.0 - srcloc ==0.5.1.2 - stache ==2.2.0 - - stack-templatizer ==0.1.0.2 - stackcollapse-ghc ==0.0.1.3 + - stack-templatizer ==0.1.0.2 - stateref ==0.3 - StateVar ==1.2.1 - static-text ==0.2.0.6 @@ -2220,10 +2230,10 @@ default-package-overrides: - stm-containers ==1.2 - stm-delay ==0.1.1.1 - stm-extras ==0.1.0.3 - - stm-hamt ==1.2.0.4 + - stm-hamt ==1.2.0.6 - stm-lifted ==2.5.0.0 - - stm-split ==0.0.2.1 - STMonadTrans ==0.4.5 + - stm-split ==0.0.2.1 - stopwatch ==0.1.0.6 - storable-complex ==0.2.3.0 - storable-endian ==0.2.6 @@ -2244,23 +2254,23 @@ default-package-overrides: - strict-list ==0.1.5 - strict-tuple ==0.1.4 - strict-tuple-lens ==0.1.0.1 + - stringbuilder ==0.5.1 - string-class ==0.1.7.0 - string-combinators ==0.6.0.5 - string-conv ==0.1.2 - string-conversions ==0.4.0.1 - - string-interpolate ==0.3.0.2 + - string-interpolate ==0.3.1.0 - string-qq ==0.0.4 - string-random ==0.1.4.0 - - string-transform ==1.1.1 - - stringbuilder ==0.5.1 - stringsearch ==0.3.6.6 + - string-transform ==1.1.1 - stripe-concepts ==1.0.2.4 - stripe-core ==2.6.2 - stripe-haskell ==2.6.2 - stripe-http-client ==2.6.2 - stripe-tests ==2.6.2 - strive ==5.0.13 - - structs ==0.1.4 + - structs ==0.1.5 - structured ==0.1 - structured-cli ==2.6.0.0 - subcategories ==0.1.0.0 @@ -2278,10 +2288,10 @@ default-package-overrides: - symmetry-operations-symbols ==0.0.2.1 - sysinfo ==0.1.1 - system-argv0 ==0.1.1 + - systemd ==2.3.0 - system-fileio ==0.3.16.4 - system-filepath ==0.4.14 - system-info ==0.5.1 - - systemd ==2.3.0 - tabular ==0.2.2.8 - taffybar ==3.2.3 - tagchup ==0.4.1.1 @@ -2295,13 +2305,13 @@ default-package-overrides: - tao-example ==1.0.0 - tar ==0.5.1.1 - tar-conduit ==0.3.2 - - tardis ==0.4.1.0 + - tardis ==0.4.3.0 - tasty ==1.2.3 - tasty-ant-xml ==1.1.7 - tasty-bench ==0.2.1 - tasty-dejafu ==2.0.0.7 - tasty-discover ==4.2.2 - - tasty-expected-failure ==0.12.2 + - tasty-expected-failure ==0.12.3 - tasty-focus ==1.0.1 - tasty-golden ==2.3.3.2 - tasty-hedgehog ==1.0.1.0 @@ -2348,6 +2358,7 @@ default-package-overrides: - text-icu ==0.7.0.1 - text-latin1 ==0.3.1 - text-ldap ==0.1.1.13 + - textlocal ==0.1.0.5 - text-manipulate ==0.2.0.1 - text-metrics ==0.3.0 - text-postgresql ==0.0.3.1 @@ -2358,9 +2369,8 @@ default-package-overrides: - text-show ==3.9 - text-show-instances ==3.8.4 - text-zipper ==0.11 - - textlocal ==0.1.0.5 - - tf-random ==0.5 - tfp ==1.0.1.1 + - tf-random ==0.5 - th-abstraction ==0.4.2.0 - th-bang-compat ==0.0.1.0 - th-compat ==0.1.1 @@ -2368,6 +2378,10 @@ default-package-overrides: - th-data-compat ==0.1.0.0 - th-desugar ==1.11 - th-env ==0.1.0.2 + - these ==1.1.1.1 + - these-lens ==1.0.1.1 + - these-optics ==1.0.1.1 + - these-skinny ==0.7.4 - th-expand-syns ==0.4.6.0 - th-extras ==0.0.0.4 - th-lift ==0.8.2 @@ -2375,37 +2389,33 @@ default-package-overrides: - th-nowq ==0.1.0.5 - th-orphans ==0.13.11 - th-printf ==0.7 - - th-reify-compat ==0.0.1.5 - - th-reify-many ==0.1.9 - - th-strict-compat ==0.1.0.1 - - th-test-utils ==1.1.0 - - th-utilities ==0.2.4.1 - - these ==1.1.1.1 - - these-lens ==1.0.1.1 - - these-optics ==1.0.1.1 - - these-skinny ==0.7.4 - thread-hierarchy ==0.3.0.2 - thread-local-storage ==0.2 - - thread-supervisor ==0.2.0.0 - threads ==0.5.1.6 + - thread-supervisor ==0.2.0.0 - threepenny-gui ==0.9.0.0 + - th-reify-compat ==0.0.1.5 + - th-reify-many ==0.1.9 - throttle-io-stream ==0.2.0.1 - through-text ==0.1.0.0 - throwable-exceptions ==0.1.0.9 + - th-strict-compat ==0.1.0.1 + - th-test-utils ==1.1.0 + - th-utilities ==0.2.4.1 - thyme ==0.3.5.5 - - tidal ==1.6.1 + - tidal ==1.7.1 - tile ==0.3.0.0 - time-compat ==1.9.5 + - timeit ==2.0 + - timelens ==0.2.0.2 - time-lens ==0.4.0.2 - time-locale-compat ==0.1.1.5 - time-locale-vietnamese ==1.0.0.0 - time-manager ==0.0.0 - time-parsers ==0.1.2.1 - - time-units ==1.0.0 - - timeit ==2.0 - - timelens ==0.2.0.2 - - timer-wheel ==0.3.0 - timerep ==2.0.1.0 + - timer-wheel ==0.3.0 + - time-units ==1.0.0 - timezone-olson ==0.2.0 - timezone-series ==0.1.9 - tinylog ==0.15.0 @@ -2414,11 +2424,11 @@ default-package-overrides: - tls ==1.5.5 - tls-debug ==0.4.8 - tls-session-manager ==0.0.4 - - tlynx ==0.5.0.1 + - tlynx ==0.5.0.2 - tmapchan ==0.0.3 - tmapmvar ==0.0.4 - tmp-postgres ==1.34.1.0 - - tomland ==1.3.1.0 + - tomland ==1.3.2.0 - tonalude ==0.1.1.1 - topograph ==1.0.0.1 - torsor ==0.1 @@ -2433,18 +2443,22 @@ default-package-overrides: - traverse-with-class ==1.0.1.0 - tree-diff ==0.1 - tree-fun ==0.8.1.0 - - tree-view ==0.5 - - trifecta ==2.1 + - tree-view ==0.5.1 + - trifecta ==2.1.1 - triplesec ==0.2.2.1 - tsv2csv ==0.1.0.2 - ttc ==0.3.0.0 - ttl-hashtables ==1.4.1.0 - ttrie ==0.1.2.1 - tuple ==0.3.0.2 + - tuples-homogenous-h98 ==0.1.1.0 - tuple-sop ==0.3.1.0 - tuple-th ==0.2.5 - - tuples-homogenous-h98 ==0.1.1.0 - turtle ==1.5.20 + - typecheck-plugin-nat-simple ==0.1.0.2 + - TypeCompose ==0.9.14 + - typed-process ==0.2.6.0 + - typed-uuid ==0.0.0.2 - type-equality ==1 - type-errors ==0.2.0.0 - type-errors-pretty ==0.0.1.1 @@ -2458,14 +2472,10 @@ default-package-overrides: - type-of-html ==1.6.2.0 - type-of-html-static ==0.1.0.2 - type-operators ==0.2.0.0 - - type-spec ==0.4.0.0 - - typecheck-plugin-nat-simple ==0.1.0.2 - - TypeCompose ==0.9.14 - - typed-process ==0.2.6.0 - - typed-uuid ==0.0.0.2 - typerep-map ==0.3.3.0 + - type-spec ==0.4.0.0 - tzdata ==0.2.20201021.0 - - ua-parser ==0.7.5.1 + - ua-parser ==0.7.6.0 - uglymemo ==0.1.0.1 - ulid ==0.3.0.0 - unagi-chan ==0.4.1.3 @@ -2518,8 +2528,8 @@ default-package-overrides: - utf8-string ==1.0.2 - util ==0.1.17.1 - utility-ht ==0.0.15 - - uuid ==1.3.13 - - uuid-types ==1.0.3 + - uuid ==1.3.14 + - uuid-types ==1.0.4 - validation ==1.1 - validation-selective ==0.1.0.0 - validity ==0.11.0.0 @@ -2535,7 +2545,7 @@ default-package-overrides: - validity-uuid ==0.1.0.3 - validity-vector ==0.2.0.3 - valor ==0.1.0.0 - - vault ==0.3.1.4 + - vault ==0.3.1.5 - vec ==0.3 - vector ==0.12.2.0 - vector-algorithms ==0.8.0.4 @@ -2550,16 +2560,16 @@ default-package-overrides: - vector-sized ==1.4.3.1 - vector-space ==0.16 - vector-split ==1.0.0.2 - - vector-th-unbox ==0.2.1.7 + - vector-th-unbox ==0.2.1.9 - verbosity ==0.4.0.0 - - versions ==4.0.2 + - versions ==4.0.3 - vformat ==0.14.1.0 - vformat-aeson ==0.1.0.1 - vformat-time ==0.1.0.0 - ViennaRNAParser ==1.3.3 - vinyl ==0.13.0 - void ==0.7.3 - - vty ==5.32 + - vty ==5.33 - wai ==3.2.3 - wai-app-static ==3.1.7.2 - wai-conduit ==3.0.0.4 @@ -2604,18 +2614,18 @@ default-package-overrides: - Win32-notify ==0.3.0.3 - windns ==0.1.0.1 - witch ==0.0.0.5 - - with-location ==0.1.0 - - with-utf8 ==1.0.2.1 - witherable-class ==0 - within ==0.2.0.1 + - with-location ==0.1.0 + - with-utf8 ==1.0.2.2 - wizards ==1.0.3 - wl-pprint-annotated ==0.1.0.1 - wl-pprint-console ==0.1.0.2 - wl-pprint-text ==1.2.0.1 - - word-trie ==0.3.0 - - word-wrap ==0.4.1 - word24 ==2.0.1 - word8 ==0.1.3 + - word-trie ==0.3.0 + - word-wrap ==0.4.1 - world-peace ==1.0.2.0 - wrap ==0.0.0 - wreq ==0.5.3.3 @@ -2642,6 +2652,7 @@ default-package-overrides: - xml-basic ==0.1.3.1 - xml-conduit ==1.9.0.0 - xml-conduit-writer ==0.1.1.2 + - xmlgen ==0.6.2.2 - xml-hamlet ==0.5.0.1 - xml-helpers ==1.0.0 - xml-html-qq ==0.1.0.1 @@ -2651,7 +2662,6 @@ default-package-overrides: - xml-to-json ==2.0.1 - xml-to-json-fast ==2.0.0 - xml-types ==0.3.8 - - xmlgen ==0.6.2.2 - xmonad ==0.15 - xmonad-contrib ==0.16 - xmonad-extras ==0.15.3 @@ -2659,7 +2669,6 @@ default-package-overrides: - xxhash-ffi ==0.2.0.0 - yaml ==0.11.5.0 - yamlparse-applicative ==0.1.0.2 - - yes-precure5-command ==5.5.3 - yesod ==1.6.1.0 - yesod-auth ==1.6.10.1 - yesod-auth-hashdb ==1.7.1.5 @@ -2677,6 +2686,7 @@ default-package-overrides: - yesod-static ==1.6.1.0 - yesod-test ==1.6.12 - yesod-websockets ==0.3.0.2 + - yes-precure5-command ==5.5.3 - yi-rope ==0.11 - yjsvg ==0.2.0.1 - yjtools ==0.9.18 @@ -2691,10 +2701,10 @@ default-package-overrides: - zio ==0.1.0.2 - zip ==1.7.0 - zip-archive ==0.4.1 - - zip-stream ==0.2.0.1 - zipper-extra ==0.1.3.2 - - zippers ==0.3 - - zlib ==0.6.2.2 + - zippers ==0.3.1 + - zip-stream ==0.2.0.1 + - zlib ==0.6.2.3 - zlib-bindings ==0.1.1.5 - zlib-lens ==0.1.2.1 - zot ==0.0.3 From d954e89af896c511039f35d70ed931d071445750 Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Thu, 25 Feb 2021 20:38:00 +0100 Subject: [PATCH 32/70] hackage-packages.nix: automatic Haskell package set update This update was generated by hackage2nix v2.16.0-13-gefcfbb2 from Hackage revision https://github.com/commercialhaskell/all-cabal-hashes/commit/e654fad9ef50c5b1ef10cee9bf3db8d93143baba. --- .../haskell-modules/hackage-packages.nix | 2780 +++-------------- 1 file changed, 353 insertions(+), 2427 deletions(-) diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 5dc81e6aab8..6bb71aaf63c 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -9384,43 +9384,6 @@ self: { }) {}; "HTF" = callPackage - ({ mkDerivation, aeson, aeson-pretty, array, base - , base64-bytestring, bytestring, Cabal, containers, cpphs, Diff - , directory, filepath, haskell-src, HUnit, lifted-base - , monad-control, mtl, old-time, pretty, process, QuickCheck, random - , regex-compat, template-haskell, temporary, text, time, unix - , unordered-containers, vector, xmlgen - }: - mkDerivation { - pname = "HTF"; - version = "0.14.0.5"; - sha256 = "1hgkymgb8v3f5s7i8nn01iml8mqvah4iyqiqcflj3ffbjb93v1zd"; - isLibrary = true; - isExecutable = true; - setupHaskellDepends = [ base Cabal process ]; - libraryHaskellDepends = [ - aeson array base base64-bytestring bytestring containers cpphs Diff - directory haskell-src HUnit lifted-base monad-control mtl old-time - pretty process QuickCheck random regex-compat text time unix vector - xmlgen - ]; - libraryToolDepends = [ cpphs ]; - executableHaskellDepends = [ - array base cpphs directory HUnit mtl old-time random text - ]; - executableToolDepends = [ cpphs ]; - testHaskellDepends = [ - aeson aeson-pretty base bytestring directory filepath HUnit mtl - process random regex-compat template-haskell temporary text - unordered-containers - ]; - description = "The Haskell Test Framework"; - license = lib.licenses.lgpl21; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "HTF_0_14_0_6" = callPackage ({ mkDerivation, aeson, aeson-pretty, array, base , base64-bytestring, bytestring, Cabal, containers, cpphs, Diff , directory, filepath, haskell-src, HUnit, lifted-base @@ -9814,8 +9777,8 @@ self: { pname = "HaXml"; version = "1.25.5"; sha256 = "0d8jbiv53r3ndg76r3937idqdg34nhmb99vj087i73hjnv21mifb"; - revision = "2"; - editedCabalFile = "0vlczcac2is5dbvkcwbsry1i10pbh1r316n1sq2py35alw7kzp1j"; + revision = "3"; + editedCabalFile = "0n98cigikjiqg2ckgihjw4if35n1jhv0zcqi3qw56b9j02yxdvvz"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -22028,8 +21991,8 @@ self: { }: mkDerivation { pname = "Z-IO"; - version = "0.6.3.0"; - sha256 = "12xy3dvd3yvln2z2dzkwqazzlyxb70ksrmzl6rhvmlx32j7djlvi"; + version = "0.6.4.0"; + sha256 = "1d651q0xda38652n249swh84kkn2jgw63db01aia00304h9cbcgf"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -22056,10 +22019,8 @@ self: { }: mkDerivation { pname = "Z-MessagePack"; - version = "0.1.0.0"; - sha256 = "0ck21z1yqjx4w86h7z4ndj0fkpx7bfxfr9p5ls8687b71wxyzn6z"; - revision = "2"; - editedCabalFile = "14p2w38wrc8m66421wdl7q7fn21vk4b5m2mi2sa79wnaibv43d1n"; + version = "0.3.0.1"; + sha256 = "1xn3by0fkn8w9akldfk2rrfk8ns2r64zxqadrcsgga7nv88q49am"; libraryHaskellDepends = [ base containers deepseq hashable integer-gmp primitive QuickCheck scientific tagged time unordered-containers Z-Data Z-IO @@ -24409,38 +24370,6 @@ self: { }) {}; "aeson" = callPackage - ({ mkDerivation, attoparsec, base, base-compat - , base-compat-batteries, base-orphans, base16-bytestring - , bytestring, containers, data-fix, deepseq, Diff, directory, dlist - , filepath, generic-deriving, ghc-prim, hashable, hashable-time - , integer-logarithms, primitive, QuickCheck, quickcheck-instances - , scientific, strict, tagged, tasty, tasty-golden, tasty-hunit - , tasty-quickcheck, template-haskell, text, th-abstraction, these - , time, time-compat, unordered-containers, uuid-types, vector - }: - mkDerivation { - pname = "aeson"; - version = "1.5.5.1"; - sha256 = "0iqnzh9xh2vx9viqvs528i24zm9sdpvh8kjbpfxgrca38v6ds5m2"; - libraryHaskellDepends = [ - attoparsec base base-compat-batteries bytestring containers - data-fix deepseq dlist ghc-prim hashable primitive scientific - strict tagged template-haskell text th-abstraction these time - time-compat unordered-containers uuid-types vector - ]; - testHaskellDepends = [ - attoparsec base base-compat base-orphans base16-bytestring - bytestring containers data-fix Diff directory dlist filepath - generic-deriving ghc-prim hashable hashable-time integer-logarithms - QuickCheck quickcheck-instances scientific strict tagged tasty - tasty-golden tasty-hunit tasty-quickcheck template-haskell text - these time time-compat unordered-containers uuid-types vector - ]; - description = "Fast JSON parsing and encoding"; - license = lib.licenses.bsd3; - }) {}; - - "aeson_1_5_6_0" = callPackage ({ mkDerivation, attoparsec, base, base-compat , base-compat-batteries, base-orphans, base16-bytestring , bytestring, containers, data-fix, deepseq, Diff, directory, dlist @@ -24470,7 +24399,6 @@ self: { ]; description = "Fast JSON parsing and encoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "aeson-applicative" = callPackage @@ -24560,26 +24488,6 @@ self: { }) {}; "aeson-combinators" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers, doctest, fail - , hspec, scientific, text, time, time-compat, unordered-containers - , utf8-string, uuid-types, vector, void - }: - mkDerivation { - pname = "aeson-combinators"; - version = "0.0.4.0"; - sha256 = "01gsrm6glr2axcls4hxs740z8lxf39cvdhvidf360mnijai4sgl6"; - libraryHaskellDepends = [ - aeson base bytestring containers fail scientific text time - time-compat unordered-containers uuid-types vector void - ]; - testHaskellDepends = [ - aeson base bytestring doctest hspec text utf8-string - ]; - description = "Aeson combinators for dead simple JSON decoding"; - license = lib.licenses.bsd3; - }) {}; - - "aeson-combinators_0_0_4_1" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, criterion , deepseq, doctest, fail, hspec, scientific, text, time , time-compat, unordered-containers, utf8-string, uuid-types @@ -24601,7 +24509,6 @@ self: { ]; description = "Aeson combinators for dead simple JSON decoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "aeson-commit" = callPackage @@ -25191,37 +25098,6 @@ self: { }) {}; "aeson-schemas" = callPackage - ({ mkDerivation, aeson, aeson-qq, base, criterion, deepseq - , first-class-families, hashable, hint, interpolate, megaparsec - , QuickCheck, raw-strings-qq, tasty, tasty-golden, tasty-hunit - , tasty-quickcheck, template-haskell, text, th-orphans - , th-test-utils, unordered-containers - }: - mkDerivation { - pname = "aeson-schemas"; - version = "1.3.2"; - sha256 = "1mchqhpnv7rnhi1lbcsg1pwr5ml2444h3l2yak353s8lr204pg1p"; - libraryHaskellDepends = [ - aeson base first-class-families hashable megaparsec - template-haskell text unordered-containers - ]; - testHaskellDepends = [ - aeson aeson-qq base deepseq first-class-families hashable hint - interpolate megaparsec QuickCheck raw-strings-qq tasty tasty-golden - tasty-hunit tasty-quickcheck template-haskell text th-orphans - th-test-utils unordered-containers - ]; - benchmarkHaskellDepends = [ - aeson base criterion deepseq first-class-families hashable - megaparsec template-haskell text th-test-utils unordered-containers - ]; - description = "Easily consume JSON data on-demand with type-safety"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "aeson-schemas_1_3_3" = callPackage ({ mkDerivation, aeson, aeson-qq, base, criterion, deepseq , first-class-families, hashable, hint, interpolate, megaparsec , QuickCheck, raw-strings-qq, tasty, tasty-golden, tasty-hunit @@ -29788,26 +29664,6 @@ self: { }) {}; "amqp-utils" = callPackage - ({ mkDerivation, amqp, base, bytestring, connection, containers - , data-default-class, directory, hinotify, magic, network, process - , text, time, tls, unix, utf8-string, x509-system - }: - mkDerivation { - pname = "amqp-utils"; - version = "0.4.5.0"; - sha256 = "0iwjgsai5bxfwqjlqcvykihd3zfj7wivx83sb07rqykjxqyhhsk9"; - isLibrary = false; - isExecutable = true; - executableHaskellDepends = [ - amqp base bytestring connection containers data-default-class - directory hinotify magic network process text time tls unix - utf8-string x509-system - ]; - description = "AMQP toolset for the command line"; - license = lib.licenses.gpl3; - }) {}; - - "amqp-utils_0_4_5_1" = callPackage ({ mkDerivation, amqp, base, bytestring, connection, containers , data-default-class, directory, hinotify, magic, network, process , text, time, tls, unix, utf8-string, x509-system @@ -29825,7 +29681,6 @@ self: { ]; description = "AMQP toolset for the command line"; license = lib.licenses.gpl3; - hydraPlatforms = lib.platforms.none; }) {}; "amqp-worker" = callPackage @@ -31990,37 +31845,6 @@ self: { }) {}; "apply-refact" = callPackage - ({ mkDerivation, base, containers, directory, extra, filemanip - , filepath, ghc, ghc-boot-th, ghc-exactprint, optparse-applicative - , process, refact, silently, syb, tasty, tasty-expected-failure - , tasty-golden, transformers, uniplate, unix-compat - }: - mkDerivation { - pname = "apply-refact"; - version = "0.9.0.0"; - sha256 = "1w6andxlap50vi2cwdy7x5xp2q1qyd67g4vs860gddcv8nir69qc"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base containers directory extra filemanip ghc ghc-boot-th - ghc-exactprint process refact syb transformers uniplate unix-compat - ]; - executableHaskellDepends = [ - base containers directory extra filemanip filepath ghc ghc-boot-th - ghc-exactprint optparse-applicative process refact syb transformers - uniplate unix-compat - ]; - testHaskellDepends = [ - base containers directory extra filemanip filepath ghc ghc-boot-th - ghc-exactprint optparse-applicative process refact silently syb - tasty tasty-expected-failure tasty-golden transformers uniplate - unix-compat - ]; - description = "Perform refactorings specified by the refact library"; - license = lib.licenses.bsd3; - }) {}; - - "apply-refact_0_9_1_0" = callPackage ({ mkDerivation, base, containers, directory, extra, filemanip , filepath, ghc, ghc-boot-th, ghc-exactprint, optparse-applicative , process, refact, silently, syb, tasty, tasty-expected-failure @@ -32049,7 +31873,6 @@ self: { ]; description = "Perform refactorings specified by the refact library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "apportionment" = callPackage @@ -32152,30 +31975,6 @@ self: { }) {}; "approximate" = callPackage - ({ mkDerivation, base, binary, bytes, Cabal, cabal-doctest, cereal - , comonad, deepseq, directory, doctest, filepath, ghc-prim - , hashable, lens, log-domain, pointed, safecopy, semigroupoids - , semigroups, simple-reflect, vector - }: - mkDerivation { - pname = "approximate"; - version = "0.3.2"; - sha256 = "016i37c5imb0n8gsk7gzyiq8dhkjv0xnn5315kmn6lnrhpfm7yyk"; - revision = "1"; - editedCabalFile = "0r81fnsyfc8y7j2y2isjayq4gf6m9vsc2chw37g89zmknfsnilb7"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - base binary bytes cereal comonad deepseq ghc-prim hashable lens - log-domain pointed safecopy semigroupoids semigroups vector - ]; - testHaskellDepends = [ - base directory doctest filepath semigroups simple-reflect - ]; - description = "Approximate discrete values and numbers"; - license = lib.licenses.bsd3; - }) {}; - - "approximate_0_3_4" = callPackage ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq , ghc-prim, hashable, lens, log-domain, pointed, safecopy , semigroupoids, semigroups, vector @@ -32190,7 +31989,6 @@ self: { ]; description = "Approximate discrete values and numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "approximate-equality" = callPackage @@ -34354,26 +34152,6 @@ self: { }) {}; "async" = callPackage - ({ mkDerivation, base, hashable, HUnit, stm, test-framework - , test-framework-hunit - }: - mkDerivation { - pname = "async"; - version = "2.2.2"; - sha256 = "1zxvfcyy4sg8lmzphi5dgnavksj5pav6rbvd5kc48lf4hanb2jjb"; - revision = "1"; - editedCabalFile = "1kg9xmby0wkx31998h2r43yr8bl1aixk6025zqigz9vdhmkc2y51"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base hashable stm ]; - testHaskellDepends = [ - base HUnit stm test-framework test-framework-hunit - ]; - description = "Run IO operations asynchronously and wait for their results"; - license = lib.licenses.bsd3; - }) {}; - - "async_2_2_3" = callPackage ({ mkDerivation, base, hashable, HUnit, stm, test-framework , test-framework-hunit }: @@ -34389,7 +34167,6 @@ self: { ]; description = "Run IO operations asynchronously and wait for their results"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "async-ajax" = callPackage @@ -38233,23 +38010,6 @@ self: { }) {}; "base16-lens" = callPackage - ({ mkDerivation, base, base16, bytestring, Cabal, cabal-doctest - , doctest, lens, text, text-short - }: - mkDerivation { - pname = "base16-lens"; - version = "0.1.3.0"; - sha256 = "1612v5lj99szshz7vm3mr5p4xxcrga1xxcfm9q9zzpnyd5z5vkn2"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - base base16 bytestring lens text text-short - ]; - testHaskellDepends = [ base doctest lens ]; - description = "Optics for the Base16 library"; - license = lib.licenses.bsd3; - }) {}; - - "base16-lens_0_1_3_2" = callPackage ({ mkDerivation, base, base16, bytestring, lens, text, text-short }: mkDerivation { @@ -38261,7 +38021,6 @@ self: { ]; description = "Optics for the Base16 library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "base32" = callPackage @@ -38307,23 +38066,6 @@ self: { }) {}; "base32-lens" = callPackage - ({ mkDerivation, base, base32, bytestring, Cabal, cabal-doctest - , doctest, lens, text - }: - mkDerivation { - pname = "base32-lens"; - version = "0.1.0.0"; - sha256 = "0yhaaz5y8cwyjcclmjw0hk31388z233041ycfpwm2a3f0vgpilvn"; - revision = "1"; - editedCabalFile = "1sj9dc2prfhbc3b7bvxmw6wfq0iql6dwvdx928z13rdc4vwj0nv0"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ base base32 bytestring lens text ]; - testHaskellDepends = [ base doctest lens ]; - description = "Optics for the Base32 library"; - license = lib.licenses.bsd3; - }) {}; - - "base32-lens_0_1_1_1" = callPackage ({ mkDerivation, base, base32, bytestring, lens, text, text-short }: mkDerivation { @@ -38335,7 +38077,6 @@ self: { ]; description = "Optics for the Base32 library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "base32-z-bytestring" = callPackage @@ -38582,21 +38323,6 @@ self: { }) {}; "base64-lens" = callPackage - ({ mkDerivation, base, base64, bytestring, Cabal, cabal-doctest - , doctest, lens, text - }: - mkDerivation { - pname = "base64-lens"; - version = "0.3.0"; - sha256 = "0gs3cxmglz0hshi4m94zrlc6fix90cvbdmcv2v4j01zwsdg8gv81"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ base base64 bytestring lens text ]; - testHaskellDepends = [ base doctest lens ]; - description = "Optics for the Base64 library"; - license = lib.licenses.bsd3; - }) {}; - - "base64-lens_0_3_1" = callPackage ({ mkDerivation, base, base64, bytestring, lens, text, text-short }: mkDerivation { @@ -38608,7 +38334,6 @@ self: { ]; description = "Optics for the Base64 library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "base64-string" = callPackage @@ -39112,8 +38837,8 @@ self: { }: mkDerivation { pname = "bcp47"; - version = "0.2.0.1"; - sha256 = "1hrqszdzr15p45wbbnpdkairmqwz8giyb0gn727wgxflh75a84xr"; + version = "0.2.0.3"; + sha256 = "07gz8bflc3klw0370albaff8v9vlgyqgrc5lifl35vs2ia891fhn"; libraryHaskellDepends = [ aeson base containers country generic-arbitrary iso639 megaparsec QuickCheck text @@ -40853,24 +40578,6 @@ self: { }) {}; "binary-search" = callPackage - ({ mkDerivation, base, containers, directory, doctest, filepath - , hspec, QuickCheck, transformers - }: - mkDerivation { - pname = "binary-search"; - version = "1.0.0.3"; - sha256 = "1ypn2i2c3mxd1zhpj515zf15y9sgz10akbyngg2ymp7ddbs2vqxh"; - libraryHaskellDepends = [ base containers transformers ]; - testHaskellDepends = [ - base directory doctest filepath hspec QuickCheck - ]; - description = "Binary and exponential searches"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "binary-search_2_0_0" = callPackage ({ mkDerivation, base, containers, directory, doctest, filepath , hspec, QuickCheck, transformers }: @@ -42970,23 +42677,6 @@ self: { }) {}; "bits" = callPackage - ({ mkDerivation, base, bytes, Cabal, cabal-doctest, doctest, mtl - , transformers - }: - mkDerivation { - pname = "bits"; - version = "0.5.2"; - sha256 = "1q5grjma421qiwjkwvnsakd4hxnf02bavfinky2skfhqvg63hkav"; - revision = "2"; - editedCabalFile = "0zcxzi3afs2vxmm2mc9l65br5qym2ah9q3671f4ckzn0h0hcqw2n"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ base bytes mtl transformers ]; - testHaskellDepends = [ base doctest ]; - description = "Various bit twiddling and bitwise serialization primitives"; - license = lib.licenses.bsd3; - }) {}; - - "bits_0_5_3" = callPackage ({ mkDerivation, base, bytes, mtl, transformers }: mkDerivation { pname = "bits"; @@ -42995,7 +42685,6 @@ self: { libraryHaskellDepends = [ base bytes mtl transformers ]; description = "Various bit twiddling and bitwise serialization primitives"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "bits-atomic" = callPackage @@ -43252,30 +42941,6 @@ self: { }) {}; "bitvec" = callPackage - ({ mkDerivation, base, containers, deepseq, gauge, ghc-prim, gmp - , integer-gmp, primitive, quickcheck-classes, random, tasty - , tasty-hunit, tasty-quickcheck, vector - }: - mkDerivation { - pname = "bitvec"; - version = "1.0.3.0"; - sha256 = "0s3gdh2rgz9wdnin5h2yhvnr8gy3sgcl9sbb1k4069ap4svrg8hd"; - libraryHaskellDepends = [ - base deepseq ghc-prim integer-gmp primitive vector - ]; - librarySystemDepends = [ gmp ]; - testHaskellDepends = [ - base integer-gmp primitive quickcheck-classes tasty tasty-hunit - tasty-quickcheck vector - ]; - benchmarkHaskellDepends = [ - base containers gauge integer-gmp random vector - ]; - description = "Space-efficient bit vectors"; - license = lib.licenses.bsd3; - }) {inherit (pkgs) gmp;}; - - "bitvec_1_1_1_0" = callPackage ({ mkDerivation, base, bytestring, containers, deepseq, ghc-prim , integer-gmp, primitive, quickcheck-classes, random, tasty , tasty-bench, tasty-hunit, tasty-quickcheck, vector @@ -43296,7 +42961,6 @@ self: { ]; description = "Space-efficient bit vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "bitwise" = callPackage @@ -47507,29 +47171,6 @@ self: { }) {}; "bytes" = callPackage - ({ mkDerivation, base, binary, binary-orphans, bytestring, Cabal - , cabal-doctest, cereal, containers, directory, doctest, filepath - , hashable, mtl, scientific, text, time, transformers - , transformers-compat, unordered-containers, void - }: - mkDerivation { - pname = "bytes"; - version = "0.17"; - sha256 = "11gacfxcn9f3v5a1phlgi7mwwrnyh51sfsym573g6i4v2zqfrwi3"; - revision = "5"; - editedCabalFile = "0a089bz9sjnmv3f5w9jsm1b7g60qx8qxqj76lwjj0mslzi9iajk2"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - base binary binary-orphans bytestring cereal containers hashable - mtl scientific text time transformers transformers-compat - unordered-containers void - ]; - testHaskellDepends = [ base directory doctest filepath ]; - description = "Sharing code for serialization between binary and cereal"; - license = lib.licenses.bsd3; - }) {}; - - "bytes_0_17_1" = callPackage ({ mkDerivation, base, binary, binary-orphans, bytestring, cereal , containers, hashable, mtl, scientific, text, time, transformers , transformers-compat, unordered-containers, void @@ -47545,7 +47186,6 @@ self: { ]; description = "Sharing code for serialization between binary and cereal"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "byteset" = callPackage @@ -53386,23 +53026,6 @@ self: { }) {}; "charset" = callPackage - ({ mkDerivation, array, base, bytestring, containers, semigroups - , unordered-containers - }: - mkDerivation { - pname = "charset"; - version = "0.3.7.1"; - sha256 = "1gn0m96qpjww8hpp2g1as5yy0wcwy4iq73h3kz6g0yxxhcl5sh9x"; - revision = "2"; - editedCabalFile = "002x3yan7632nqgwk0a7f3wvchgm95pdwqh225va8dnn1lr9pi1z"; - libraryHaskellDepends = [ - array base bytestring containers semigroups unordered-containers - ]; - description = "Fast unicode character sets based on complemented PATRICIA tries"; - license = lib.licenses.bsd3; - }) {}; - - "charset_0_3_8" = callPackage ({ mkDerivation, array, base, bytestring, containers , unordered-containers }: @@ -53415,7 +53038,6 @@ self: { ]; description = "Fast unicode character sets based on complemented PATRICIA tries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "charsetdetect" = callPackage @@ -57347,23 +56969,6 @@ self: { }) {}; "cmdargs" = callPackage - ({ mkDerivation, base, filepath, process, template-haskell - , transformers - }: - mkDerivation { - pname = "cmdargs"; - version = "0.10.20"; - sha256 = "0cbkmgrcnwgigg6z88y3c09gm7g6dwm7gzbgr53h8k1xik29s9hf"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base filepath process template-haskell transformers - ]; - description = "Command line argument processing"; - license = lib.licenses.bsd3; - }) {}; - - "cmdargs_0_10_21" = callPackage ({ mkDerivation, base, filepath, process, template-haskell , transformers }: @@ -57378,7 +56983,6 @@ self: { ]; description = "Command line argument processing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "cmdargs-browser" = callPackage @@ -59797,31 +59401,6 @@ self: { }) {}; "compensated" = callPackage - ({ mkDerivation, base, bifunctors, binary, bytes, Cabal - , cabal-doctest, cereal, comonad, criterion, deepseq, distributive - , doctest, generic-deriving, hashable, lens, log-domain, safecopy - , semigroupoids, semigroups, simple-reflect, vector - }: - mkDerivation { - pname = "compensated"; - version = "0.8.1"; - sha256 = "1qr5nsg6fb6ib2wp29c1y05zdbydsng0sfg2k75qsh0avb2cgw7z"; - revision = "1"; - editedCabalFile = "1hsg6j8h700nixgnz823js5pm5ziq820nzds1b60j0a0plz94pin"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - base bifunctors binary bytes cereal comonad deepseq distributive - hashable lens log-domain safecopy semigroupoids semigroups vector - ]; - testHaskellDepends = [ - base doctest generic-deriving semigroups simple-reflect - ]; - benchmarkHaskellDepends = [ base criterion ]; - description = "Compensated floating-point arithmetic"; - license = lib.licenses.bsd3; - }) {}; - - "compensated_0_8_3" = callPackage ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad , criterion, deepseq, distributive, hashable, lens, log-domain , safecopy, semigroupoids, semigroups, vector @@ -59837,7 +59416,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Compensated floating-point arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "competition" = callPackage @@ -71996,19 +71574,6 @@ self: { }) {}; "dec" = callPackage - ({ mkDerivation, base }: - mkDerivation { - pname = "dec"; - version = "0.0.3"; - sha256 = "1y8bvlm2371dq2v0jv1srki98nbhbz091wh0g2x58wz78h971f6r"; - revision = "2"; - editedCabalFile = "1v5f5yby0cld1ziqqgkcx8b50qkpviplspm82a6wl7lw28cjm0hs"; - libraryHaskellDepends = [ base ]; - description = "Decidable propositions"; - license = lib.licenses.bsd3; - }) {}; - - "dec_0_0_4" = callPackage ({ mkDerivation, base }: mkDerivation { pname = "dec"; @@ -72017,7 +71582,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Decidable propositions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "decepticons" = callPackage @@ -72083,25 +71647,6 @@ self: { }) {}; "declarative" = callPackage - ({ mkDerivation, base, hasty-hamiltonian, kan-extensions, lens - , mcmc-types, mighty-metropolis, mwc-probability, pipes, primitive - , speedy-slice, transformers - }: - mkDerivation { - pname = "declarative"; - version = "0.5.3"; - sha256 = "021rhdhj2sji316mkm1fw679w7xb9n51x9pslmj21427q127ycw3"; - libraryHaskellDepends = [ - base hasty-hamiltonian kan-extensions lens mcmc-types - mighty-metropolis mwc-probability pipes primitive speedy-slice - transformers - ]; - testHaskellDepends = [ base mwc-probability ]; - description = "DIY Markov Chains"; - license = lib.licenses.mit; - }) {}; - - "declarative_0_5_4" = callPackage ({ mkDerivation, base, hasty-hamiltonian, kan-extensions, lens , mcmc-types, mighty-metropolis, mwc-probability, pipes, primitive , speedy-slice, transformers @@ -72118,7 +71663,6 @@ self: { testHaskellDepends = [ base mwc-probability ]; description = "DIY Markov Chains"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "decode-utf8" = callPackage @@ -72366,28 +71910,6 @@ self: { }) {}; "deferred-folds" = callPackage - ({ mkDerivation, base, bytestring, containers, foldl, hashable - , primitive, QuickCheck, quickcheck-instances, rerebase, tasty - , tasty-hunit, tasty-quickcheck, text, transformers - , unordered-containers, vector - }: - mkDerivation { - pname = "deferred-folds"; - version = "0.9.15"; - sha256 = "0jijnjy6x6f86dmlhiaj9gl13zbwzaz4gpb8svzdwwws48bwwyqr"; - libraryHaskellDepends = [ - base bytestring containers foldl hashable primitive text - transformers unordered-containers vector - ]; - testHaskellDepends = [ - QuickCheck quickcheck-instances rerebase tasty tasty-hunit - tasty-quickcheck - ]; - description = "Abstractions over deferred folds"; - license = lib.licenses.mit; - }) {}; - - "deferred-folds_0_9_16" = callPackage ({ mkDerivation, base, bytestring, containers, foldl, hashable , primitive, QuickCheck, quickcheck-instances, rerebase, tasty , tasty-hunit, tasty-quickcheck, text, transformers @@ -72407,7 +71929,6 @@ self: { ]; description = "Abstractions over deferred folds"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "definitive-base" = callPackage @@ -73373,18 +72894,6 @@ self: { }) {}; "deriving-aeson" = callPackage - ({ mkDerivation, aeson, base, bytestring }: - mkDerivation { - pname = "deriving-aeson"; - version = "0.2.6"; - sha256 = "0x9sv8r0ziy14zk6lcgzgxbmx9mrlngc0r1bqg6gkgxhswmjc2jq"; - libraryHaskellDepends = [ aeson base ]; - testHaskellDepends = [ aeson base bytestring ]; - description = "Type driven generic aeson instance customisation"; - license = lib.licenses.bsd3; - }) {}; - - "deriving-aeson_0_2_6_1" = callPackage ({ mkDerivation, aeson, base, bytestring }: mkDerivation { pname = "deriving-aeson"; @@ -73394,7 +72903,6 @@ self: { testHaskellDepends = [ aeson base bytestring ]; description = "Type driven generic aeson instance customisation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "deriving-compat" = callPackage @@ -75047,22 +74555,6 @@ self: { }) {}; "diagrams-solve" = callPackage - ({ mkDerivation, base, deepseq, tasty, tasty-hunit - , tasty-quickcheck - }: - mkDerivation { - pname = "diagrams-solve"; - version = "0.1.2"; - sha256 = "1qzycw3aj4107dqpgir3ak7pnja3a6i4ax15gd2q2fjzmp4p3z24"; - libraryHaskellDepends = [ base ]; - testHaskellDepends = [ - base deepseq tasty tasty-hunit tasty-quickcheck - ]; - description = "Pure Haskell solver routines used by diagrams"; - license = lib.licenses.bsd3; - }) {}; - - "diagrams-solve_0_1_3" = callPackage ({ mkDerivation, base, deepseq, tasty, tasty-hunit , tasty-quickcheck }: @@ -75076,7 +74568,6 @@ self: { ]; description = "Pure Haskell solver routines used by diagrams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "diagrams-svg" = callPackage @@ -81545,21 +81036,6 @@ self: { }) {}; "echo" = callPackage - ({ mkDerivation, base, process }: - mkDerivation { - pname = "echo"; - version = "0.1.3"; - sha256 = "1vw5ykpwhr39wc0hhcgq3r8dh59zq6ib4zxbz1qd2wl21wqhfkvh"; - revision = "1"; - editedCabalFile = "0br8wfiybcw5hand4imiw0i5hacdmrax1dv8g95f35gazffbx42l"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base process ]; - description = "A cross-platform, cross-console way to handle echoing terminal input"; - license = lib.licenses.bsd3; - }) {}; - - "echo_0_1_4" = callPackage ({ mkDerivation, base, process }: mkDerivation { pname = "echo"; @@ -81570,7 +81046,6 @@ self: { libraryHaskellDepends = [ base process ]; description = "A cross-platform, cross-console way to handle echoing terminal input"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "ecma262" = callPackage @@ -83425,25 +82900,6 @@ self: { }) {}; "elynx" = callPackage - ({ mkDerivation, aeson, base, bytestring, elynx-tools - , optparse-applicative, slynx, tlynx - }: - mkDerivation { - pname = "elynx"; - version = "0.5.0.1"; - sha256 = "1rglf080hx4c8nai07ghh2wf6j79x9hfx2mjzbqc588y0rpj7kmj"; - isLibrary = false; - isExecutable = true; - executableHaskellDepends = [ - aeson base bytestring elynx-tools optparse-applicative slynx tlynx - ]; - description = "Validate and (optionally) redo ELynx analyses"; - license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "elynx_0_5_0_2" = callPackage ({ mkDerivation, aeson, base, bytestring, elynx-tools , optparse-applicative, slynx, tlynx }: @@ -83463,28 +82919,6 @@ self: { }) {}; "elynx-markov" = callPackage - ({ mkDerivation, async, attoparsec, base, bytestring, containers - , elynx-seq, elynx-tools, hmatrix, hspec, integration - , math-functions, mwc-random, parallel, primitive, statistics - , vector - }: - mkDerivation { - pname = "elynx-markov"; - version = "0.5.0.1"; - sha256 = "0m24kzayvhc2mhhk2glpw82kmdbgk38vl2d0xdkkdnnbqag8mbqa"; - libraryHaskellDepends = [ - async attoparsec base bytestring containers elynx-seq hmatrix - integration math-functions mwc-random parallel primitive statistics - vector - ]; - testHaskellDepends = [ - base containers elynx-tools hmatrix hspec mwc-random vector - ]; - description = "Simulate molecular sequences along trees"; - license = lib.licenses.gpl3Plus; - }) {}; - - "elynx-markov_0_5_0_2" = callPackage ({ mkDerivation, async, attoparsec, base, bytestring, containers , elynx-seq, elynx-tools, hmatrix, hspec, integration , math-functions, mwc-random, primitive, statistics, vector @@ -83503,22 +82937,9 @@ self: { benchmarkHaskellDepends = [ base ]; description = "Simulate molecular sequences along trees"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; }) {}; "elynx-nexus" = callPackage - ({ mkDerivation, attoparsec, base, bytestring, hspec }: - mkDerivation { - pname = "elynx-nexus"; - version = "0.5.0.1"; - sha256 = "0jh5j4f8awallrjbgrgdjl6jdzk2lswr28xjryqdapwf4licfkk2"; - libraryHaskellDepends = [ attoparsec base bytestring ]; - testHaskellDepends = [ base hspec ]; - description = "Import and export Nexus files"; - license = lib.licenses.gpl3Plus; - }) {}; - - "elynx-nexus_0_5_0_2" = callPackage ({ mkDerivation, attoparsec, base, bytestring, hspec }: mkDerivation { pname = "elynx-nexus"; @@ -83528,30 +82949,9 @@ self: { testHaskellDepends = [ base hspec ]; description = "Import and export Nexus files"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; }) {}; "elynx-seq" = callPackage - ({ mkDerivation, aeson, attoparsec, base, bytestring, containers - , elynx-tools, hspec, matrices, mwc-random, parallel, primitive - , vector, vector-th-unbox, word8 - }: - mkDerivation { - pname = "elynx-seq"; - version = "0.5.0.1"; - sha256 = "0b5jih0jgcf0rbcbwj18l269wbgf31i9125gx3rz6w7ydapmr7wr"; - libraryHaskellDepends = [ - aeson attoparsec base bytestring containers matrices mwc-random - parallel primitive vector vector-th-unbox word8 - ]; - testHaskellDepends = [ - base bytestring elynx-tools hspec matrices vector - ]; - description = "Handle molecular sequences"; - license = lib.licenses.gpl3Plus; - }) {}; - - "elynx-seq_0_5_0_2" = callPackage ({ mkDerivation, aeson, attoparsec, base, bytestring, containers , elynx-tools, hspec, matrices, mwc-random, parallel, primitive , vector, vector-th-unbox, word8 @@ -83569,32 +82969,9 @@ self: { ]; description = "Handle molecular sequences"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; }) {}; "elynx-tools" = callPackage - ({ mkDerivation, aeson, attoparsec, base, base16-bytestring - , bytestring, cryptohash-sha256, deepseq, directory, fast-logger - , hmatrix, monad-control, monad-logger, mwc-random - , optparse-applicative, primitive, template-haskell, text, time - , transformers, transformers-base, vector, zlib - }: - mkDerivation { - pname = "elynx-tools"; - version = "0.5.0.1"; - sha256 = "0lq5jv9dwyi0plkx1n270dan8nfxac9q7rhcdq95mzhgar8daink"; - libraryHaskellDepends = [ - aeson attoparsec base base16-bytestring bytestring - cryptohash-sha256 deepseq directory fast-logger hmatrix - monad-control monad-logger mwc-random optparse-applicative - primitive template-haskell text time transformers transformers-base - vector zlib - ]; - description = "Tools for ELynx"; - license = lib.licenses.gpl3Plus; - }) {}; - - "elynx-tools_0_5_0_2" = callPackage ({ mkDerivation, aeson, attoparsec, base, base16-bytestring , bytestring, cryptohash-sha256, deepseq, directory, fast-logger , hmatrix, monad-control, monad-logger, mwc-random @@ -83614,37 +82991,9 @@ self: { ]; description = "Tools for ELynx"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; }) {}; "elynx-tree" = callPackage - ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad - , containers, criterion, deepseq, double-conversion, elynx-nexus - , elynx-tools, hspec, math-functions, microlens, mwc-random - , parallel, primitive, QuickCheck, statistics - }: - mkDerivation { - pname = "elynx-tree"; - version = "0.5.0.1"; - sha256 = "1pzam7qg7qihim50iyxw2fsy58xakzjvzskaa4vhzg9cghmjjva8"; - libraryHaskellDepends = [ - aeson attoparsec base bytestring comonad containers deepseq - double-conversion elynx-nexus math-functions mwc-random parallel - primitive statistics - ]; - testHaskellDepends = [ - attoparsec base bytestring containers elynx-tools hspec QuickCheck - ]; - benchmarkHaskellDepends = [ - base criterion elynx-tools microlens mwc-random parallel - ]; - description = "Handle phylogenetic trees"; - license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "elynx-tree_0_5_0_2" = callPackage ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad , containers, criterion, deepseq, double-conversion, elynx-nexus , elynx-tools, hspec, math-functions, microlens, mwc-random @@ -85450,34 +84799,6 @@ self: { }) {}; "ersatz" = callPackage - ({ mkDerivation, array, attoparsec, base, bytestring, Cabal - , cabal-doctest, containers, data-default, directory, doctest, fail - , filepath, lens, mtl, parsec, process, semigroups, temporary - , transformers, unordered-containers - }: - mkDerivation { - pname = "ersatz"; - version = "0.4.8"; - sha256 = "1gddf8zhavxri80f3nnd29ff6k7n03ggcah4qglknci7h94z7v8c"; - isLibrary = true; - isExecutable = true; - enableSeparateDataOutput = true; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - array attoparsec base bytestring containers data-default lens mtl - process semigroups temporary transformers unordered-containers - ]; - executableHaskellDepends = [ - array base containers fail lens mtl parsec semigroups - ]; - testHaskellDepends = [ array base directory doctest filepath ]; - description = "A monad for expressing SAT or QSAT problems using observable sharing"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "ersatz_0_4_9" = callPackage ({ mkDerivation, array, attoparsec, base, bytestring, containers , data-default, fail, lens, mtl, parsec, process, semigroups , temporary, transformers, unordered-containers @@ -85705,34 +85026,6 @@ self: { }) {}; "esqueleto" = callPackage - ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring - , conduit, containers, exceptions, hspec, monad-logger, mtl, mysql - , mysql-simple, persistent, persistent-mysql, persistent-postgresql - , persistent-sqlite, persistent-template, postgresql-libpq - , postgresql-simple, resourcet, tagged, text, time, transformers - , unliftio, unordered-containers, vector - }: - mkDerivation { - pname = "esqueleto"; - version = "3.4.0.1"; - sha256 = "1vq8yfrixgqps8g6wvfgr9n42zmwj1jybiq3sbrgfj318n6dm5mc"; - libraryHaskellDepends = [ - aeson attoparsec base blaze-html bytestring conduit containers - monad-logger persistent resourcet tagged text time transformers - unliftio unordered-containers - ]; - testHaskellDepends = [ - aeson attoparsec base blaze-html bytestring conduit containers - exceptions hspec monad-logger mtl mysql mysql-simple persistent - persistent-mysql persistent-postgresql persistent-sqlite - persistent-template postgresql-libpq postgresql-simple resourcet - tagged text time transformers unliftio unordered-containers vector - ]; - description = "Type-safe EDSL for SQL queries on persistent backends"; - license = lib.licenses.bsd3; - }) {}; - - "esqueleto_3_4_1_0" = callPackage ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring , conduit, containers, exceptions, hspec, monad-logger, mtl, mysql , mysql-simple, persistent, persistent-mysql, persistent-postgresql @@ -85758,7 +85051,6 @@ self: { ]; description = "Type-safe EDSL for SQL queries on persistent backends"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "ess" = callPackage @@ -89224,28 +88516,6 @@ self: { }) {}; "fast-logger" = callPackage - ({ mkDerivation, array, auto-update, base, bytestring, directory - , easy-file, filepath, hspec, hspec-discover, text, unix-compat - , unix-time - }: - mkDerivation { - pname = "fast-logger"; - version = "3.0.2"; - sha256 = "0ilbjz09vw35jzfvkiqjy6zjbci2l60wcyjzfysrbxzk24qxmb5z"; - revision = "1"; - editedCabalFile = "1w8nsnjnpaxz8hm66gmh18msmc9hsafpladwy4ihvydb421fqpq2"; - libraryHaskellDepends = [ - array auto-update base bytestring directory easy-file filepath text - unix-compat unix-time - ]; - testHaskellDepends = [ base bytestring directory hspec ]; - testToolDepends = [ hspec-discover ]; - description = "A fast logging system"; - license = lib.licenses.bsd3; - maintainers = with lib.maintainers; [ sternenseemann ]; - }) {}; - - "fast-logger_3_0_3" = callPackage ({ mkDerivation, array, auto-update, base, bytestring, directory , easy-file, filepath, hspec, hspec-discover, text, unix-compat , unix-time @@ -89262,7 +88532,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A fast logging system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = with lib.maintainers; [ sternenseemann ]; }) {}; @@ -94033,6 +93302,28 @@ self: { license = lib.licenses.bsd3; }) {}; + "foldl_1_4_11" = callPackage + ({ mkDerivation, base, bytestring, comonad, containers + , contravariant, criterion, doctest, hashable, mwc-random + , primitive, profunctors, semigroupoids, text, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "foldl"; + version = "1.4.11"; + sha256 = "05i87pqldk1xfpx66nh1lhn75x3g7s8kvhf9k9yll33a6ggawwxl"; + libraryHaskellDepends = [ + base bytestring comonad containers contravariant hashable + mwc-random primitive profunctors semigroupoids text transformers + unordered-containers vector + ]; + testHaskellDepends = [ base doctest ]; + benchmarkHaskellDepends = [ base criterion ]; + description = "Composable, streaming, and efficient left folds"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "foldl-exceptions" = callPackage ({ mkDerivation, base, doctest, foldl, safe-exceptions }: mkDerivation { @@ -94148,31 +93439,6 @@ self: { }) {}; "folds" = callPackage - ({ mkDerivation, adjunctions, base, bifunctors, bytestring, Cabal - , cabal-doctest, comonad, constraints, contravariant, data-reify - , deepseq, directory, distributive, doctest, filepath, lens, mtl - , pointed, profunctors, reflection, semigroupoids, semigroups - , transformers, unordered-containers, vector - }: - mkDerivation { - pname = "folds"; - version = "0.7.5"; - sha256 = "17a8xggx17m59hiwd2lxd2379sw4xblgyv1pk9g5h93w3m8wgq1r"; - configureFlags = [ "-f-test-hlint" ]; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - adjunctions base bifunctors comonad constraints contravariant - data-reify distributive lens mtl pointed profunctors reflection - semigroupoids transformers unordered-containers vector - ]; - testHaskellDepends = [ - base bytestring deepseq directory doctest filepath mtl semigroups - ]; - description = "Beautiful Folding"; - license = lib.licenses.bsd3; - }) {}; - - "folds_0_7_6" = callPackage ({ mkDerivation, adjunctions, base, bifunctors, comonad , constraints, contravariant, data-reify, distributive, lens, mtl , pointed, profunctors, reflection, semigroupoids, transformers @@ -94190,7 +93456,6 @@ self: { ]; description = "Beautiful Folding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "folds-common" = callPackage @@ -95047,6 +94312,8 @@ self: { pname = "fourmolu"; version = "0.3.0.0"; sha256 = "0v89dvcr8l0swj23kkakc39q6lyxjz90rqgwy7m6a5p6iv3h2wms"; + revision = "1"; + editedCabalFile = "1n3avdmjqkd2910lhb5spxvjgzb7icln82pcrz3cmkfmjwxnirsc"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -97145,23 +96412,6 @@ self: { }) {}; "functor-classes-compat" = callPackage - ({ mkDerivation, base, containers, hashable, unordered-containers - , vector - }: - mkDerivation { - pname = "functor-classes-compat"; - version = "1"; - sha256 = "0vrnl5crr7d2wsm4ryx26g98j23dpk7x5p31xrbnckd78i7zj4gg"; - revision = "7"; - editedCabalFile = "0dagdnlb3wfrli6adpy4fjlgdc982pjgwcnq2sb7p3zm86ngi07v"; - libraryHaskellDepends = [ - base containers hashable unordered-containers vector - ]; - description = "Data.Functor.Classes instances for core packages"; - license = lib.licenses.bsd3; - }) {}; - - "functor-classes-compat_1_0_1" = callPackage ({ mkDerivation, base, containers, hashable, unordered-containers , vector }: @@ -97174,7 +96424,6 @@ self: { ]; description = "Data.Functor.Classes instances for core packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "functor-combinators" = callPackage @@ -99821,27 +99070,6 @@ self: { }) {}; "generics-sop" = callPackage - ({ mkDerivation, base, criterion, deepseq, ghc-prim, sop-core - , template-haskell, th-abstraction - }: - mkDerivation { - pname = "generics-sop"; - version = "0.5.1.0"; - sha256 = "0g0z0k5bnw3whfj3qswzhadrhg85jfn491s30cgai0ijfjm5gipa"; - revision = "1"; - editedCabalFile = "1m61bb6k96ybsrc3hpxn0fdspq9mbkyfklx7vfnd55mava4ahzp2"; - libraryHaskellDepends = [ - base ghc-prim sop-core template-haskell th-abstraction - ]; - testHaskellDepends = [ base ]; - benchmarkHaskellDepends = [ - base criterion deepseq template-haskell - ]; - description = "Generic Programming using True Sums of Products"; - license = lib.licenses.bsd3; - }) {}; - - "generics-sop_0_5_1_1" = callPackage ({ mkDerivation, base, criterion, deepseq, ghc-prim, sop-core , template-haskell, th-abstraction }: @@ -99858,7 +99086,6 @@ self: { ]; description = "Generic Programming using True Sums of Products"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "generics-sop-lens" = callPackage @@ -101324,29 +100551,6 @@ self: { }) {}; "ghc-exactprint" = callPackage - ({ mkDerivation, base, bytestring, containers, Diff, directory - , filemanip, filepath, free, ghc, ghc-boot, ghc-paths, HUnit, mtl - , silently, syb - }: - mkDerivation { - pname = "ghc-exactprint"; - version = "0.6.3.4"; - sha256 = "0x3z9zlghcd22v6hidby72w6g11xl6cbwyskzcjlv0235csr5v98"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base bytestring containers directory filepath free ghc ghc-boot - ghc-paths mtl syb - ]; - testHaskellDepends = [ - base bytestring containers Diff directory filemanip filepath ghc - ghc-boot ghc-paths HUnit mtl silently syb - ]; - description = "ExactPrint for GHC"; - license = lib.licenses.bsd3; - }) {}; - - "ghc-exactprint_0_6_4" = callPackage ({ mkDerivation, base, bytestring, containers, Diff, directory , filemanip, filepath, free, ghc, ghc-boot, ghc-paths, HUnit, mtl , silently, syb @@ -101367,7 +100571,6 @@ self: { ]; description = "ExactPrint for GHC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "ghc-gc-tune" = callPackage @@ -101856,27 +101059,6 @@ self: { }) {}; "ghc-prof" = callPackage - ({ mkDerivation, attoparsec, base, containers, directory, filepath - , process, scientific, tasty, tasty-hunit, temporary, text, time - }: - mkDerivation { - pname = "ghc-prof"; - version = "1.4.1.7"; - sha256 = "0js799sf957xlki8f7jgwj803iygi35j4bp4p4hh8gzj4icvcqfz"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - attoparsec base containers scientific text time - ]; - testHaskellDepends = [ - attoparsec base containers directory filepath process tasty - tasty-hunit temporary text - ]; - description = "Library for parsing GHC time and allocation profiling reports"; - license = lib.licenses.bsd3; - }) {}; - - "ghc-prof_1_4_1_8" = callPackage ({ mkDerivation, attoparsec, base, containers, directory, filepath , process, scientific, tasty, tasty-hunit, temporary, text, time }: @@ -101895,7 +101077,6 @@ self: { ]; description = "Library for parsing GHC time and allocation profiling reports"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "ghc-prof-aeson" = callPackage @@ -102242,22 +101423,6 @@ self: { }) {}; "ghc-typelits-natnormalise" = callPackage - ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra - , integer-gmp, tasty, tasty-hunit, template-haskell, transformers - }: - mkDerivation { - pname = "ghc-typelits-natnormalise"; - version = "0.7.3"; - sha256 = "14lynjsmiml19wma9fk2bbhfz43wzbbyvrxp8xpch2lkh5zkfkny"; - libraryHaskellDepends = [ - base containers ghc ghc-tcplugins-extra integer-gmp transformers - ]; - testHaskellDepends = [ base tasty tasty-hunit template-haskell ]; - description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat"; - license = lib.licenses.bsd2; - }) {}; - - "ghc-typelits-natnormalise_0_7_4" = callPackage ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra , integer-gmp, tasty, tasty-hunit, template-haskell, transformers }: @@ -102271,7 +101436,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit template-haskell ]; description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "ghc-typelits-presburger" = callPackage @@ -116262,8 +115426,8 @@ self: { }: mkDerivation { pname = "hanspell"; - version = "0.2.2.0"; - sha256 = "06351wg5y9840nj1ysraa78bixk25vjn64g6fnj3d0zs2qyxd6ca"; + version = "0.2.3.0"; + sha256 = "1n692i4d92g25j31v7iyp7w3135hxcdm5p18zki8mmx6x1pg244a"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -117891,19 +117055,6 @@ self: { }) {}; "hashable-time" = callPackage - ({ mkDerivation, base, hashable, time }: - mkDerivation { - pname = "hashable-time"; - version = "0.2.0.2"; - sha256 = "1q7y4plqqwy5286hhx2fygn12h8lqk0y047b597sbdckskxzfqgs"; - revision = "3"; - editedCabalFile = "1dr7ak803ngrhpv43dy25jm18gfzn02gzd3hm31dzcjv3mxsmbrk"; - libraryHaskellDepends = [ base hashable time ]; - description = "Hashable instances for Data.Time"; - license = lib.licenses.bsd3; - }) {}; - - "hashable-time_0_2_1" = callPackage ({ mkDerivation, base, hashable, time, time-compat }: mkDerivation { pname = "hashable-time"; @@ -117912,7 +117063,6 @@ self: { libraryHaskellDepends = [ base hashable time time-compat ]; description = "Hashable instances for Data.Time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "hashabler" = callPackage @@ -122997,23 +122147,6 @@ self: { }) {}; "hasty-hamiltonian" = callPackage - ({ mkDerivation, ad, base, kan-extensions, lens, mcmc-types - , mwc-probability, pipes, primitive, transformers - }: - mkDerivation { - pname = "hasty-hamiltonian"; - version = "1.3.3"; - sha256 = "11x0daijylcxg0zf55bcwac6dy6lmmz9f4zf7a44qp9dsgfv753a"; - libraryHaskellDepends = [ - base kan-extensions lens mcmc-types mwc-probability pipes primitive - transformers - ]; - testHaskellDepends = [ ad base mwc-probability ]; - description = "Speedy traversal through parameter space"; - license = lib.licenses.mit; - }) {}; - - "hasty-hamiltonian_1_3_4" = callPackage ({ mkDerivation, ad, base, kan-extensions, lens, mcmc-types , mwc-probability, pipes, primitive, transformers }: @@ -123028,7 +122161,6 @@ self: { testHaskellDepends = [ ad base mwc-probability ]; description = "Speedy traversal through parameter space"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hat" = callPackage @@ -127813,36 +126945,6 @@ self: { }) {}; "hie-bios" = callPackage - ({ mkDerivation, aeson, base, base16-bytestring, bytestring - , conduit, conduit-extra, containers, cryptohash-sha1, deepseq - , directory, extra, file-embed, filepath, ghc, hslogger - , hspec-expectations, process, tasty, tasty-expected-failure - , tasty-hunit, temporary, text, time, transformers, unix-compat - , unordered-containers, vector, yaml - }: - mkDerivation { - pname = "hie-bios"; - version = "0.7.2"; - sha256 = "0cff9kf4qnfkfzvxhxi0hh54x013g5sg0xcw0vpsarc3a91p7da8"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base base16-bytestring bytestring conduit conduit-extra - containers cryptohash-sha1 deepseq directory extra file-embed - filepath ghc hslogger process temporary text time transformers - unix-compat unordered-containers vector yaml - ]; - executableHaskellDepends = [ base directory filepath ghc ]; - testHaskellDepends = [ - base directory extra filepath ghc hspec-expectations tasty - tasty-expected-failure tasty-hunit temporary text - unordered-containers yaml - ]; - description = "Set up a GHC API session"; - license = lib.licenses.bsd3; - }) {}; - - "hie-bios_0_7_4" = callPackage ({ mkDerivation, aeson, base, base16-bytestring, bytestring , conduit, conduit-extra, containers, cryptohash-sha1, deepseq , directory, extra, file-embed, filepath, ghc, hslogger @@ -127872,7 +126974,6 @@ self: { ]; description = "Set up a GHC API session"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "hie-compat" = callPackage @@ -131287,34 +130388,6 @@ self: { }) {}; "hnix-store-core" = callPackage - ({ mkDerivation, base, base16-bytestring, base64-bytestring, binary - , bytestring, containers, cryptohash-md5, cryptohash-sha1 - , cryptohash-sha256, directory, filepath, hashable, mtl, process - , regex-base, regex-tdfa, saltine, tasty, tasty-discover - , tasty-hspec, tasty-hunit, tasty-quickcheck, temporary, text, time - , unix, unordered-containers, vector - }: - mkDerivation { - pname = "hnix-store-core"; - version = "0.2.0.0"; - sha256 = "1gy808dzaq2jjy1xdhf3vjxzprlzn9mmbxc554sa03v8f9hc0r7h"; - libraryHaskellDepends = [ - base base16-bytestring binary bytestring containers cryptohash-md5 - cryptohash-sha1 cryptohash-sha256 directory filepath hashable mtl - regex-base regex-tdfa saltine text time unix unordered-containers - vector - ]; - testHaskellDepends = [ - base base64-bytestring binary bytestring containers directory - process tasty tasty-discover tasty-hspec tasty-hunit - tasty-quickcheck temporary text - ]; - testToolDepends = [ tasty-discover ]; - description = "Core effects for interacting with the Nix store"; - license = lib.licenses.asl20; - }) {}; - - "hnix-store-core_0_4_1_0" = callPackage ({ mkDerivation, algebraic-graphs, attoparsec, base , base16-bytestring, base64-bytestring, binary, bytestring, cereal , containers, cryptohash-md5, cryptohash-sha1, cryptohash-sha256 @@ -131341,7 +130414,6 @@ self: { ]; description = "Core effects for interacting with the Nix store"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "hnix-store-remote" = callPackage @@ -133172,24 +132244,6 @@ self: { }) {}; "hp2pretty" = callPackage - ({ mkDerivation, array, attoparsec, base, containers, filepath - , floatshow, mtl, optparse-applicative, semigroups, text - }: - mkDerivation { - pname = "hp2pretty"; - version = "0.9"; - sha256 = "0libwl8kl6yhingvbrmw1b8l5yiq6wn07asvkwbnh9l6mnh8pz2n"; - isLibrary = false; - isExecutable = true; - executableHaskellDepends = [ - array attoparsec base containers filepath floatshow mtl - optparse-applicative semigroups text - ]; - description = "generate pretty graphs from heap profiles"; - license = lib.licenses.bsd3; - }) {}; - - "hp2pretty_0_10" = callPackage ({ mkDerivation, array, attoparsec, base, containers, filepath , floatshow, mtl, optparse-applicative, semigroups, text }: @@ -133205,7 +132259,6 @@ self: { ]; description = "generate pretty graphs from heap profiles"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "hpack" = callPackage @@ -140238,34 +139291,6 @@ self: { }) {}; "http-conduit" = callPackage - ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring - , case-insensitive, conduit, conduit-extra, connection, cookie - , data-default-class, hspec, http-client, http-client-tls - , http-types, HUnit, mtl, network, resourcet, streaming-commons - , temporary, text, time, tls, transformers, unliftio, unliftio-core - , utf8-string, wai, wai-conduit, warp, warp-tls - }: - mkDerivation { - pname = "http-conduit"; - version = "2.3.7.4"; - sha256 = "1mbaasmxx90gzfirwn8lmjpwj34gf1dk9y3m9mm88rzmy3s6czbb"; - libraryHaskellDepends = [ - aeson attoparsec base bytestring conduit conduit-extra http-client - http-client-tls http-types mtl resourcet transformers unliftio-core - ]; - testHaskellDepends = [ - aeson base blaze-builder bytestring case-insensitive conduit - conduit-extra connection cookie data-default-class hspec - http-client http-types HUnit network resourcet streaming-commons - temporary text time tls transformers unliftio utf8-string wai - wai-conduit warp warp-tls - ]; - doCheck = false; - description = "HTTP client package with conduit interface and HTTPS support"; - license = lib.licenses.bsd3; - }) {}; - - "http-conduit_2_3_8" = callPackage ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring , case-insensitive, conduit, conduit-extra, connection, cookie , data-default-class, hspec, http-client, http-client-tls @@ -140291,7 +139316,6 @@ self: { doCheck = false; description = "HTTP client package with conduit interface and HTTPS support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "http-conduit-browser" = callPackage @@ -140342,24 +139366,6 @@ self: { }) {}; "http-date" = callPackage - ({ mkDerivation, array, attoparsec, base, bytestring, doctest - , hspec, old-locale, time - }: - mkDerivation { - pname = "http-date"; - version = "0.0.10"; - sha256 = "1g3b895894mrscnm32x3a2nax3xvsp8aji11f0qd44xh7kz249zs"; - revision = "1"; - editedCabalFile = "13pq2x29pzh6ylp2crs33q9nkawwymaim6ma4x6hf0s3qdr7vzfh"; - libraryHaskellDepends = [ array attoparsec base bytestring time ]; - testHaskellDepends = [ - base bytestring doctest hspec old-locale time - ]; - description = "HTTP Date parser/formatter"; - license = lib.licenses.bsd3; - }) {}; - - "http-date_0_0_11" = callPackage ({ mkDerivation, array, attoparsec, base, bytestring, doctest , hspec, old-locale, time }: @@ -140373,7 +139379,6 @@ self: { ]; description = "HTTP Date parser/formatter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "http-directory" = callPackage @@ -144253,31 +143258,6 @@ self: { }) {}; "hyperloglog" = callPackage - ({ mkDerivation, approximate, base, binary, bits, bytes, Cabal - , cabal-doctest, cereal, cereal-vector, comonad, deepseq, directory - , distributive, doctest, filepath, generic-deriving, hashable, lens - , reflection, semigroupoids, semigroups, simple-reflect, siphash - , tagged, vector - }: - mkDerivation { - pname = "hyperloglog"; - version = "0.4.3"; - sha256 = "0r1zrhl81hm0sb9my32xyng0xdl2yzh1pdw2bqabzccrhyjk1fwd"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - approximate base binary bits bytes cereal cereal-vector comonad - deepseq distributive hashable lens reflection semigroupoids - semigroups siphash tagged vector - ]; - testHaskellDepends = [ - base directory doctest filepath generic-deriving semigroups - simple-reflect - ]; - description = "An approximate streaming (constant space) unique object counter"; - license = lib.licenses.bsd3; - }) {}; - - "hyperloglog_0_4_4" = callPackage ({ mkDerivation, approximate, base, binary, bits, bytes, cereal , cereal-vector, comonad, deepseq, distributive, hashable, lens , reflection, semigroupoids, semigroups, siphash, tagged, vector @@ -144293,7 +143273,6 @@ self: { ]; description = "An approximate streaming (constant space) unique object counter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "hyperloglogplus" = callPackage @@ -144343,28 +143322,6 @@ self: { }) {}; "hyphenation" = callPackage - ({ mkDerivation, base, bytestring, Cabal, cabal-doctest, containers - , doctest, text, unordered-containers, zlib - }: - mkDerivation { - pname = "hyphenation"; - version = "0.8"; - sha256 = "09c9xpygjnq7kqcaybls91s7g1cv40rg54dn9w1svk973h0lgyii"; - revision = "3"; - editedCabalFile = "0krjvrk5hzcs101b5h95ai51wwq1fj04q1ryn63j1qmj22jpn4ki"; - enableSeparateDataOutput = true; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - base bytestring containers text unordered-containers zlib - ]; - testHaskellDepends = [ - base containers doctest unordered-containers - ]; - description = "Configurable Knuth-Liang hyphenation"; - license = lib.licenses.bsd2; - }) {}; - - "hyphenation_0_8_1" = callPackage ({ mkDerivation, base, bytestring, containers, text , unordered-containers, zlib }: @@ -144378,7 +143335,6 @@ self: { ]; description = "Configurable Knuth-Liang hyphenation"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "hypher" = callPackage @@ -147353,33 +146309,6 @@ self: { }) {}; "influxdb" = callPackage - ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal - , cabal-doctest, clock, containers, doctest, foldl, http-client - , http-types, lens, network, optional-args, raw-strings-qq - , scientific, tagged, tasty, tasty-hunit, template-haskell, text - , time, unordered-containers, vector - }: - mkDerivation { - pname = "influxdb"; - version = "1.9.0"; - sha256 = "1d580f2j71x0iww0q2mg47jbhjsd83yarrnnmcp9f2bx7cix174v"; - isLibrary = true; - isExecutable = true; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - aeson attoparsec base bytestring clock containers foldl http-client - http-types lens network optional-args scientific tagged text time - unordered-containers vector - ]; - testHaskellDepends = [ - base containers doctest lens raw-strings-qq tasty tasty-hunit - template-haskell time vector - ]; - description = "Haskell client library for InfluxDB"; - license = lib.licenses.bsd3; - }) {}; - - "influxdb_1_9_1" = callPackage ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal , cabal-doctest, clock, containers, doctest, foldl, http-client , http-types, lens, network, optional-args, raw-strings-qq @@ -147404,7 +146333,6 @@ self: { ]; description = "InfluxDB client library for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "informative" = callPackage @@ -147759,30 +146687,6 @@ self: { }) {aether = null;}; "insert-ordered-containers" = callPackage - ({ mkDerivation, aeson, base, base-compat, hashable, lens - , optics-core, optics-extra, QuickCheck, semigroupoids, semigroups - , tasty, tasty-quickcheck, text, transformers, unordered-containers - }: - mkDerivation { - pname = "insert-ordered-containers"; - version = "0.2.3.1"; - sha256 = "020a56280mxjk9k97q2m1424m73m1sf1ccl0wm0ci9msyw2g51za"; - revision = "1"; - editedCabalFile = "1s90flzj3039s50r6hx7mqihf8lvarcqb6zps7m12x543gahfcq0"; - libraryHaskellDepends = [ - aeson base base-compat hashable lens optics-core optics-extra - semigroupoids semigroups text transformers unordered-containers - ]; - testHaskellDepends = [ - aeson base base-compat hashable lens QuickCheck semigroupoids - semigroups tasty tasty-quickcheck text transformers - unordered-containers - ]; - description = "Associative containers retaining insertion order for traversals"; - license = lib.licenses.bsd3; - }) {}; - - "insert-ordered-containers_0_2_4" = callPackage ({ mkDerivation, aeson, base, base-compat, hashable , indexed-traversable, lens, optics-core, optics-extra, QuickCheck , semigroupoids, semigroups, tasty, tasty-quickcheck, text @@ -147804,7 +146708,6 @@ self: { ]; description = "Associative containers retaining insertion order for traversals"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "inserts" = callPackage @@ -147838,22 +146741,6 @@ self: { }) {}; "inspection-testing" = callPackage - ({ mkDerivation, base, containers, ghc, mtl, template-haskell - , transformers - }: - mkDerivation { - pname = "inspection-testing"; - version = "0.4.2.4"; - sha256 = "11nz8j56l3h7sn927mcsms9af9rpqkmxc0c0vf9mln567wpb75h3"; - libraryHaskellDepends = [ - base containers ghc mtl template-haskell transformers - ]; - testHaskellDepends = [ base ]; - description = "GHC plugin to do inspection testing"; - license = lib.licenses.mit; - }) {}; - - "inspection-testing_0_4_3_0" = callPackage ({ mkDerivation, base, containers, ghc, mtl, template-haskell , transformers }: @@ -147867,7 +146754,6 @@ self: { testHaskellDepends = [ base ]; description = "GHC plugin to do inspection testing"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "inspector-wrecker" = callPackage @@ -148421,23 +147307,6 @@ self: { }) {}; "intern" = callPackage - ({ mkDerivation, array, base, bytestring, hashable, text - , unordered-containers - }: - mkDerivation { - pname = "intern"; - version = "0.9.3"; - sha256 = "1pbk804kq5p25ixrihhpfgy0fwj8i6cybxlhk42krzni7ad7gx4k"; - revision = "1"; - editedCabalFile = "1cjlmvg55nn9fd1f0jfmgy1rjys7gna3x3qknnpcmndq6vzg1mrl"; - libraryHaskellDepends = [ - array base bytestring hashable text unordered-containers - ]; - description = "Efficient hash-consing for arbitrary data types"; - license = lib.licenses.bsd3; - }) {}; - - "intern_0_9_4" = callPackage ({ mkDerivation, array, base, bytestring, hashable, text , unordered-containers }: @@ -148450,7 +147319,6 @@ self: { ]; description = "Efficient hash-consing for arbitrary data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "internetmarke" = callPackage @@ -148768,26 +147636,6 @@ self: { }) {}; "intervals" = callPackage - ({ mkDerivation, array, base, Cabal, cabal-doctest, directory - , distributive, doctest, filepath, ghc-prim, QuickCheck - , template-haskell - }: - mkDerivation { - pname = "intervals"; - version = "0.9.1"; - sha256 = "1s9pj2dah94smq769q4annxv2grdx376wvhzl4rsq85kjppf5a6z"; - revision = "2"; - editedCabalFile = "1nrpc95wwifnlk7p9nw6xgcc74zw1k6krhvll7rr18ddjgfgv07x"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ array base distributive ghc-prim ]; - testHaskellDepends = [ - base directory doctest filepath QuickCheck template-haskell - ]; - description = "Interval Arithmetic"; - license = lib.licenses.bsd3; - }) {}; - - "intervals_0_9_2" = callPackage ({ mkDerivation, array, base, distributive, ghc-prim, QuickCheck }: mkDerivation { pname = "intervals"; @@ -148797,7 +147645,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Interval Arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "intmap-graph" = callPackage @@ -151883,21 +150730,6 @@ self: { }) {}; "jira-wiki-markup" = callPackage - ({ mkDerivation, base, mtl, parsec, tasty, tasty-hunit, text }: - mkDerivation { - pname = "jira-wiki-markup"; - version = "1.3.2"; - sha256 = "16vcy9gn6qrzvr99l26az4yi2dy9xngcb1wmj86yl7bmk1hcq3wc"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base mtl parsec text ]; - executableHaskellDepends = [ base text ]; - testHaskellDepends = [ base parsec tasty tasty-hunit text ]; - description = "Handle Jira wiki markup"; - license = lib.licenses.mit; - }) {}; - - "jira-wiki-markup_1_3_3" = callPackage ({ mkDerivation, base, mtl, parsec, tasty, tasty-hunit, text }: mkDerivation { pname = "jira-wiki-markup"; @@ -151910,7 +150742,6 @@ self: { testHaskellDepends = [ base parsec tasty tasty-hunit text ]; description = "Handle Jira wiki markup"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "jmacro" = callPackage @@ -154347,24 +153178,6 @@ self: { }) {}; "kan-extensions" = callPackage - ({ mkDerivation, adjunctions, array, base, comonad, containers - , contravariant, distributive, free, invariant, mtl, profunctors - , semigroupoids, tagged, transformers, transformers-compat - }: - mkDerivation { - pname = "kan-extensions"; - version = "5.2.1"; - sha256 = "114zs8j81ich4178qvvlnpch09dvbv1mm1g7xf2g78f77gh9ia7a"; - libraryHaskellDepends = [ - adjunctions array base comonad containers contravariant - distributive free invariant mtl profunctors semigroupoids tagged - transformers transformers-compat - ]; - description = "Kan extensions, Kan lifts, the Yoneda lemma, and (co)density (co)monads"; - license = lib.licenses.bsd3; - }) {}; - - "kan-extensions_5_2_2" = callPackage ({ mkDerivation, adjunctions, array, base, comonad, containers , contravariant, distributive, free, invariant, mtl, profunctors , semigroupoids, tagged, transformers, transformers-compat @@ -154380,7 +153193,6 @@ self: { ]; description = "Kan extensions, Kan lifts, the Yoneda lemma, and (co)density (co)monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "kangaroo" = callPackage @@ -158299,27 +157111,6 @@ self: { }) {}; "language-docker" = callPackage - ({ mkDerivation, base, bytestring, containers, data-default-class - , hspec, HUnit, megaparsec, prettyprinter, QuickCheck, split, text - , time - }: - mkDerivation { - pname = "language-docker"; - version = "9.1.2"; - sha256 = "014rb5jf650fhsmc02v4xc60w7v1261ri1w9ig6dw0xjdgxalvbs"; - libraryHaskellDepends = [ - base bytestring containers data-default-class megaparsec - prettyprinter split text time - ]; - testHaskellDepends = [ - base bytestring containers data-default-class hspec HUnit - megaparsec prettyprinter QuickCheck split text time - ]; - description = "Dockerfile parser, pretty-printer and embedded DSL"; - license = lib.licenses.gpl3; - }) {}; - - "language-docker_9_1_3" = callPackage ({ mkDerivation, base, bytestring, containers, data-default-class , hspec, HUnit, megaparsec, prettyprinter, QuickCheck, split, text , time @@ -158338,7 +157129,6 @@ self: { ]; description = "Dockerfile parser, pretty-printer and embedded DSL"; license = lib.licenses.gpl3; - hydraPlatforms = lib.platforms.none; }) {}; "language-dockerfile" = callPackage @@ -160160,19 +158950,6 @@ self: { }) {}; "lca" = callPackage - ({ mkDerivation, base, Cabal, cabal-doctest, doctest }: - mkDerivation { - pname = "lca"; - version = "0.3.1"; - sha256 = "0kj3zsmzckczp51w70x1aqayk2fay4vcqwz8j6sdv0hdw1d093ca"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ base ]; - testHaskellDepends = [ base doctest ]; - description = "O(log n) persistent online lowest common ancestor search without preprocessing"; - license = lib.licenses.bsd3; - }) {}; - - "lca_0_4" = callPackage ({ mkDerivation, base }: mkDerivation { pname = "lca"; @@ -160181,7 +158958,6 @@ self: { libraryHaskellDepends = [ base ]; description = "O(log n) persistent online lowest common ancestor search without preprocessing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "lcs" = callPackage @@ -160888,25 +159664,6 @@ self: { }) {}; "lens-action" = callPackage - ({ mkDerivation, base, Cabal, cabal-doctest, comonad, contravariant - , directory, doctest, filepath, lens, mtl, profunctors - , semigroupoids, semigroups, transformers - }: - mkDerivation { - pname = "lens-action"; - version = "0.2.4"; - sha256 = "06yg4ds0d4cfs3zl1fhc8865i5w6pwqhx9bxngfa8f9974mdiid3"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - base comonad contravariant lens mtl profunctors semigroupoids - semigroups transformers - ]; - testHaskellDepends = [ base directory doctest filepath ]; - description = "Monadic Getters and Folds"; - license = lib.licenses.bsd3; - }) {}; - - "lens-action_0_2_5" = callPackage ({ mkDerivation, base, comonad, contravariant, lens, mtl , profunctors, semigroupoids, transformers }: @@ -160920,33 +159677,9 @@ self: { ]; description = "Monadic Getters and Folds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "lens-aeson" = callPackage - ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal - , cabal-doctest, doctest, generic-deriving, lens, scientific - , semigroups, simple-reflect, text, unordered-containers, vector - }: - mkDerivation { - pname = "lens-aeson"; - version = "1.1"; - sha256 = "03n9dkdyqkkf15h8k4c4bjwgjcbbs2an2cf6z8x54nvkjmprrg7p"; - revision = "4"; - editedCabalFile = "1wgk0nd0fxgdbqb6mkslj3gyrs9vdxpb83hvj2n2dcswg3ahwdsy"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - aeson attoparsec base bytestring lens scientific text - unordered-containers vector - ]; - testHaskellDepends = [ - base doctest generic-deriving semigroups simple-reflect - ]; - description = "Law-abiding lenses for aeson"; - license = lib.licenses.mit; - }) {}; - - "lens-aeson_1_1_1" = callPackage ({ mkDerivation, aeson, attoparsec, base, bytestring, lens , scientific, text, unordered-containers, vector }: @@ -160960,7 +159693,6 @@ self: { ]; description = "Law-abiding lenses for aeson"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "lens-core" = callPackage @@ -161177,26 +159909,6 @@ self: { }) {}; "lens-regex" = callPackage - ({ mkDerivation, array, base, directory, doctest, filepath, lens - , regex-base, regex-posix, template-haskell - }: - mkDerivation { - pname = "lens-regex"; - version = "0.1.1"; - sha256 = "0c673v6k6y7dng6qmi4jbh3jlx803mg5g1911bz54r785fm6p50d"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - array base lens regex-base template-haskell - ]; - testHaskellDepends = [ - base directory doctest filepath regex-posix - ]; - description = "Lens powered regular expression"; - license = lib.licenses.bsd3; - }) {}; - - "lens-regex_0_1_3" = callPackage ({ mkDerivation, array, base, directory, doctest, filepath, lens , regex-base, regex-posix, template-haskell }: @@ -161214,7 +159926,6 @@ self: { ]; description = "Lens powered regular expression"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "lens-regex-pcre" = callPackage @@ -163492,32 +162203,6 @@ self: { }) {}; "linear" = callPackage - ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes - , bytestring, cereal, containers, deepseq, distributive, ghc-prim - , hashable, HUnit, lens, random, reflection, semigroupoids - , semigroups, simple-reflect, tagged, template-haskell - , test-framework, test-framework-hunit, transformers - , transformers-compat, unordered-containers, vector, void - }: - mkDerivation { - pname = "linear"; - version = "1.21.4"; - sha256 = "019dsw4xqcmz8g0hanc3xsl0k1pqzxkhp9jz1sf12mqsgs6jj0zr"; - libraryHaskellDepends = [ - adjunctions base base-orphans binary bytes cereal containers - deepseq distributive ghc-prim hashable lens random reflection - semigroupoids semigroups tagged template-haskell transformers - transformers-compat unordered-containers vector void - ]; - testHaskellDepends = [ - base binary bytestring deepseq HUnit reflection simple-reflect - test-framework test-framework-hunit vector - ]; - description = "Linear Algebra"; - license = lib.licenses.bsd3; - }) {}; - - "linear_1_21_5" = callPackage ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes , bytestring, cereal, containers, deepseq, distributive, ghc-prim , hashable, HUnit, indexed-traversable, lens, random, reflection @@ -163542,7 +162227,6 @@ self: { ]; description = "Linear Algebra"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "linear-accelerate" = callPackage @@ -166240,29 +164924,6 @@ self: { }) {}; "log-domain" = callPackage - ({ mkDerivation, base, binary, bytes, Cabal, cabal-doctest, cereal - , comonad, deepseq, distributive, doctest, generic-deriving - , hashable, semigroupoids, semigroups, simple-reflect, vector - }: - mkDerivation { - pname = "log-domain"; - version = "0.13"; - sha256 = "0isl8rs0k5088sxapfh351sff3lh7r1qkgwz8lmai3gvqasb3avv"; - revision = "3"; - editedCabalFile = "10ajmxkjbbkdrkasgfd5hhjcbggrylrg00m1lafac53v97hqpyp1"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - base binary bytes cereal comonad deepseq distributive hashable - semigroupoids semigroups vector - ]; - testHaskellDepends = [ - base doctest generic-deriving semigroups simple-reflect - ]; - description = "Log-domain arithmetic"; - license = lib.licenses.bsd3; - }) {}; - - "log-domain_0_13_1" = callPackage ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq , distributive, hashable, semigroupoids, semigroups, vector }: @@ -166276,7 +164937,6 @@ self: { ]; description = "Log-domain arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "log-effect" = callPackage @@ -167350,18 +166010,18 @@ self: { }) {}; "lorentz" = callPackage - ({ mkDerivation, aeson-pretty, base, bimap, bytestring, constraints - , containers, data-default, first-class-families, fmt, interpolate - , lens, morley, morley-prelude, mtl, named, optparse-applicative - , singletons, template-haskell, text, text-manipulate - , unordered-containers, vinyl, with-utf8 + ({ mkDerivation, aeson-pretty, base-noprelude, bimap, bytestring + , constraints, containers, data-default, first-class-families, fmt + , interpolate, lens, morley, morley-prelude, mtl, named + , optparse-applicative, singletons, template-haskell, text + , text-manipulate, unordered-containers, vinyl, with-utf8 }: mkDerivation { pname = "lorentz"; - version = "0.9.1"; - sha256 = "1f4rf4q6gfiz55qlfpkzk19nq6fw92ri3a1smyv4r55i50jr07rm"; + version = "0.10.0"; + sha256 = "15kgnw8f52i30xxw1q6mxlyhkpfpq5hyjsvfklg334iqr5w0nby2"; libraryHaskellDepends = [ - aeson-pretty base bimap bytestring constraints containers + aeson-pretty base-noprelude bimap bytestring constraints containers data-default first-class-families fmt interpolate lens morley morley-prelude mtl named optparse-applicative singletons template-haskell text text-manipulate unordered-containers vinyl @@ -168834,32 +167494,6 @@ self: { }) {}; "machines" = callPackage - ({ mkDerivation, adjunctions, base, Cabal, cabal-doctest, comonad - , conduit, containers, criterion, distributive, doctest, mtl, pipes - , pointed, profunctors, semigroupoids, semigroups, streaming - , transformers, transformers-compat, void - }: - mkDerivation { - pname = "machines"; - version = "0.7.1"; - sha256 = "0ayajyzaczdazfsmamlm5vap43x2mdm4w8v5970y1xlxh4rb3bs1"; - revision = "1"; - editedCabalFile = "1cp850vwzn213n0k9s5i62889a1wvmyi05jw6kmazaczcbcs7jsq"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - adjunctions base comonad containers distributive mtl pointed - profunctors semigroupoids semigroups transformers - transformers-compat void - ]; - testHaskellDepends = [ base doctest ]; - benchmarkHaskellDepends = [ - base conduit criterion mtl pipes streaming - ]; - description = "Networked stream transducers"; - license = lib.licenses.bsd3; - }) {}; - - "machines_0_7_2" = callPackage ({ mkDerivation, adjunctions, base, comonad, conduit, containers , criterion, distributive, mtl, pipes, pointed, profunctors , semigroupoids, semigroups, streaming, transformers @@ -168879,7 +167513,6 @@ self: { ]; description = "Networked stream transducers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "machines-amazonka" = callPackage @@ -169264,8 +167897,8 @@ self: { }: mkDerivation { pname = "magic-wormhole"; - version = "0.3.3"; - sha256 = "1wsm7y05k8byxizkmkyl7bciyz6f3jwxiwqc0gvsqi31kkqajxqn"; + version = "0.3.4"; + sha256 = "1i9010zp1w34kfgx5xgd23hjmb0v8h3y3riiw2ripvjxqgikbky4"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -174722,23 +173355,6 @@ self: { }) {}; "mime-mail" = callPackage - ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring - , filepath, hspec, process, random, text - }: - mkDerivation { - pname = "mime-mail"; - version = "0.5.0"; - sha256 = "0vs302vbdf8y58nxky0m2w7cbqs4laljk969sfnbxl8zq7k3ic0h"; - libraryHaskellDepends = [ - base base64-bytestring blaze-builder bytestring filepath process - random text - ]; - testHaskellDepends = [ base blaze-builder bytestring hspec text ]; - description = "Compose MIME email messages"; - license = lib.licenses.mit; - }) {}; - - "mime-mail_0_5_1" = callPackage ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring , filepath, hspec, process, random, text }: @@ -174753,7 +173369,6 @@ self: { testHaskellDepends = [ base blaze-builder bytestring hspec text ]; description = "Compose MIME email messages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "mime-mail-ses" = callPackage @@ -175933,21 +174548,6 @@ self: { }) {}; "mmorph" = callPackage - ({ mkDerivation, base, mtl, transformers, transformers-compat }: - mkDerivation { - pname = "mmorph"; - version = "1.1.4"; - sha256 = "1hxyyh0x58kjdsyf1kj2kibjxzk2d9rcabv2y9vrpb59w85lqanz"; - revision = "1"; - editedCabalFile = "0xvwjcfpy6243wiwgyckmwc1nbw31y32n3hrrswdjw21znz894yl"; - libraryHaskellDepends = [ - base mtl transformers transformers-compat - ]; - description = "Monad morphisms"; - license = lib.licenses.bsd3; - }) {}; - - "mmorph_1_1_5" = callPackage ({ mkDerivation, base, mtl, transformers, transformers-compat }: mkDerivation { pname = "mmorph"; @@ -175958,7 +174558,6 @@ self: { ]; description = "Monad morphisms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "mmsyn2" = callPackage @@ -176388,32 +174987,6 @@ self: { }) {}; "modern-uri" = callPackage - ({ mkDerivation, base, bytestring, containers, contravariant - , criterion, deepseq, exceptions, hspec, hspec-discover - , hspec-megaparsec, megaparsec, mtl, profunctors, QuickCheck - , reflection, tagged, template-haskell, text, weigh - }: - mkDerivation { - pname = "modern-uri"; - version = "0.3.3.1"; - sha256 = "0h4ssb4wy4ac6vd5jcbvp0r2fr1jmyc60hg56s7ym50bbymj5wp3"; - libraryHaskellDepends = [ - base bytestring containers contravariant deepseq exceptions - megaparsec mtl profunctors QuickCheck reflection tagged - template-haskell text - ]; - testHaskellDepends = [ - base bytestring hspec hspec-megaparsec megaparsec QuickCheck text - ]; - testToolDepends = [ hspec-discover ]; - benchmarkHaskellDepends = [ - base bytestring criterion deepseq megaparsec text weigh - ]; - description = "Modern library for working with URIs"; - license = lib.licenses.bsd3; - }) {}; - - "modern-uri_0_3_4_0" = callPackage ({ mkDerivation, base, bytestring, containers, contravariant , criterion, deepseq, exceptions, hspec, hspec-discover , hspec-megaparsec, megaparsec, mtl, profunctors, QuickCheck @@ -176437,7 +175010,6 @@ self: { ]; description = "Modern library for working with URIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "modify-fasta" = callPackage @@ -179019,37 +177591,45 @@ self: { }) {morfeusz = null;}; "morley" = callPackage - ({ mkDerivation, aeson, aeson-casing, aeson-pretty, base - , base58-bytestring, binary, bytestring, constraints, containers - , cryptonite, data-default, first-class-families, fmt - , generic-deriving, gitrev, haskeline, hex-text, interpolate, lens - , megaparsec, memory, morley-prelude, mtl, named - , optparse-applicative, parser-combinators, scientific, semigroups - , show-type, singletons, syb, template-haskell, text - , text-manipulate, th-lift, th-lift-instances, time, timerep + ({ mkDerivation, aeson, aeson-casing, aeson-pretty, base-noprelude + , base58-bytestring, binary, bytestring, Cabal, constraints + , containers, cryptonite, data-default, doctest, elliptic-curve + , first-class-families, fmt, galois-field, generic-deriving, gitrev + , haskeline, hex-text, interpolate, lens, megaparsec, memory + , MonadRandom, morley-prelude, mtl, named, optparse-applicative + , pairing, parser-combinators, process, scientific, semigroups + , show-type, singletons, syb, tasty-discover, template-haskell + , text, text-manipulate, th-lift, th-lift-instances, time, timerep , uncaught-exception, unordered-containers, vector, vinyl , with-utf8, wl-pprint-text }: mkDerivation { pname = "morley"; - version = "1.12.0"; - sha256 = "0cfmcrasf2cfirsa6xb1aznj75bwnzmiy9irirk1i9p2bx4aqy5m"; + version = "1.13.0"; + sha256 = "1jbjmri2k7z5fh96i0yx28wpcp0l3fchkk3iwvq0vdwcrb78bndb"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - aeson aeson-casing aeson-pretty base base58-bytestring binary - bytestring constraints containers cryptonite data-default - first-class-families fmt generic-deriving gitrev hex-text - interpolate lens megaparsec memory morley-prelude mtl named - optparse-applicative parser-combinators scientific semigroups - show-type singletons syb template-haskell text text-manipulate - th-lift th-lift-instances time timerep uncaught-exception - unordered-containers vector vinyl with-utf8 wl-pprint-text + aeson aeson-casing aeson-pretty base-noprelude base58-bytestring + binary bytestring constraints containers cryptonite data-default + elliptic-curve first-class-families fmt galois-field + generic-deriving gitrev hex-text interpolate lens megaparsec memory + MonadRandom morley-prelude mtl named optparse-applicative pairing + parser-combinators scientific semigroups show-type singletons syb + template-haskell text text-manipulate th-lift th-lift-instances + time timerep uncaught-exception unordered-containers vector vinyl + with-utf8 wl-pprint-text ]; executableHaskellDepends = [ - aeson base bytestring data-default fmt haskeline megaparsec - morley-prelude named optparse-applicative text vinyl with-utf8 + aeson base-noprelude bytestring data-default fmt haskeline + megaparsec morley-prelude named optparse-applicative text vinyl + with-utf8 ]; + testHaskellDepends = [ + base-noprelude bytestring Cabal doctest morley-prelude + optparse-applicative process + ]; + testToolDepends = [ tasty-discover ]; description = "Developer tools for the Michelson Language"; license = lib.licenses.mit; hydraPlatforms = lib.platforms.none; @@ -179150,6 +177730,60 @@ self: { license = lib.licenses.mit; }) {}; + "morpheus-graphql_0_17_0" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers + , morpheus-graphql-app, morpheus-graphql-core + , morpheus-graphql-subscriptions, mtl, relude, tasty, tasty-hunit + , template-haskell, text, transformers, unordered-containers + , vector + }: + mkDerivation { + pname = "morpheus-graphql"; + version = "0.17.0"; + sha256 = "0k9nlik5qi1ff4m731da5wlaadx024irgn2v1hyz2bv9n1q28cqs"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base bytestring containers morpheus-graphql-app + morpheus-graphql-core mtl relude template-haskell text transformers + unordered-containers vector + ]; + testHaskellDepends = [ + aeson base bytestring containers morpheus-graphql-app + morpheus-graphql-core morpheus-graphql-subscriptions mtl relude + tasty tasty-hunit template-haskell text transformers + unordered-containers vector + ]; + description = "Morpheus GraphQL"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + + "morpheus-graphql-app" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, directory + , hashable, megaparsec, morpheus-graphql-core, mtl, relude + , scientific, tasty, tasty-hunit, template-haskell, text + , th-lift-instances, transformers, unordered-containers, vector + }: + mkDerivation { + pname = "morpheus-graphql-app"; + version = "0.17.0"; + sha256 = "0l3brvcv7ang83yiv1bdg4v8hvajq4cbq2dr28q1j39a4r85f9xz"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base bytestring containers hashable megaparsec + morpheus-graphql-core mtl relude scientific template-haskell text + th-lift-instances transformers unordered-containers vector + ]; + testHaskellDepends = [ + aeson base bytestring containers directory hashable megaparsec + morpheus-graphql-core mtl relude scientific tasty tasty-hunit + template-haskell text th-lift-instances transformers + unordered-containers vector + ]; + description = "Morpheus GraphQL Core"; + license = lib.licenses.mit; + }) {}; + "morpheus-graphql-cli" = callPackage ({ mkDerivation, base, bytestring, filepath, morpheus-graphql , optparse-applicative @@ -179195,6 +177829,30 @@ self: { license = lib.licenses.mit; }) {}; + "morpheus-graphql-client_0_17_0" = callPackage + ({ mkDerivation, aeson, base, bytestring, directory + , morpheus-graphql-core, mtl, relude, tasty, tasty-hunit + , template-haskell, text, transformers, unordered-containers + }: + mkDerivation { + pname = "morpheus-graphql-client"; + version = "0.17.0"; + sha256 = "1djgxy59s98na1s182p5a06qjhw8n862zka96wwp8ckyx2jpjkq3"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base bytestring morpheus-graphql-core mtl relude + template-haskell text transformers unordered-containers + ]; + testHaskellDepends = [ + aeson base bytestring directory morpheus-graphql-core mtl relude + tasty tasty-hunit template-haskell text transformers + unordered-containers + ]; + description = "Morpheus GraphQL Client"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "morpheus-graphql-core" = callPackage ({ mkDerivation, aeson, base, bytestring, directory, hashable , megaparsec, mtl, relude, scientific, tasty, tasty-hunit @@ -179220,6 +177878,32 @@ self: { license = lib.licenses.mit; }) {}; + "morpheus-graphql-core_0_17_0" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, directory + , hashable, megaparsec, mtl, relude, scientific, tasty, tasty-hunit + , template-haskell, text, th-lift-instances, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "morpheus-graphql-core"; + version = "0.17.0"; + sha256 = "0rj4g05365hp5c9b5y0v0v7s73jw3gkq3g0z3m6xrpxi3j2gp0p8"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base bytestring containers hashable megaparsec mtl relude + scientific template-haskell text th-lift-instances transformers + unordered-containers vector + ]; + testHaskellDepends = [ + aeson base bytestring containers directory hashable megaparsec mtl + relude scientific tasty tasty-hunit template-haskell text + th-lift-instances transformers unordered-containers vector + ]; + description = "Morpheus GraphQL Core"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "morpheus-graphql-subscriptions" = callPackage ({ mkDerivation, aeson, base, bytestring, directory , morpheus-graphql-core, mtl, relude, tasty, tasty-hunit, text @@ -179243,6 +177927,31 @@ self: { license = lib.licenses.mit; }) {}; + "morpheus-graphql-subscriptions_0_17_0" = callPackage + ({ mkDerivation, aeson, base, bytestring, directory + , morpheus-graphql-app, morpheus-graphql-core, mtl, relude, tasty + , tasty-hunit, text, transformers, unliftio-core + , unordered-containers, uuid, websockets + }: + mkDerivation { + pname = "morpheus-graphql-subscriptions"; + version = "0.17.0"; + sha256 = "14bpnzxxiid5582z5fi8nwb8rrhm7lgxscgkjxw34ng41wyv6686"; + libraryHaskellDepends = [ + aeson base bytestring morpheus-graphql-app morpheus-graphql-core + mtl relude text transformers unliftio-core unordered-containers + uuid websockets + ]; + testHaskellDepends = [ + aeson base bytestring directory morpheus-graphql-app + morpheus-graphql-core mtl relude tasty tasty-hunit text + transformers unliftio-core unordered-containers uuid websockets + ]; + description = "Morpheus GraphQL Subscriptions"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "morphisms" = callPackage ({ mkDerivation }: mkDerivation { @@ -188405,20 +187114,6 @@ self: { }) {}; "nri-env-parser" = callPackage - ({ mkDerivation, base, modern-uri, network-uri, nri-prelude, text - }: - mkDerivation { - pname = "nri-env-parser"; - version = "0.1.0.3"; - sha256 = "0335bpjqvkazfjx2k0dm460hzdwcwz1rn82x0nvf441njjqz6846"; - libraryHaskellDepends = [ - base modern-uri network-uri nri-prelude text - ]; - description = "Read environment variables as settings to build 12-factor apps"; - license = lib.licenses.bsd3; - }) {}; - - "nri-env-parser_0_1_0_4" = callPackage ({ mkDerivation, base, modern-uri, network-uri, nri-prelude, text }: mkDerivation { @@ -188430,34 +187125,9 @@ self: { ]; description = "Read environment variables as settings to build 12-factor apps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "nri-prelude" = callPackage - ({ mkDerivation, aeson, ansi-terminal, async, auto-update, base - , bytestring, containers, directory, exceptions, filepath, hedgehog - , junit-xml, pretty-diff, pretty-show, safe-exceptions - , terminal-size, text, time, vector - }: - mkDerivation { - pname = "nri-prelude"; - version = "0.3.0.0"; - sha256 = "1dijid038rvviz063ncviq1mw20hsk02gidcf68vzy99d16kn5c9"; - libraryHaskellDepends = [ - aeson ansi-terminal async auto-update base bytestring containers - directory exceptions filepath hedgehog junit-xml pretty-diff - pretty-show safe-exceptions terminal-size text time vector - ]; - testHaskellDepends = [ - aeson ansi-terminal async auto-update base bytestring containers - directory exceptions filepath hedgehog junit-xml pretty-diff - pretty-show safe-exceptions terminal-size text time vector - ]; - description = "A Prelude inspired by the Elm programming language"; - license = lib.licenses.bsd3; - }) {}; - - "nri-prelude_0_4_0_0" = callPackage ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async , auto-update, base, bytestring, containers, directory, exceptions , filepath, ghc, hedgehog, junit-xml, pretty-diff, pretty-show @@ -188481,7 +187151,6 @@ self: { ]; description = "A Prelude inspired by the Elm programming language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "nsis" = callPackage @@ -201539,22 +200208,6 @@ self: { }) {}; "pipes-bytestring" = callPackage - ({ mkDerivation, base, bytestring, pipes, pipes-group, pipes-parse - , stringsearch, transformers - }: - mkDerivation { - pname = "pipes-bytestring"; - version = "2.1.6"; - sha256 = "061wcb48mdq694zhwb5xh423ss6f7cccxahc05cifrzkh033gp5i"; - libraryHaskellDepends = [ - base bytestring pipes pipes-group pipes-parse stringsearch - transformers - ]; - description = "ByteString support for pipes"; - license = lib.licenses.bsd3; - }) {}; - - "pipes-bytestring_2_1_7" = callPackage ({ mkDerivation, base, bytestring, pipes, pipes-group, pipes-parse , stringsearch, transformers }: @@ -201568,7 +200221,6 @@ self: { ]; description = "ByteString support for pipes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "pipes-bzip" = callPackage @@ -202181,6 +200833,19 @@ self: { license = lib.licenses.bsd3; }) {}; + "pipes-ordered-zip_1_2_1" = callPackage + ({ mkDerivation, base, foldl, hspec, pipes, pipes-safe }: + mkDerivation { + pname = "pipes-ordered-zip"; + version = "1.2.1"; + sha256 = "0jgqnx5jdra5v0r7v564zzd96jfv42lbkdxgk1k7ip8gcikb1zdm"; + libraryHaskellDepends = [ base pipes pipes-safe ]; + testHaskellDepends = [ base foldl hspec pipes pipes-safe ]; + description = "merge two ordered Producers into a new Producer"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "pipes-p2p" = callPackage ({ mkDerivation, async, base, binary, bytestring, errors , exceptions, mtl, network, network-simple-sockaddr, pipes @@ -202221,17 +200886,6 @@ self: { }) {}; "pipes-parse" = callPackage - ({ mkDerivation, base, pipes, transformers }: - mkDerivation { - pname = "pipes-parse"; - version = "3.0.8"; - sha256 = "1a87q6l610rhxr23qfzzzif3zpfjhw3mg5gfcyjwqac25hdq73yj"; - libraryHaskellDepends = [ base pipes transformers ]; - description = "Parsing infrastructure for the pipes ecosystem"; - license = lib.licenses.bsd3; - }) {}; - - "pipes-parse_3_0_9" = callPackage ({ mkDerivation, base, pipes, transformers }: mkDerivation { pname = "pipes-parse"; @@ -202240,7 +200894,6 @@ self: { libraryHaskellDepends = [ base pipes transformers ]; description = "Parsing infrastructure for the pipes ecosystem"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "pipes-postgresql-simple" = callPackage @@ -202336,22 +200989,6 @@ self: { }) {}; "pipes-safe" = callPackage - ({ mkDerivation, base, containers, exceptions, monad-control, mtl - , pipes, primitive, transformers, transformers-base - }: - mkDerivation { - pname = "pipes-safe"; - version = "2.3.2"; - sha256 = "10m6f52nahxwnl2zvgnbilllcvd3lpi0dxl3j6fk20lryjzmhyqc"; - libraryHaskellDepends = [ - base containers exceptions monad-control mtl pipes primitive - transformers transformers-base - ]; - description = "Safety for the pipes ecosystem"; - license = lib.licenses.bsd3; - }) {}; - - "pipes-safe_2_3_3" = callPackage ({ mkDerivation, base, containers, exceptions, monad-control, mtl , pipes, primitive, transformers, transformers-base }: @@ -202365,7 +201002,6 @@ self: { ]; description = "Safety for the pipes ecosystem"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "pipes-shell" = callPackage @@ -202629,15 +201265,17 @@ self: { }) {}; "pixel-printer" = callPackage - ({ mkDerivation, base, JuicyPixels, lens }: + ({ mkDerivation, base, JuicyPixels, lens, optparse-applicative }: mkDerivation { pname = "pixel-printer"; - version = "0.1.0"; - sha256 = "1cx485lvd5z6895jv1iiq93kspch78w9m730ggw6nvf0rimvazyy"; + version = "0.1.1"; + sha256 = "179r8715rmd7njan4jl0g3jy0w0xq420nmkw9arvp50my8ag610f"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base JuicyPixels lens ]; - executableHaskellDepends = [ base JuicyPixels ]; + executableHaskellDepends = [ + base JuicyPixels optparse-applicative + ]; testHaskellDepends = [ base ]; description = "A program for turning pixel art into 3D prints"; license = lib.licenses.gpl3; @@ -204270,8 +202908,8 @@ self: { pname = "polyparse"; version = "1.13"; sha256 = "0yvhg718dlksiw3v27m2d8m1sn4r4f5s0p56zq3lynhy1sc74k0w"; - revision = "1"; - editedCabalFile = "09jcn26py3lkjn3lvxgry86bad8xb8cwl3avxymqmf7b181krfb8"; + revision = "2"; + editedCabalFile = "1n5q6w7x46cvcq7j1pg9jx9h72vcsc5di35rbkmwgjw6pq4w4gfl"; libraryHaskellDepends = [ base bytestring text ]; description = "A variety of alternative parser combinator libraries"; license = "LGPL"; @@ -207739,8 +206377,8 @@ self: { }: mkDerivation { pname = "pretty-diff"; - version = "0.2.0.3"; - sha256 = "1pnq05zw7zyfikga8y27pkya4wrf0m3mrksmzi8l7jp9qdhkyia1"; + version = "0.4.0.2"; + sha256 = "0wa70is5pmad4f0spj5hmi56y290k1xizs4zwlrgry65r8c1qgns"; libraryHaskellDepends = [ base data-default Diff text ]; testHaskellDepends = [ base data-default Diff tasty tasty-hunit tasty-test-reporter text @@ -207749,14 +206387,14 @@ self: { license = lib.licenses.bsd3; }) {}; - "pretty-diff_0_4_0_2" = callPackage + "pretty-diff_0_4_0_3" = callPackage ({ mkDerivation, base, data-default, Diff, tasty, tasty-hunit , tasty-test-reporter, text }: mkDerivation { pname = "pretty-diff"; - version = "0.4.0.2"; - sha256 = "0wa70is5pmad4f0spj5hmi56y290k1xizs4zwlrgry65r8c1qgns"; + version = "0.4.0.3"; + sha256 = "0qzsq9dm95f6yjryl2675rbyx178zxl562x0y9i1py2rx4k8z7gl"; libraryHaskellDepends = [ base data-default Diff text ]; testHaskellDepends = [ base data-default Diff tasty tasty-hunit tasty-test-reporter text @@ -208444,30 +207082,6 @@ self: { }) {}; "primitive-extras" = callPackage - ({ mkDerivation, base, bytestring, cereal, deferred-folds, focus - , foldl, list-t, primitive, primitive-unlifted, profunctors - , QuickCheck, quickcheck-instances, rerebase, tasty, tasty-hunit - , tasty-quickcheck, vector - }: - mkDerivation { - pname = "primitive-extras"; - version = "0.8"; - sha256 = "0g3b7b842wbdh7hqr6ikvycdwk1n3in9dq5yb09g744ydpmvg24r"; - libraryHaskellDepends = [ - base bytestring cereal deferred-folds focus foldl list-t primitive - primitive-unlifted profunctors vector - ]; - testHaskellDepends = [ - cereal deferred-folds focus primitive QuickCheck - quickcheck-instances rerebase tasty tasty-hunit tasty-quickcheck - ]; - description = "Extras for the \"primitive\" library"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "primitive-extras_0_10_1" = callPackage ({ mkDerivation, base, bytestring, cereal, deferred-folds, focus , foldl, list-t, primitive, primitive-unlifted, profunctors , QuickCheck, quickcheck-instances, rerebase, tasty, tasty-hunit @@ -215180,23 +213794,6 @@ self: { }) {}; "random-bytestring" = callPackage - ({ mkDerivation, async, base, bytestring, criterion, cryptonite - , entropy, ghc-prim, mwc-random, pcg-random, primitive, random - }: - mkDerivation { - pname = "random-bytestring"; - version = "0.1.3.2"; - sha256 = "16mjdb1sy7ppfbj5hshjpyrly6mklzvxip8vrqcvsfm869pkzayw"; - libraryHaskellDepends = [ base bytestring mwc-random pcg-random ]; - benchmarkHaskellDepends = [ - async base bytestring criterion cryptonite entropy ghc-prim - mwc-random pcg-random primitive random - ]; - description = "Efficient generation of random bytestrings"; - license = lib.licenses.mit; - }) {}; - - "random-bytestring_0_1_4" = callPackage ({ mkDerivation, async, base, bytestring, criterion, cryptonite , entropy, ghc-prim, mwc-random, pcg-random, primitive, random }: @@ -215211,7 +213808,6 @@ self: { ]; description = "Efficient generation of random bytestrings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "random-class" = callPackage @@ -216425,34 +215021,6 @@ self: { }) {}; "rcu" = callPackage - ({ mkDerivation, atomic-primops, base, Cabal, cabal-doctest - , containers, criterion, deepseq, doctest, fail, ghc-prim - , optparse-applicative, parallel, primitive, rdtsc, time - , transformers - }: - mkDerivation { - pname = "rcu"; - version = "0.2.4"; - sha256 = "1zl6gl6b9x2ppxzrvb356216f7gi1kpwxsqb0w220f86wyzf9gbr"; - revision = "2"; - editedCabalFile = "1lblpsgprk26nplfzxkclvj6gsaim1b97njvrq564crryn6hn2wz"; - isLibrary = true; - isExecutable = true; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - atomic-primops base fail ghc-prim parallel primitive transformers - ]; - executableHaskellDepends = [ base transformers ]; - testHaskellDepends = [ base doctest parallel ]; - benchmarkHaskellDepends = [ - base containers criterion deepseq ghc-prim optparse-applicative - primitive rdtsc time transformers - ]; - description = "Read-Copy-Update for Haskell"; - license = lib.licenses.bsd3; - }) {}; - - "rcu_0_2_5" = callPackage ({ mkDerivation, atomic-primops, base, containers, criterion , deepseq, fail, ghc-prim, optparse-applicative, parallel , primitive, rdtsc, time, transformers @@ -216473,7 +215041,6 @@ self: { ]; description = "Read-Copy-Update for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "rdf" = callPackage @@ -217273,44 +215840,6 @@ self: { }) {}; "reanimate" = callPackage - ({ mkDerivation, aeson, ansi-terminal, array, attoparsec, base - , base64-bytestring, bytestring, cassava, cereal, colour - , containers, cryptohash-sha256, cubicbezier, directory, filelock - , filepath, fingertree, fsnotify, geojson, hashable, hgeometry - , hgeometry-combinatorial, JuicyPixels, lens, linear, matrix, mtl - , neat-interpolation, network, open-browser, optparse-applicative - , parallel, process, QuickCheck, random, random-shuffle - , reanimate-svg, split, tasty, tasty-expected-failure, tasty-golden - , tasty-hunit, tasty-quickcheck, tasty-rerun, temporary, text, time - , unix, unordered-containers, vector, vector-space, websockets, xml - }: - mkDerivation { - pname = "reanimate"; - version = "1.1.3.2"; - sha256 = "006fj47pm7lqs4haq0i0nmz6syqx3v07qgnh4vjqlyqixk22cyy5"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - aeson ansi-terminal array attoparsec base base64-bytestring - bytestring cassava cereal colour containers cryptohash-sha256 - cubicbezier directory filelock filepath fingertree fsnotify geojson - hashable hgeometry hgeometry-combinatorial JuicyPixels lens linear - matrix mtl neat-interpolation network open-browser - optparse-applicative parallel process random random-shuffle - reanimate-svg split temporary text time unix unordered-containers - vector vector-space websockets xml - ]; - testHaskellDepends = [ - base bytestring directory filepath linear process QuickCheck tasty - tasty-expected-failure tasty-golden tasty-hunit tasty-quickcheck - tasty-rerun temporary text vector - ]; - description = "Animation library based on SVGs"; - license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "reanimate_1_1_3_3" = callPackage ({ mkDerivation, aeson, ansi-terminal, array, attoparsec, base , base64-bytestring, bytestring, cassava, cereal, colour , containers, cryptohash-sha256, cubicbezier, directory, filelock @@ -217349,33 +215878,6 @@ self: { }) {}; "reanimate-svg" = callPackage - ({ mkDerivation, attoparsec, base, bytestring, containers, Diff - , directory, double-conversion, filepath, hashable, JuicyPixels - , lens, linear, mtl, process, QuickCheck, scientific, tasty - , tasty-expected-failure, tasty-golden, tasty-hunit - , tasty-quickcheck, tasty-rerun, temporary, text, transformers - , typed-process, vector, xml - }: - mkDerivation { - pname = "reanimate-svg"; - version = "0.13.0.0"; - sha256 = "0fl3rb993zihwm9vyg615x4k17rrqimjfpc7k06mb5dlgkd39f7v"; - libraryHaskellDepends = [ - attoparsec base bytestring containers double-conversion hashable - JuicyPixels lens linear mtl scientific text transformers vector xml - ]; - testHaskellDepends = [ - base bytestring Diff directory filepath linear process QuickCheck - tasty tasty-expected-failure tasty-golden tasty-hunit - tasty-quickcheck tasty-rerun temporary text typed-process vector - ]; - description = "SVG file loader and serializer"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "reanimate-svg_0_13_0_1" = callPackage ({ mkDerivation, attoparsec, base, bytestring, containers, Diff , directory, double-conversion, filepath, hashable, JuicyPixels , lens, linear, mtl, process, QuickCheck, scientific, tasty @@ -217565,23 +216067,6 @@ self: { }) {}; "record-dot-preprocessor" = callPackage - ({ mkDerivation, base, extra, filepath, ghc, record-hasfield - , uniplate - }: - mkDerivation { - pname = "record-dot-preprocessor"; - version = "0.2.7"; - sha256 = "1ma1rc962z2qr7xwxh03bkbcmn9dsqizrjv699wbc82fzfzn5hrr"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base extra ghc uniplate ]; - executableHaskellDepends = [ base extra ]; - testHaskellDepends = [ base extra filepath record-hasfield ]; - description = "Preprocessor to allow record.field syntax"; - license = lib.licenses.bsd3; - }) {}; - - "record-dot-preprocessor_0_2_8" = callPackage ({ mkDerivation, base, extra, filepath, ghc, record-hasfield , uniplate }: @@ -217596,7 +216081,6 @@ self: { testHaskellDepends = [ base extra filepath record-hasfield ]; description = "Preprocessor to allow record.field syntax"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "record-encode" = callPackage @@ -217775,23 +216259,6 @@ self: { }) {}; "recursion-schemes" = callPackage - ({ mkDerivation, base, base-orphans, comonad, containers, data-fix - , free, HUnit, template-haskell, th-abstraction, transformers - }: - mkDerivation { - pname = "recursion-schemes"; - version = "5.2.1"; - sha256 = "0yx7pj25p6h8qjsgxbjsxaz23ar21wyxr8wqpmsn61pk8mahwggl"; - libraryHaskellDepends = [ - base base-orphans comonad containers data-fix free template-haskell - th-abstraction transformers - ]; - testHaskellDepends = [ base HUnit template-haskell transformers ]; - description = "Representing common recursion patterns as higher-order functions"; - license = lib.licenses.bsd2; - }) {}; - - "recursion-schemes_5_2_2" = callPackage ({ mkDerivation, base, base-orphans, comonad, containers, data-fix , free, HUnit, template-haskell, th-abstraction, transformers }: @@ -217806,7 +216273,6 @@ self: { testHaskellDepends = [ base HUnit template-haskell transformers ]; description = "Representing common recursion patterns as higher-order functions"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "recursion-schemes-ext" = callPackage @@ -219434,21 +217900,6 @@ self: { }) {}; "regex-base" = callPackage - ({ mkDerivation, array, base, bytestring, containers, mtl, text }: - mkDerivation { - pname = "regex-base"; - version = "0.94.0.0"; - sha256 = "055rlq67xnbqv43fgrlw6d7s8nhyavahrp6blihwjmqizksq47y4"; - revision = "1"; - editedCabalFile = "13lnky4ps9as73jqrwz4aqn5sfyrcz2zj2ng52xzz512fv59baj4"; - libraryHaskellDepends = [ - array base bytestring containers mtl text - ]; - description = "Common \"Text.Regex.*\" API for Regex matching"; - license = lib.licenses.bsd3; - }) {}; - - "regex-base_0_94_0_1" = callPackage ({ mkDerivation, array, base, bytestring, containers, mtl, text }: mkDerivation { pname = "regex-base"; @@ -219459,23 +217910,9 @@ self: { ]; description = "Common \"Text.Regex.*\" API for Regex matching"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "regex-compat" = callPackage - ({ mkDerivation, array, base, regex-base, regex-posix }: - mkDerivation { - pname = "regex-compat"; - version = "0.95.2.0"; - sha256 = "01l44zrfpqb4k1rrzd1j18hn6922xhrl9h7s0hjfs363dx3hxj8z"; - revision = "1"; - editedCabalFile = "1d2k9zj51rhy695vlx6cfcmik6a0yyk5kl6aza7nqsqc6zwhidif"; - libraryHaskellDepends = [ array base regex-base regex-posix ]; - description = "Replaces/Enhances \"Text.Regex\""; - license = lib.licenses.bsd3; - }) {}; - - "regex-compat_0_95_2_1" = callPackage ({ mkDerivation, array, base, regex-base, regex-posix }: mkDerivation { pname = "regex-compat"; @@ -219484,7 +217921,6 @@ self: { libraryHaskellDepends = [ array base regex-base regex-posix ]; description = "Replaces/enhances \"Text.Regex\""; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "regex-compat-tdfa" = callPackage @@ -226356,29 +224792,6 @@ self: { }) {}; "safecopy" = callPackage - ({ mkDerivation, array, base, bytestring, cereal, containers - , generic-data, HUnit, lens, lens-action, old-time, QuickCheck - , quickcheck-instances, tasty, tasty-quickcheck, template-haskell - , text, time, transformers, vector - }: - mkDerivation { - pname = "safecopy"; - version = "0.10.3.1"; - sha256 = "0y2jpykad7inzndw4azb2wdp4zp3smjax95sdcxycw5x88rxdra1"; - libraryHaskellDepends = [ - array base bytestring cereal containers generic-data old-time - template-haskell text time transformers vector - ]; - testHaskellDepends = [ - array base bytestring cereal containers HUnit lens lens-action - QuickCheck quickcheck-instances tasty tasty-quickcheck - template-haskell time vector - ]; - description = "Binary serialization with version control"; - license = lib.licenses.publicDomain; - }) {}; - - "safecopy_0_10_4_1" = callPackage ({ mkDerivation, array, base, bytestring, cereal, containers , generic-data, HUnit, lens, lens-action, old-time, QuickCheck , quickcheck-instances, tasty, tasty-quickcheck, template-haskell @@ -226399,7 +224812,6 @@ self: { ]; description = "Binary serialization with version control"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; }) {}; "safecopy-migrate" = callPackage @@ -226661,8 +225073,8 @@ self: { pname = "salak"; version = "0.3.6"; sha256 = "00qyd09az0ldfidfgcki8z3r9gcpxmss3iyr99as5bky29rlz9n3"; - revision = "3"; - editedCabalFile = "0cdp6gy3r92vhpmq2i7yg4xxmnj95dyfvaf8gm05v6wl8l6rihfy"; + revision = "4"; + editedCabalFile = "07q9a24ry6h6r3m1av0dxz39dzmyjhlcrw1ww5jprqcf3xxjxhdz"; libraryHaskellDepends = [ base bytestring containers data-default directory dlist exceptions filepath hashable heaps megaparsec mtl scientific text time @@ -229248,25 +227660,6 @@ self: { }) {}; "sdl2-ttf" = callPackage - ({ mkDerivation, base, bytestring, SDL2, sdl2, SDL2_ttf - , template-haskell, text, transformers - }: - mkDerivation { - pname = "sdl2-ttf"; - version = "2.1.1"; - sha256 = "1iyqm1i5k8j4948gvr59rgalqwsdkishs52kp85ncvb6cpylw3qn"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base bytestring sdl2 template-haskell text transformers - ]; - libraryPkgconfigDepends = [ SDL2 SDL2_ttf ]; - description = "Bindings to SDL2_ttf"; - license = lib.licenses.bsd3; - platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ]; - }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_ttf;}; - - "sdl2-ttf_2_1_2" = callPackage ({ mkDerivation, base, bytestring, SDL2, sdl2, SDL2_ttf , template-haskell, text, th-abstraction, transformers }: @@ -229284,7 +227677,6 @@ self: { description = "Bindings to SDL2_ttf"; license = lib.licenses.bsd3; platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ]; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_ttf;}; "sdnv" = callPackage @@ -230190,6 +228582,25 @@ self: { license = lib.licenses.bsd3; }) {}; + "semialign_1_2" = callPackage + ({ mkDerivation, base, containers, hashable, indexed-traversable + , indexed-traversable-instances, semigroupoids, tagged, these + , transformers, unordered-containers, vector + }: + mkDerivation { + pname = "semialign"; + version = "1.2"; + sha256 = "04dcyj69g7bm1sydxk89vin9mh2pmm0pqf0cm9v981i98xp6xxdj"; + libraryHaskellDepends = [ + base containers hashable indexed-traversable + indexed-traversable-instances semigroupoids tagged these + transformers unordered-containers vector + ]; + description = "Align and Zip type-classes from the common Semialign ancestor"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "semialign-extras" = callPackage ({ mkDerivation, base, doctest, lens, QuickCheck, semialign , semialign-indexed, these, witherable @@ -230228,6 +228639,19 @@ self: { license = lib.licenses.bsd3; }) {}; + "semialign-indexed_1_2" = callPackage + ({ mkDerivation, base, lens, semialign }: + mkDerivation { + pname = "semialign-indexed"; + version = "1.2"; + sha256 = "16f0y3j85zlq2f8z45z085dizvbx4ihppp1ww3swh5daj0zf3kzy"; + libraryHaskellDepends = [ base lens semialign ]; + doHaddock = false; + description = "SemialignWithIndex, i.e. izipWith and ialignWith"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "semialign-optics" = callPackage ({ mkDerivation, base, containers, hashable, optics-extra , semialign, these, unordered-containers, vector @@ -230246,6 +228670,19 @@ self: { license = lib.licenses.bsd3; }) {}; + "semialign-optics_1_2" = callPackage + ({ mkDerivation, base, optics-core, semialign }: + mkDerivation { + pname = "semialign-optics"; + version = "1.2"; + sha256 = "04vh689mmnb5q77v6ifhg7xf7m2qh5x4i4804rm4biw78130xqr1"; + libraryHaskellDepends = [ base optics-core semialign ]; + doHaddock = false; + description = "SemialignWithIndex, i.e. izipWith and ialignWith"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "semibounded-lattices" = callPackage ({ mkDerivation, base, containers, lattices }: mkDerivation { @@ -230852,6 +229289,30 @@ self: { license = lib.licenses.gpl3; }) {}; + "sequence-formats_1_6_0" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers, errors + , exceptions, foldl, hspec, lens-family, pipes, pipes-attoparsec + , pipes-bytestring, pipes-safe, tasty, tasty-hunit, transformers + , vector + }: + mkDerivation { + pname = "sequence-formats"; + version = "1.6.0"; + sha256 = "1vy2wwzpnqd2c0ma3jm46gx3w3al0j61ncr22bcahsb1nrgmg0dq"; + libraryHaskellDepends = [ + attoparsec base bytestring containers errors exceptions foldl + lens-family pipes pipes-attoparsec pipes-bytestring pipes-safe + transformers vector + ]; + testHaskellDepends = [ + base bytestring containers foldl hspec pipes pipes-safe tasty + tasty-hunit transformers vector + ]; + description = "A package with basic parsing utilities for several Bioinformatic data formats"; + license = lib.licenses.gpl3; + hydraPlatforms = lib.platforms.none; + }) {}; + "sequenceTools" = callPackage ({ mkDerivation, ansi-wl-pprint, base, bytestring, foldl, hspec , lens-family, optparse-applicative, pipes, pipes-group @@ -233870,30 +232331,6 @@ self: { }) {}; "serversession" = callPackage - ({ mkDerivation, aeson, base, base64-bytestring, bytestring - , containers, data-default, hashable, hspec, nonce, path-pieces - , QuickCheck, text, time, transformers, unordered-containers - }: - mkDerivation { - pname = "serversession"; - version = "1.0.1"; - sha256 = "08j8v6a2018bmvwsb7crdg0ajak74jggb073pdpx9s0pf3cfzyrz"; - revision = "2"; - editedCabalFile = "0i5faxzxgvpfylmrr175f8l4asyh4phncc90jkfag53gnspcv028"; - libraryHaskellDepends = [ - aeson base base64-bytestring bytestring data-default hashable nonce - path-pieces text time transformers unordered-containers - ]; - testHaskellDepends = [ - aeson base base64-bytestring bytestring containers data-default - hspec nonce path-pieces QuickCheck text time transformers - unordered-containers - ]; - description = "Secure, modular server-side sessions"; - license = lib.licenses.mit; - }) {}; - - "serversession_1_0_2" = callPackage ({ mkDerivation, aeson, base, base64-bytestring, bytestring , containers, data-default, hashable, hspec, nonce, path-pieces , persistent-test, QuickCheck, text, time, transformers @@ -233915,7 +232352,6 @@ self: { ]; description = "Secure, modular server-side sessions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "serversession-backend-acid-state" = callPackage @@ -238613,28 +237049,6 @@ self: { }) {}; "skylighting" = callPackage - ({ mkDerivation, base, binary, blaze-html, bytestring, containers - , directory, filepath, pretty-show, skylighting-core, text - }: - mkDerivation { - pname = "skylighting"; - version = "0.10.2"; - sha256 = "1f60fnr8d8a28fr785hjzaaakss1ncn0998sz740xb76wp6q7pqd"; - configureFlags = [ "-fexecutable" ]; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base binary bytestring containers skylighting-core - ]; - executableHaskellDepends = [ - base blaze-html bytestring containers directory filepath - pretty-show text - ]; - description = "syntax highlighting library"; - license = lib.licenses.gpl2; - }) {}; - - "skylighting_0_10_3" = callPackage ({ mkDerivation, base, binary, blaze-html, bytestring, containers , directory, filepath, pretty-show, skylighting-core, text }: @@ -238654,41 +237068,9 @@ self: { ]; description = "syntax highlighting library"; license = lib.licenses.gpl2; - hydraPlatforms = lib.platforms.none; }) {}; "skylighting-core" = callPackage - ({ mkDerivation, aeson, ansi-terminal, attoparsec, base - , base64-bytestring, binary, blaze-html, bytestring - , case-insensitive, colour, containers, criterion, Diff, directory - , filepath, HUnit, hxt, mtl, pretty-show, QuickCheck, random, safe - , tasty, tasty-golden, tasty-hunit, tasty-quickcheck, text - , transformers, utf8-string - }: - mkDerivation { - pname = "skylighting-core"; - version = "0.10.2"; - sha256 = "1igqskmcbhk7b3fv1a1fxvfc4s3mc2sf96q90bf5iipy0h3f2zbg"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson ansi-terminal attoparsec base base64-bytestring binary - blaze-html bytestring case-insensitive colour containers directory - filepath hxt mtl safe text transformers utf8-string - ]; - testHaskellDepends = [ - aeson base bytestring containers Diff directory filepath HUnit - pretty-show QuickCheck random tasty tasty-golden tasty-hunit - tasty-quickcheck text utf8-string - ]; - benchmarkHaskellDepends = [ - base containers criterion directory filepath text - ]; - description = "syntax highlighting library"; - license = lib.licenses.bsd3; - }) {}; - - "skylighting-core_0_10_3" = callPackage ({ mkDerivation, aeson, ansi-terminal, attoparsec, base , base64-bytestring, binary, blaze-html, bytestring , case-insensitive, colour, containers, criterion, Diff, directory @@ -238717,7 +237099,6 @@ self: { ]; description = "syntax highlighting library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "skylighting-extensions" = callPackage @@ -239251,30 +237632,6 @@ self: { }) {}; "slynx" = callPackage - ({ mkDerivation, async, attoparsec, base, bytestring, containers - , elynx-markov, elynx-seq, elynx-tools, elynx-tree, hmatrix - , monad-logger, mwc-random, optparse-applicative, statistics, text - , transformers, vector - }: - mkDerivation { - pname = "slynx"; - version = "0.5.0.1"; - sha256 = "013ck07xgna42a5vlk6a323z3x1jrggbjw7jr2ww8mpgvpw2wp8r"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - async attoparsec base bytestring containers elynx-markov elynx-seq - elynx-tools elynx-tree hmatrix monad-logger mwc-random - optparse-applicative statistics text transformers vector - ]; - executableHaskellDepends = [ base ]; - description = "Handle molecular sequences"; - license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "slynx_0_5_0_2" = callPackage ({ mkDerivation, attoparsec, base, bytestring, containers , elynx-markov, elynx-seq, elynx-tools, elynx-tree, hmatrix , monad-logger, mwc-random, optparse-applicative, statistics, text @@ -242033,8 +240390,8 @@ self: { pname = "sockets-and-pipes"; version = "0.1"; sha256 = "02xc2kddcz93d9yqdchml0yh9gypcx64315baj766adgf8np42nv"; - revision = "2"; - editedCabalFile = "0rfkw9hq50xvrkb6wyp4g48pj0v6y4z1apmcba1svzwgni9am93d"; + revision = "4"; + editedCabalFile = "1lv2zpyblqryr59ii3zvwi5f06vxsgnla1xa14rardhncs36fa8r"; libraryHaskellDepends = [ aeson ascii async base blaze-html bytestring containers network safe-exceptions stm text time @@ -243258,23 +241615,6 @@ self: { }) {}; "speedy-slice" = callPackage - ({ mkDerivation, base, containers, kan-extensions, lens, mcmc-types - , mwc-probability, pipes, primitive, transformers - }: - mkDerivation { - pname = "speedy-slice"; - version = "0.3.1"; - sha256 = "0i139wp2c75q8a5q018z7ps1ghbqjkkd8nh6z6xfp0rqywq2bsnr"; - libraryHaskellDepends = [ - base kan-extensions lens mcmc-types mwc-probability pipes primitive - transformers - ]; - testHaskellDepends = [ base containers ]; - description = "Speedy slice sampling"; - license = lib.licenses.mit; - }) {}; - - "speedy-slice_0_3_2" = callPackage ({ mkDerivation, base, containers, kan-extensions, lens, mcmc-types , mwc-probability, pipes, primitive, transformers }: @@ -243289,7 +241629,6 @@ self: { testHaskellDepends = [ base containers ]; description = "Speedy slice sampling"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "spelling-suggest" = callPackage @@ -246963,34 +245302,6 @@ self: { }) {}; "stm-hamt" = callPackage - ({ mkDerivation, async, base, criterion, deferred-folds, focus - , free, hashable, list-t, mwc-random, mwc-random-monad, primitive - , primitive-extras, QuickCheck, quickcheck-instances, rebase - , rerebase, tasty, tasty-hunit, tasty-quickcheck, transformers - }: - mkDerivation { - pname = "stm-hamt"; - version = "1.2.0.4"; - sha256 = "0hlzi1zg58mgnb77982hkssm86ds66fs5nf1g2hcjjbjawchx3mj"; - libraryHaskellDepends = [ - base deferred-folds focus hashable list-t primitive - primitive-extras transformers - ]; - testHaskellDepends = [ - deferred-folds focus QuickCheck quickcheck-instances rerebase tasty - tasty-hunit tasty-quickcheck - ]; - benchmarkHaskellDepends = [ - async criterion focus free list-t mwc-random mwc-random-monad - rebase - ]; - description = "STM-specialised Hash Array Mapped Trie"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "stm-hamt_1_2_0_6" = callPackage ({ mkDerivation, async, base, criterion, deferred-folds, focus , free, hashable, list-t, mwc-random, mwc-random-monad, primitive , primitive-extras, QuickCheck, quickcheck-instances, rebase @@ -248909,36 +247220,6 @@ self: { }) {}; "string-interpolate" = callPackage - ({ mkDerivation, base, bytestring, criterion, deepseq, formatting - , haskell-src-exts, haskell-src-meta, hspec, hspec-core - , interpolate, neat-interpolation, QuickCheck, quickcheck-instances - , quickcheck-text, quickcheck-unicode, split, template-haskell - , text, text-conversions, unordered-containers, utf8-string - }: - mkDerivation { - pname = "string-interpolate"; - version = "0.3.0.2"; - sha256 = "1dkw4q2fxnr7gnish45lryxwrmdy93ffa1010qdnjlnz5m3dxbyl"; - revision = "1"; - editedCabalFile = "1rwylfxa821260mxfsr6l6grcyz7gxk18mvjijfhg5sm53v4c1ka"; - libraryHaskellDepends = [ - base bytestring haskell-src-exts haskell-src-meta split - template-haskell text text-conversions utf8-string - ]; - testHaskellDepends = [ - base bytestring hspec hspec-core QuickCheck quickcheck-instances - quickcheck-text quickcheck-unicode template-haskell text - unordered-containers - ]; - benchmarkHaskellDepends = [ - base bytestring criterion deepseq formatting interpolate - neat-interpolation QuickCheck text - ]; - description = "Haskell string/text/bytestring interpolation that just works"; - license = lib.licenses.bsd3; - }) {}; - - "string-interpolate_0_3_1_0" = callPackage ({ mkDerivation, base, bytestring, criterion, deepseq, formatting , haskell-src-exts, haskell-src-meta, hspec, hspec-core , interpolate, neat-interpolation, QuickCheck, quickcheck-instances @@ -248964,7 +247245,6 @@ self: { ]; description = "Haskell string/text/bytestring interpolation that just works"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "string-isos" = callPackage @@ -249522,28 +247802,6 @@ self: { }) {}; "structs" = callPackage - ({ mkDerivation, base, Cabal, cabal-doctest, deepseq, directory - , doctest, filepath, ghc-prim, parallel, primitive, QuickCheck - , tasty, tasty-hunit, tasty-quickcheck, template-haskell - , th-abstraction - }: - mkDerivation { - pname = "structs"; - version = "0.1.4"; - sha256 = "0sjrih706bpibd1ygfjz76gabampffwqvn0hnvmxa9b9vzwdgqzr"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - base deepseq ghc-prim primitive template-haskell th-abstraction - ]; - testHaskellDepends = [ - base directory doctest filepath parallel primitive QuickCheck tasty - tasty-hunit tasty-quickcheck - ]; - description = "Strict GC'd imperative object-oriented programming with cheap pointers"; - license = lib.licenses.bsd3; - }) {}; - - "structs_0_1_5" = callPackage ({ mkDerivation, base, deepseq, ghc-prim, primitive, QuickCheck , tasty, tasty-hunit, tasty-quickcheck, template-haskell , th-abstraction @@ -249560,7 +247818,6 @@ self: { ]; description = "Strict GC'd imperative object-oriented programming with cheap pointers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "structural-induction" = callPackage @@ -254139,19 +252396,6 @@ self: { }) {}; "tardis" = callPackage - ({ mkDerivation, base, mmorph, mtl }: - mkDerivation { - pname = "tardis"; - version = "0.4.1.0"; - sha256 = "1nd54pff1n6ds5jqa98qrby06d3ziw2rhb3j5lvw4mahsynsnwp6"; - revision = "1"; - editedCabalFile = "1wp6vp90g19hv8r2l83ava7qxf0933gb7ni2zgyfa66vlvxvhibv"; - libraryHaskellDepends = [ base mmorph mtl ]; - description = "Bidirectional state monad transformer"; - license = lib.licenses.bsd3; - }) {}; - - "tardis_0_4_3_0" = callPackage ({ mkDerivation, base, mmorph, mtl }: mkDerivation { pname = "tardis"; @@ -254161,7 +252405,6 @@ self: { testHaskellDepends = [ base ]; description = "Bidirectional state monad transformer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "target" = callPackage @@ -254527,22 +252770,6 @@ self: { }) {}; "tasty-expected-failure" = callPackage - ({ mkDerivation, base, hedgehog, tagged, tasty, tasty-golden - , tasty-hedgehog, tasty-hunit, unbounded-delays - }: - mkDerivation { - pname = "tasty-expected-failure"; - version = "0.12.2"; - sha256 = "0i97y723vi2f5z94ripli8jfzqk540w80cfab3prylbm9j3s7rb7"; - libraryHaskellDepends = [ base tagged tasty unbounded-delays ]; - testHaskellDepends = [ - base hedgehog tasty tasty-golden tasty-hedgehog tasty-hunit - ]; - description = "Mark tasty tests as failure expected"; - license = lib.licenses.mit; - }) {}; - - "tasty-expected-failure_0_12_3" = callPackage ({ mkDerivation, base, hedgehog, tagged, tasty, tasty-golden , tasty-hedgehog, tasty-hunit, unbounded-delays }: @@ -254556,7 +252783,6 @@ self: { ]; description = "Mark tasty tests as failure expected"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "tasty-fail-fast" = callPackage @@ -259670,6 +257896,18 @@ self: { license = lib.licenses.bsd3; }) {}; + "these-lens_1_0_1_2" = callPackage + ({ mkDerivation, base, lens, these }: + mkDerivation { + pname = "these-lens"; + version = "1.0.1.2"; + sha256 = "1v3kj7j4bkywbmdbblwqs5gsj5s23d59sb3s27jf3bwdzf9d21p6"; + libraryHaskellDepends = [ base lens these ]; + description = "Lenses for These"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "these-optics" = callPackage ({ mkDerivation, base, optics-core, these }: mkDerivation { @@ -259681,6 +257919,18 @@ self: { license = lib.licenses.bsd3; }) {}; + "these-optics_1_0_1_2" = callPackage + ({ mkDerivation, base, optics-core, these }: + mkDerivation { + pname = "these-optics"; + version = "1.0.1.2"; + sha256 = "06jxv320a8f94zjjsqrh072vz2dkzhwgcmpbdy1prgvypiynm4zd"; + libraryHaskellDepends = [ base optics-core these ]; + description = "Optics for These"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "these-skinny" = callPackage ({ mkDerivation, base, deepseq }: mkDerivation { @@ -260397,26 +258647,6 @@ self: { }) {}; "tidal" = callPackage - ({ mkDerivation, base, bifunctors, bytestring, clock, colour - , containers, criterion, deepseq, hosc, microspec, network, parsec - , primitive, random, text, transformers, vector, weigh - }: - mkDerivation { - pname = "tidal"; - version = "1.6.1"; - sha256 = "13n9s0s04bddl16xq86anz7a9fqcm7j3xfqn5y1mni5j1h7hn2k2"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - base bifunctors bytestring clock colour containers deepseq hosc - network parsec primitive random text transformers vector - ]; - testHaskellDepends = [ base containers deepseq microspec parsec ]; - benchmarkHaskellDepends = [ base criterion weigh ]; - description = "Pattern language for improvised music"; - license = lib.licenses.gpl3; - }) {}; - - "tidal_1_7_1" = callPackage ({ mkDerivation, base, bifunctors, bytestring, clock, colour , containers, criterion, deepseq, hosc, microspec, network, parsec , primitive, random, text, transformers, vector, weigh @@ -260436,7 +258666,6 @@ self: { benchmarkHaskellDepends = [ base criterion weigh ]; description = "Pattern language for improvised music"; license = lib.licenses.gpl3; - hydraPlatforms = lib.platforms.none; }) {}; "tidal-midi" = callPackage @@ -262070,30 +260299,6 @@ self: { }) {}; "tlynx" = callPackage - ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad - , containers, elynx-tools, elynx-tree, gnuplot, lifted-async - , monad-logger, mwc-random, optparse-applicative, parallel - , statistics, text, transformers, vector - }: - mkDerivation { - pname = "tlynx"; - version = "0.5.0.1"; - sha256 = "0prqnbq75jrixx845z3hbqajfc63vgsdfdgrsxw0g29rx0x4hw2i"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson attoparsec base bytestring comonad containers elynx-tools - elynx-tree gnuplot lifted-async monad-logger mwc-random - optparse-applicative parallel statistics text transformers vector - ]; - executableHaskellDepends = [ base ]; - description = "Handle phylogenetic trees"; - license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "tlynx_0_5_0_2" = callPackage ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad , containers, elynx-tools, elynx-tree, gnuplot, lifted-async , monad-logger, mwc-random, optparse-applicative, parallel @@ -262648,37 +260853,6 @@ self: { }) {}; "tomland" = callPackage - ({ mkDerivation, base, bytestring, containers, deepseq, directory - , hashable, hedgehog, hspec, hspec-golden, hspec-hedgehog - , hspec-megaparsec, markdown-unlit, megaparsec, mtl - , parser-combinators, text, time, transformers - , unordered-containers, validation-selective - }: - mkDerivation { - pname = "tomland"; - version = "1.3.1.0"; - sha256 = "17909a8aapbrsa0yb642ij80k64dg2dam1v3rsvc3rm07ik61x42"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base bytestring containers deepseq hashable megaparsec mtl - parser-combinators text time transformers unordered-containers - validation-selective - ]; - executableHaskellDepends = [ - base bytestring containers hashable text time unordered-containers - ]; - executableToolDepends = [ markdown-unlit ]; - testHaskellDepends = [ - base bytestring containers directory hashable hedgehog hspec - hspec-golden hspec-hedgehog hspec-megaparsec megaparsec text time - unordered-containers - ]; - description = "Bidirectional TOML serialization"; - license = lib.licenses.mpl20; - }) {}; - - "tomland_1_3_2_0" = callPackage ({ mkDerivation, base, bytestring, containers, deepseq, directory , hashable, hedgehog, hspec, hspec-golden, hspec-hedgehog , hspec-megaparsec, markdown-unlit, megaparsec, mtl @@ -262707,7 +260881,6 @@ self: { ]; description = "Bidirectional TOML serialization"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; }) {}; "tomlcheck" = callPackage @@ -264691,19 +262864,6 @@ self: { }) {}; "tree-view" = callPackage - ({ mkDerivation, base, containers, mtl }: - mkDerivation { - pname = "tree-view"; - version = "0.5"; - sha256 = "1aywcaq9b48ap04g8i5rirz447kfmwxnswqigmycbgvqdbglc01d"; - revision = "1"; - editedCabalFile = "0f4sls511c4axp92r07yk0b4h9wvlbk5345643q4gvy1adxwdyw5"; - libraryHaskellDepends = [ base containers mtl ]; - description = "Render trees as foldable HTML and Unicode art"; - license = lib.licenses.bsd3; - }) {}; - - "tree-view_0_5_1" = callPackage ({ mkDerivation, base, containers, mtl }: mkDerivation { pname = "tree-view"; @@ -264712,7 +262872,6 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Render trees as foldable HTML and Unicode art"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "treefold" = callPackage @@ -265043,33 +263202,6 @@ self: { }) {}; "trifecta" = callPackage - ({ mkDerivation, ansi-terminal, array, base, blaze-builder - , blaze-html, blaze-markup, bytestring, Cabal, cabal-doctest - , charset, comonad, containers, deepseq, doctest, fingertree - , ghc-prim, hashable, lens, mtl, parsers, prettyprinter - , prettyprinter-ansi-terminal, profunctors, QuickCheck, reducers - , semigroups, transformers, unordered-containers, utf8-string - }: - mkDerivation { - pname = "trifecta"; - version = "2.1"; - sha256 = "0fr326lzf38m20h2g4189nsyml9w3128924zbd3cd93cgfqcc9bs"; - revision = "4"; - editedCabalFile = "0frzfh7xmaypbxcmszjvzbakz52p0fx79jg6ng0ygaaj62inv4ss"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - ansi-terminal array base blaze-builder blaze-html blaze-markup - bytestring charset comonad containers deepseq fingertree ghc-prim - hashable lens mtl parsers prettyprinter prettyprinter-ansi-terminal - profunctors reducers semigroups transformers unordered-containers - utf8-string - ]; - testHaskellDepends = [ base doctest parsers QuickCheck ]; - description = "A modern parser combinator library with convenient diagnostics"; - license = lib.licenses.bsd3; - }) {}; - - "trifecta_2_1_1" = callPackage ({ mkDerivation, ansi-terminal, array, base, blaze-builder , blaze-html, blaze-markup, bytestring, charset, comonad , containers, deepseq, fingertree, ghc-prim, hashable @@ -265091,7 +263223,6 @@ self: { testHaskellDepends = [ base parsers QuickCheck ]; description = "A modern parser combinator library with convenient diagnostics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "trigger" = callPackage @@ -268321,31 +266452,6 @@ self: { }) {}; "ua-parser" = callPackage - ({ mkDerivation, aeson, base, bytestring, criterion, data-default - , deepseq, file-embed, filepath, HUnit, pcre-light, tasty - , tasty-hunit, tasty-quickcheck, text, yaml - }: - mkDerivation { - pname = "ua-parser"; - version = "0.7.5.1"; - sha256 = "091lks0jpp0m4wg56i03ih3n0n7kvs2fm511vcnypmwskflkkk0z"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - aeson base bytestring data-default file-embed pcre-light text yaml - ]; - testHaskellDepends = [ - aeson base bytestring data-default file-embed filepath HUnit - pcre-light tasty tasty-hunit tasty-quickcheck text yaml - ]; - benchmarkHaskellDepends = [ - aeson base bytestring criterion data-default deepseq file-embed - filepath pcre-light text yaml - ]; - description = "A library for parsing User-Agent strings, official Haskell port of ua-parser"; - license = lib.licenses.bsd3; - }) {}; - - "ua-parser_0_7_6_0" = callPackage ({ mkDerivation, aeson, base, bytestring, criterion, data-default , deepseq, file-embed, filepath, HUnit, pcre-light, tasty , tasty-hunit, tasty-quickcheck, text, yaml @@ -268368,7 +266474,6 @@ self: { ]; description = "A library for parsing User-Agent strings, official Haskell port of ua-parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "uacpid" = callPackage @@ -272372,33 +270477,6 @@ self: { }) {}; "uuid" = callPackage - ({ mkDerivation, base, binary, bytestring, criterion - , cryptohash-md5, cryptohash-sha1, entropy, HUnit - , mersenne-random-pure64, network-info, QuickCheck, random, tasty - , tasty-hunit, tasty-quickcheck, text, time, uuid-types - }: - mkDerivation { - pname = "uuid"; - version = "1.3.13"; - sha256 = "09xhk42yhxvqmka0iqrv3338asncz8cap3j0ic0ps896f2581b6z"; - revision = "6"; - editedCabalFile = "06w8i9hi9ha84nmj6fcj44apzv61m3ryc0a1yxxqq5n8vznk2iya"; - libraryHaskellDepends = [ - base binary bytestring cryptohash-md5 cryptohash-sha1 entropy - network-info random text time uuid-types - ]; - testHaskellDepends = [ - base bytestring HUnit QuickCheck random tasty tasty-hunit - tasty-quickcheck - ]; - benchmarkHaskellDepends = [ - base criterion mersenne-random-pure64 random - ]; - description = "For creating, comparing, parsing and printing Universally Unique Identifiers"; - license = lib.licenses.bsd3; - }) {}; - - "uuid_1_3_14" = callPackage ({ mkDerivation, base, binary, bytestring, cryptohash-md5 , cryptohash-sha1, entropy, network-info, QuickCheck, random, tasty , tasty-hunit, tasty-quickcheck, text, time, uuid-types @@ -272417,7 +270495,6 @@ self: { ]; description = "For creating, comparing, parsing and printing Universally Unique Identifiers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "uuid-aeson" = callPackage @@ -272515,30 +270592,6 @@ self: { }) {}; "uuid-types" = callPackage - ({ mkDerivation, base, binary, bytestring, containers, criterion - , deepseq, hashable, HUnit, QuickCheck, random, tasty, tasty-hunit - , tasty-quickcheck, text - }: - mkDerivation { - pname = "uuid-types"; - version = "1.0.3"; - sha256 = "1zdka5jnm1h6k36w3nr647yf3b5lqb336g3fkprhd6san9x52xlj"; - revision = "4"; - editedCabalFile = "0ipwfd5y8021ygpadjjhchw5irm0x27dlv1k2hf4znza5v7hadcn"; - libraryHaskellDepends = [ - base binary bytestring deepseq hashable random text - ]; - testHaskellDepends = [ - base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck - ]; - benchmarkHaskellDepends = [ - base bytestring containers criterion deepseq random - ]; - description = "Type definitions for Universally Unique Identifiers"; - license = lib.licenses.bsd3; - }) {}; - - "uuid-types_1_0_4" = callPackage ({ mkDerivation, base, binary, bytestring, deepseq, ghc-byteorder , hashable, QuickCheck, random, tasty, tasty-hunit , tasty-quickcheck, text @@ -272556,7 +270609,6 @@ self: { ]; description = "Type definitions for Universally Unique Identifiers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "uulib" = callPackage @@ -272576,8 +270628,8 @@ self: { }: mkDerivation { pname = "uusi"; - version = "0.3.1.0"; - sha256 = "14n2n62lcaxfljxxdk6pw14liksfa77jj8zby5magdnsx2jzkb5i"; + version = "0.4.0.0"; + sha256 = "03spazp0lpd2impvg9i6fdd32v3fzycgqr95ry2jwvaxijqhfic9"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base Cabal microlens microlens-th text ]; @@ -272587,7 +270639,7 @@ self: { testHaskellDepends = [ base Cabal HUnit microlens microlens-th text ]; - description = "Tweak dependencies in .cabal files"; + description = "Tweak .cabal files"; license = lib.licenses.mit; }) {}; @@ -273313,21 +271365,6 @@ self: { }) {}; "vault" = callPackage - ({ mkDerivation, base, containers, hashable, semigroups - , unordered-containers - }: - mkDerivation { - pname = "vault"; - version = "0.3.1.4"; - sha256 = "0na31n56p6713az0vfhdrv53n03bb3yrnyszf3vxsjlgvrax472v"; - libraryHaskellDepends = [ - base containers hashable semigroups unordered-containers - ]; - description = "a persistent store for values of arbitrary types"; - license = lib.licenses.bsd3; - }) {}; - - "vault_0_3_1_5" = callPackage ({ mkDerivation, base, containers, hashable, unordered-containers }: mkDerivation { @@ -273339,7 +271376,6 @@ self: { ]; description = "a persistent store for values of arbitrary types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "vault-tool" = callPackage @@ -274207,20 +272243,6 @@ self: { }) {}; "vector-th-unbox" = callPackage - ({ mkDerivation, base, data-default, template-haskell, vector }: - mkDerivation { - pname = "vector-th-unbox"; - version = "0.2.1.7"; - sha256 = "0q8dqnbv1c2gi7jjdhqj14abj1vik23ki6lq4iz2sz18yc7q69fi"; - revision = "1"; - editedCabalFile = "11qhhir9cdy3x7pd0z0xk8vi4nzr9fn9q3ggwbhhc43jglngw1x7"; - libraryHaskellDepends = [ base template-haskell vector ]; - testHaskellDepends = [ base data-default vector ]; - description = "Deriver for Data.Vector.Unboxed using Template Haskell"; - license = lib.licenses.bsd3; - }) {}; - - "vector-th-unbox_0_2_1_9" = callPackage ({ mkDerivation, base, data-default, template-haskell, vector }: mkDerivation { pname = "vector-th-unbox"; @@ -274230,7 +272252,6 @@ self: { testHaskellDepends = [ base data-default vector ]; description = "Deriver for Data.Vector.Unboxed using Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "vectortiles" = callPackage @@ -274508,26 +272529,6 @@ self: { }) {}; "versions" = callPackage - ({ mkDerivation, base, deepseq, hashable, megaparsec, microlens - , parser-combinators, QuickCheck, tasty, tasty-hunit - , tasty-quickcheck, text - }: - mkDerivation { - pname = "versions"; - version = "4.0.2"; - sha256 = "1m7nyjqd0cyxnli5f7rbk1wrh6h7dk65i67k6xp787npf7hi6gdf"; - libraryHaskellDepends = [ - base deepseq hashable megaparsec parser-combinators text - ]; - testHaskellDepends = [ - base megaparsec microlens QuickCheck tasty tasty-hunit - tasty-quickcheck text - ]; - description = "Types and parsers for software version numbers"; - license = lib.licenses.bsd3; - }) {}; - - "versions_4_0_3" = callPackage ({ mkDerivation, base, deepseq, hashable, megaparsec, microlens , parser-combinators, QuickCheck, tasty, tasty-hunit , tasty-quickcheck, text @@ -274545,7 +272546,6 @@ self: { ]; description = "Types and parsers for software version numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "vflow-types" = callPackage @@ -275549,41 +273549,6 @@ self: { }) {inherit (pkgs) vte;}; "vty" = callPackage - ({ mkDerivation, ansi-terminal, base, binary, blaze-builder - , bytestring, Cabal, containers, deepseq, directory, filepath - , hashable, HUnit, microlens, microlens-mtl, microlens-th, mtl - , parallel, parsec, QuickCheck, quickcheck-assertions, random - , smallcheck, stm, string-qq, terminfo, test-framework - , test-framework-hunit, test-framework-smallcheck, text - , transformers, unix, utf8-string, vector - }: - mkDerivation { - pname = "vty"; - version = "5.32"; - sha256 = "0ydbifik7xilb33phglpjkgf6r8vifipyyq0wb6111azzj7dmszs"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - ansi-terminal base binary blaze-builder bytestring containers - deepseq directory filepath hashable microlens microlens-mtl - microlens-th mtl parallel parsec stm terminfo text transformers - unix utf8-string vector - ]; - executableHaskellDepends = [ - base containers directory filepath microlens microlens-mtl mtl - ]; - testHaskellDepends = [ - base blaze-builder bytestring Cabal containers deepseq HUnit - microlens microlens-mtl mtl QuickCheck quickcheck-assertions random - smallcheck stm string-qq terminfo test-framework - test-framework-hunit test-framework-smallcheck text unix - utf8-string vector - ]; - description = "A simple terminal UI library"; - license = lib.licenses.bsd3; - }) {}; - - "vty_5_33" = callPackage ({ mkDerivation, ansi-terminal, base, binary, blaze-builder , bytestring, Cabal, containers, deepseq, directory, filepath , hashable, HUnit, microlens, microlens-mtl, microlens-th, mtl @@ -275618,7 +273583,6 @@ self: { ]; description = "A simple terminal UI library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "vty-examples" = callPackage @@ -280288,30 +278252,6 @@ self: { }) {}; "with-utf8" = callPackage - ({ mkDerivation, base, deepseq, directory, filepath, hedgehog - , HUnit, process, safe-exceptions, tasty, tasty-discover - , tasty-hedgehog, tasty-hunit, temporary, text, th-env, unix - }: - mkDerivation { - pname = "with-utf8"; - version = "1.0.2.1"; - sha256 = "13zifhmhpdfwifw9bwyn9w5a29iph7h59jx13r0wiw5ry0g7qbif"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base safe-exceptions text ]; - executableHaskellDepends = [ - base directory filepath process safe-exceptions text th-env - ]; - testHaskellDepends = [ - base deepseq hedgehog HUnit safe-exceptions tasty tasty-hedgehog - tasty-hunit temporary text unix - ]; - testToolDepends = [ tasty-discover ]; - description = "Get your IO right on the first try"; - license = lib.licenses.mpl20; - }) {}; - - "with-utf8_1_0_2_2" = callPackage ({ mkDerivation, base, deepseq, directory, filepath, hedgehog , HUnit, process, safe-exceptions, tasty, tasty-discover , tasty-hedgehog, tasty-hunit, temporary, text, th-env, unix @@ -280333,7 +278273,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Get your IO right on the first try"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; }) {}; "withdependencies" = callPackage @@ -287266,6 +285205,32 @@ self: { broken = true; }) {}; + "yesod-page-cursor_2_0_0_4" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, hspec + , hspec-expectations-lifted, http-link-header, http-types, lens + , lens-aeson, monad-logger, mtl, network-uri, persistent + , persistent-sqlite, persistent-template, scientific, text, time + , unliftio, unliftio-core, wai-extra, yesod, yesod-core, yesod-test + }: + mkDerivation { + pname = "yesod-page-cursor"; + version = "2.0.0.4"; + sha256 = "1zckyjg3k8xi6lx1xgyh50d6v7hydv12c1j36w48xy296nsjwvv9"; + libraryHaskellDepends = [ + aeson base bytestring containers http-link-header network-uri text + unliftio yesod-core + ]; + testHaskellDepends = [ + aeson base bytestring hspec hspec-expectations-lifted + http-link-header http-types lens lens-aeson monad-logger mtl + persistent persistent-sqlite persistent-template scientific text + time unliftio unliftio-core wai-extra yesod yesod-core yesod-test + ]; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "yesod-paginate" = callPackage ({ mkDerivation, base, template-haskell, yesod }: mkDerivation { @@ -289983,26 +287948,6 @@ self: { }) {}; "zippers" = callPackage - ({ mkDerivation, base, Cabal, cabal-doctest, criterion, doctest - , fail, lens, profunctors, semigroupoids, semigroups - }: - mkDerivation { - pname = "zippers"; - version = "0.3"; - sha256 = "0hrsgk8sh9g3438kl79131s6vjydhivgya04yxv3h70m7pky1dpm"; - revision = "2"; - editedCabalFile = "131rmvifqf3dcvh9lnpjnm28ss7nzra1n2qnxa1fypnx1zmmljva"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - base fail lens profunctors semigroupoids semigroups - ]; - testHaskellDepends = [ base doctest ]; - benchmarkHaskellDepends = [ base criterion lens ]; - description = "Traversal based zippers"; - license = lib.licenses.bsd3; - }) {}; - - "zippers_0_3_1" = callPackage ({ mkDerivation, base, criterion, fail, indexed-traversable, lens , profunctors, semigroupoids, semigroups }: @@ -290017,7 +287962,6 @@ self: { benchmarkHaskellDepends = [ base criterion lens ]; description = "Traversal based zippers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "zippo" = callPackage @@ -290078,23 +288022,6 @@ self: { }) {}; "zlib" = callPackage - ({ mkDerivation, base, bytestring, QuickCheck, tasty, tasty-hunit - , tasty-quickcheck, zlib - }: - mkDerivation { - pname = "zlib"; - version = "0.6.2.2"; - sha256 = "1fii0qfc60lfp93vwb78p2fv3jjyklgdhw4ms262z6cysq6qkd84"; - libraryHaskellDepends = [ base bytestring ]; - librarySystemDepends = [ zlib ]; - testHaskellDepends = [ - base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck - ]; - description = "Compression and decompression in the gzip and zlib formats"; - license = lib.licenses.bsd3; - }) {inherit (pkgs) zlib;}; - - "zlib_0_6_2_3" = callPackage ({ mkDerivation, base, bytestring, QuickCheck, tasty, tasty-hunit , tasty-quickcheck, zlib }: @@ -290109,7 +288036,6 @@ self: { ]; description = "Compression and decompression in the gzip and zlib formats"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) zlib;}; "zlib-bindings" = callPackage From 62dbe409768bd0e5d051bf7e3a7a1365f43d0835 Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Fri, 26 Feb 2021 00:13:30 +0100 Subject: [PATCH 33/70] haskellPackages: fix eval after advancing to hnix-store-core 0.4.1.0 We don't need to pin the package version from hackage anywhere anymore since stackage-nightly has arrived at the version we want. The tasty-discover override is still necessary, but can be applied to the plain hnix-store-core attribute. Since the hnix-store-core_0_4_1_0 attribute no longer exists a few intermittent eval errors where caused by the package set regeneration. --- .../haskell-modules/configuration-common.nix | 20 ++----------------- 1 file changed, 2 insertions(+), 18 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 372d0c8e5c3..bfde29e33cd 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -217,26 +217,10 @@ self: super: { # building of the executable has been disabled for ghc < 8.10 in hnix. # Generating the completions should be activated again, once we default to # ghc 8.10. - hnix = dontCheck (super.hnix.override { - - # 2021-01-07: NOTE: hnix-store-core pinned at ==0.2 in Stackage Nightly. - # https://github.com/haskell-nix/hnix-store/issues/104 - # Until unpin, which may hold off in time due to Stackage maintenence bottleneck - # the 0_4_0_0 is used - hnix-store-core = self.hnix-store-core_0_4_1_0; # at least 1.7 - - }); - - # 2021-01-07: NOTE: hnix-store-core pinned at ==0.2 in Stackage Nightly. - # https://github.com/haskell-nix/hnix-store/issues/104 - # Until unpin, which may hold off in time due to Stackage maintenence bottleneck - # the 0_4_0_0 is used - hnix-store-remote = (super.hnix-store-remote.override { - hnix-store-core = self.hnix-store-core_0_4_1_0; # at least 1.7 - }); + hnix = dontCheck super.hnix; # https://github.com/haskell-nix/hnix-store/issues/127 - hnix-store-core_0_4_1_0 = addTestToolDepend super.hnix-store-core_0_4_1_0 self.tasty-discover; + hnix-store-core = addTestToolDepend super.hnix-store-core self.tasty-discover; # Fails for non-obvious reasons while attempting to use doctest. search = dontCheck super.search; From 474dbcb767a3e62cbfded428b294e99c9da96de9 Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Fri, 26 Feb 2021 00:24:32 +0100 Subject: [PATCH 34/70] haskellPackages.essence-of-live-coding-warp: bump http-client http-client had a new release on hackage, so the http-client_0_7_5 attribute no longer exists, we replace it by http-client_0_7_6. --- pkgs/development/haskell-modules/configuration-common.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index bfde29e33cd..8ab7e06af2e 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1534,7 +1534,7 @@ self: super: { # 2020-12-05: http-client is fixed on too old version essence-of-live-coding-warp = super.essence-of-live-coding-warp.override { - http-client = self.http-client_0_7_5; + http-client = self.http-client_0_7_6; }; # 2020-12-06: Restrictive upper bounds w.r.t. pandoc-types (https://github.com/owickstrom/pandoc-include-code/issues/27) From 77fe5ae244044424c6eeb8a8441ca24d046487d7 Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Fri, 26 Feb 2021 00:30:22 +0100 Subject: [PATCH 35/70] haskellPackages.hnix: generate completions again As stated in the original comment, since we have moved to GHC 8.10.x, the hnix binary builds again and we can generate completions for it. --- pkgs/development/haskell-modules/configuration-common.nix | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 8ab7e06af2e..433060b4405 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -212,12 +212,8 @@ self: super: { # base bound digit = doJailbreak super.digit; - # 2020-06-05: HACK: does not pass own build suite - `dontCheck` We should - # generate optparse-applicative completions for the hnix executable. Sadly - # building of the executable has been disabled for ghc < 8.10 in hnix. - # Generating the completions should be activated again, once we default to - # ghc 8.10. - hnix = dontCheck super.hnix; + # 2020-06-05: HACK: does not pass own build suite - `dontCheck` + hnix = generateOptparseApplicativeCompletion "hnix" (dontCheck super.hnix); # https://github.com/haskell-nix/hnix-store/issues/127 hnix-store-core = addTestToolDepend super.hnix-store-core self.tasty-discover; From 1e36eafdf340498f7171ef431d56262d00087f1f Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 02:30:23 +0100 Subject: [PATCH 36/70] hackage-packages.nix: automatic Haskell package set update This update was generated by hackage2nix v2.16.0-13-gefcfbb2 from Hackage revision https://github.com/commercialhaskell/all-cabal-hashes/commit/a9870d227521bef7aa1df56ff5e31226bfc08fbb. --- .../haskell-modules/hackage-packages.nix | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 6bb71aaf63c..b5ec750478a 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -258668,6 +258668,29 @@ self: { license = lib.licenses.gpl3; }) {}; + "tidal_1_7_2" = callPackage + ({ mkDerivation, base, bifunctors, bytestring, clock, colour + , containers, criterion, deepseq, hosc, microspec, network, parsec + , primitive, random, text, transformers, vector, weigh + }: + mkDerivation { + pname = "tidal"; + version = "1.7.2"; + sha256 = "15shxaazxik1bawgak16xhlvk708kv9al6i3518b3m3iap9sbw9p"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bifunctors bytestring clock colour containers deepseq hosc + network parsec primitive random text transformers vector + ]; + testHaskellDepends = [ + base containers deepseq hosc microspec parsec + ]; + benchmarkHaskellDepends = [ base criterion weigh ]; + description = "Pattern language for improvised music"; + license = lib.licenses.gpl3; + hydraPlatforms = lib.platforms.none; + }) {}; + "tidal-midi" = callPackage ({ mkDerivation, base, containers, PortMidi, tidal, time , transformers From 1cdbaf46c0f7cfb64405508834737ec49208da3e Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Thu, 25 Feb 2021 23:28:33 +0100 Subject: [PATCH 37/70] haskellPackages.yarn2nix: unbreak build * fix compilation error concerning protolude 0.3 by applying patch * remove dependency on regex-tdfa-text which has been merged into regex-tdfa --- .../haskell-modules/configuration-common.nix | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 433060b4405..f5a653ec637 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1589,4 +1589,26 @@ self: super: { # Overly strict version bounds: https://github.com/Profpatsch/yarn-lock/issues/8 yarn-lock = doJailbreak super.yarn-lock; + + # Dependency to regex-tdfa-text can be removed for later regex-tdfa versions. + # Fix protolude compilation error by applying patch from pull-request. + # Override can be removed for the next release > 0.8.0. + yarn2nix = overrideCabal (super.yarn2nix.override { + regex-tdfa-text = null; + }) (attrs: { + jailbreak = true; + # remove dependency on regex-tdfa-text + # which has been merged into regex-tdfa + postPatch = '' + sed -i '/regex-tdfa-text/d' yarn2nix.cabal + ''; + patches = (attrs.patches or []) ++ [ + # fix a compilation error related to protolude 0.3 + (pkgs.fetchpatch { + url = "https://github.com/Profpatsch/yarn2nix/commit/ca78cf06226819b2e78cb6cdbc157d27afb41532.patch"; + sha256 = "1vkczwzhxilnp87apyb18nycn834y5nbw4yr1kpwlwhrhalvzw61"; + includes = [ "*/ResolveLockfile.hs" ]; + }) + ]; + }); } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super From d4acd16abc9811c17b770754e668a3ec723871ec Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Fri, 26 Feb 2021 09:13:47 +0100 Subject: [PATCH 38/70] python3Packages.prawcore: 1.5.0 -> 2.0.0 --- pkgs/development/python-modules/prawcore/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/python-modules/prawcore/default.nix b/pkgs/development/python-modules/prawcore/default.nix index 2b6eff885f9..1e38f401a43 100644 --- a/pkgs/development/python-modules/prawcore/default.nix +++ b/pkgs/development/python-modules/prawcore/default.nix @@ -6,12 +6,12 @@ buildPythonPackage rec { pname = "prawcore"; - version = "1.5.0"; + version = "2.0.0"; disabled = isPy27; # see https://github.com/praw-dev/prawcore/pull/101 src = fetchPypi { inherit pname version; - sha256 = "1f1eafc8a65d671f9892354f73142014fbb5d3a9ee621568c662d0a354e0578b"; + sha256 = "sha256-tJjZtvVJkQBecn1SNcj0nqW6DJpteT+3Q7QPoInNNtE="; }; propagatedBuildInputs = [ From 287ef70bb3bcd2d285f87a3f360c7c9856d42e5d Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Fri, 26 Feb 2021 09:14:09 +0100 Subject: [PATCH 39/70] python3Packages.praw: 7.1.4 -> 7.2.0 --- pkgs/development/python-modules/praw/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/python-modules/praw/default.nix b/pkgs/development/python-modules/praw/default.nix index 5ca1d3d83c9..5047c1e88b0 100644 --- a/pkgs/development/python-modules/praw/default.nix +++ b/pkgs/development/python-modules/praw/default.nix @@ -14,13 +14,13 @@ buildPythonPackage rec { pname = "praw"; - version = "7.1.4"; + version = "7.2.0"; src = fetchFromGitHub { owner = "praw-dev"; repo = pname; rev = "v${version}"; - sha256 = "sha256-onxag3kmswqqSycbwW+orofrukry0pCaRSxVRq2u53A="; + sha256 = "sha256-/GV5ZhrJxeChcYwmH/9FsLceAYRSeTCDe4lMEwdTa8Y="; }; propagatedBuildInputs = [ From 596bcdaf93a0441d3f777b49b82f304411d5fc33 Mon Sep 17 00:00:00 2001 From: Markus Hauck Date: Fri, 26 Feb 2021 10:31:36 +0100 Subject: [PATCH 40/70] anki-bin: 2.1.38 -> 2.1.40 --- pkgs/games/anki/bin.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/games/anki/bin.nix b/pkgs/games/anki/bin.nix index 5509d8a90ca..f5677b142e2 100644 --- a/pkgs/games/anki/bin.nix +++ b/pkgs/games/anki/bin.nix @@ -3,14 +3,14 @@ let pname = "anki-bin"; # Update hashes for both Linux and Darwin! - version = "2.1.38"; + version = "2.1.40"; unpacked = stdenv.mkDerivation { inherit pname version; src = fetchurl { url = "https://github.com/ankitects/anki/releases/download/${version}/anki-${version}-linux.tar.bz2"; - sha256 = "14zbz8k142djka3b5sld3368m98lj80c39m6xg87bz140h25ylz4"; + sha256 = "0zcvjm0dv3mjln2npv415yfaa1fykif738qkis52x3pq1by2aiam"; }; installPhase = '' @@ -49,7 +49,7 @@ if stdenv.isLinux then buildFHSUserEnv (appimageTools.defaultFhsEnvArgs // { src = fetchurl { url = "https://github.com/ankitects/anki/releases/download/${version}/anki-${version}-mac.dmg"; - sha256 = "1krl014jhhby0zv4if9cgbcarmhcg6zccyhxw1yb6djiqap0zii7"; + sha256 = "14f0sp9h963qix4wa0kg7z8a2nhch9aybv736rm55aqk6mady6vi"; }; nativeBuildInputs = [ undmg ]; From 3389b87674917f4a5b69e34f013da887b45c0e07 Mon Sep 17 00:00:00 2001 From: Martin Weinelt Date: Fri, 26 Feb 2021 12:57:37 +0100 Subject: [PATCH 41/70] salt: 3002.2 -> 3002.5 https://saltproject.io/security_announcements/active-saltstack-cve-release-2021-feb-25/ Fixes: CVE-2021-3197, CVE-2021-25281, CVE-2021-25282, CVE-2021-25283, CVE-2021-25284, CVE-2021-3148, CVE-2020-35662, CVE-2021-3144, CVE-2020-28972, CVE-2020-28243 --- pkgs/tools/admin/salt/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/tools/admin/salt/default.nix b/pkgs/tools/admin/salt/default.nix index ad0cae6ecde..592f4cc7648 100644 --- a/pkgs/tools/admin/salt/default.nix +++ b/pkgs/tools/admin/salt/default.nix @@ -7,11 +7,11 @@ }: python3.pkgs.buildPythonApplication rec { pname = "salt"; - version = "3002.2"; + version = "3002.5"; src = python3.pkgs.fetchPypi { inherit pname version; - sha256 = "vW0pYhzo4JlBJ3fNOWrzVHSqESuwmZtdqAQ4fYcpAHU="; + sha256 = "1bqranhanxcxjc1qcc6cm95f4xxag0ic9g61dq352hqh6m1l1ay8"; }; propagatedBuildInputs = with python3.pkgs; [ From ed0a29c88dfe32f3121474ce5cad7df02e28c2cc Mon Sep 17 00:00:00 2001 From: rnhmjoj Date: Fri, 26 Feb 2021 13:06:18 +0100 Subject: [PATCH 42/70] nixos/test/ksm: add simple test --- nixos/tests/all-tests.nix | 1 + nixos/tests/ksm.nix | 22 ++++++++++++++++++++++ 2 files changed, 23 insertions(+) create mode 100644 nixos/tests/ksm.nix diff --git a/nixos/tests/all-tests.nix b/nixos/tests/all-tests.nix index bf094dbe984..625eb54403d 100644 --- a/nixos/tests/all-tests.nix +++ b/nixos/tests/all-tests.nix @@ -195,6 +195,7 @@ in keymap = handleTest ./keymap.nix {}; knot = handleTest ./knot.nix {}; krb5 = discoverTests (import ./krb5 {}); + ksm = handleTest ./ksm.nix {}; kubernetes.dns = handleTestOn ["x86_64-linux"] ./kubernetes/dns.nix {}; # kubernetes.e2e should eventually replace kubernetes.rbac when it works #kubernetes.e2e = handleTestOn ["x86_64-linux"] ./kubernetes/e2e.nix {}; diff --git a/nixos/tests/ksm.nix b/nixos/tests/ksm.nix new file mode 100644 index 00000000000..8feccbe6df5 --- /dev/null +++ b/nixos/tests/ksm.nix @@ -0,0 +1,22 @@ +import ./make-test-python.nix ({ pkgs, ...} : + +{ + name = "ksm"; + meta = with pkgs.lib.maintainers; { + maintainers = [ rnhmjoj ]; + }; + + machine = { ... }: { + imports = [ ../modules/profiles/minimal.nix ]; + + hardware.ksm.enable = true; + hardware.ksm.sleep = 300; + }; + + testScript = + '' + machine.start() + machine.wait_until_succeeds("test $( Date: Fri, 26 Feb 2021 14:18:22 +0100 Subject: [PATCH 43/70] haskellPackages.haskell-language-server: Fix build --- .../haskell-modules/configuration-common.nix | 14 +++++--------- .../haskell-modules/configuration-hackage2nix.yaml | 4 +--- 2 files changed, 6 insertions(+), 12 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index f5a653ec637..241312cd911 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1406,16 +1406,12 @@ self: super: { # 2020-11-19: Checks nearly fixed, but still disabled because of flaky tests: # https://github.com/haskell/haskell-language-server/issues/610 # https://github.com/haskell/haskell-language-server/issues/611 - haskell-language-server = overrideCabal (dontCheck super.haskell-language-server) { - # 2020-02-19: Override is necessary because of wrong bound on upstream, remove after next hackage update - preConfigure = '' - substituteInPlace haskell-language-server.cabal --replace "hls-explicit-imports-plugin ==0.1.0.1" "hls-explicit-imports-plugin ==0.1.0.0" - ''; - }; + haskell-language-server = dontCheck super.haskell-language-server; + + # 2020-02-26: Outdated upperbound on ghc-exactprint + # https://github.com/lspitzner/brittany/issues/342 + brittany = doJailbreak super.brittany; - # 2021-02-08: Jailbreaking because of - # https://github.com/haskell/haskell-language-server/issues/1329 - hls-tactics-plugin = doJailbreak super.hls-tactics-plugin; # 2021-02-11: Jailbreaking because of syntax error on bound revision hls-explicit-imports-plugin = doJailbreak super.hls-explicit-imports-plugin; diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml index dccc462acd1..3a47b2869bf 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml @@ -2800,14 +2800,12 @@ package-maintainers: - nix-diff maralorn: - reflex-dom - - ghcide - cabal-fmt - shh - - brittany - - hlint - neuron - releaser - taskwarrior + - haskell-language-server sorki: - cayene-lpp - data-stm32 From 1444504e4bcb3adb6b1c6db469469e7801fde1fe Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Fri, 26 Feb 2021 14:54:28 +0100 Subject: [PATCH 44/70] haskellPackages.cabal-install: Fix build for 3.4.0.0 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We can‘t use overrideScope with random because that would touch a lot of tests and cause build failures. So I try to do the overrides manually. --- .../configuration-ghc-8.10.x.nix | 21 +++++++------------ 1 file changed, 7 insertions(+), 14 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix b/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix index 60d3f423246..5e39a8047bd 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix @@ -42,20 +42,13 @@ self: super: { unix = null; xhtml = null; - # The proper 3.2.0.0 release does not compile with ghc-8.10.1, so we take the - # hitherto unreleased next version from the '3.2' branch of the upstream git - # repository for the time being. - cabal-install = assert super.cabal-install.version == "3.2.0.0"; - overrideCabal super.cabal-install (drv: { - postUnpack = "sourceRoot+=/cabal-install; echo source root reset to $sourceRoot"; - version = "3.2.0.0-git"; - editedCabalFile = null; - src = pkgs.fetchgit { - url = "git://github.com/haskell/cabal.git"; - rev = "9bd4cc0591616aeae78e17167338371a2542a475"; - sha256 = "005q1shh7vqgykkp72hhmswmrfpz761x0q0jqfnl3wqim4xd9dg0"; - }; - }); + cabal-install = super.cabal-install.override { + Cabal = super.Cabal_3_4_0_0; + hackage-security = super.hackage-security.override { Cabal = super.Cabal_3_4_0_0; }; + # Usung dontCheck to break test dependency cycles + edit-distance = dontCheck (super.edit-distance.override { random = super.random_1_2_0; }); + random = super.random_1_2_0; + }; # Jailbreak to fix the build. base-noprelude = doJailbreak super.base-noprelude; From 19fca6f48324a6830f72bde513ce976ef49c2025 Mon Sep 17 00:00:00 2001 From: Thiago Kenji Okada Date: Fri, 26 Feb 2021 11:07:10 -0300 Subject: [PATCH 45/70] babashka: sync native-image arguments with upstream This commit syncs the arguments passed to the babashka with upstream: https://github.com/babashka/babashka/blob/77daea7362d8e2562c89c315b1fbcefde6fa56a5/script/compile#L41-L74 The idea here is to enable more features and reduce the number of issues compared to upstream. Also add some tests to ensure everything is working. --- .../interpreters/clojure/babashka.nix | 79 +++++++++++++------ 1 file changed, 57 insertions(+), 22 deletions(-) diff --git a/pkgs/development/interpreters/clojure/babashka.nix b/pkgs/development/interpreters/clojure/babashka.nix index 774e83311b1..43b8fb4c6c4 100644 --- a/pkgs/development/interpreters/clojure/babashka.nix +++ b/pkgs/development/interpreters/clojure/babashka.nix @@ -17,36 +17,71 @@ stdenv.mkDerivation rec { dontUnpack = true; - LC_ALL = "en_US.UTF-8"; nativeBuildInputs = [ graalvm11-ce glibcLocales ]; + LC_ALL = "en_US.UTF-8"; + BABASHKA_JAR = src; + BABASHKA_BINARY = "bb"; + BABASHKA_XMX = "-J-Xmx4500m"; + buildPhase = '' - native-image \ - -jar ${src} \ - -H:Name=bb \ - ${lib.optionalString stdenv.isDarwin ''-H:-CheckToolchain''} \ - -H:+ReportExceptionStackTraces \ - -J-Dclojure.spec.skip-macros=true \ - -J-Dclojure.compiler.direct-linking=true \ - "-H:IncludeResources=BABASHKA_VERSION" \ - "-H:IncludeResources=SCI_VERSION" \ - -H:ReflectionConfigurationFiles=${reflectionJson} \ - --initialize-at-build-time \ - -H:Log=registerResource: \ - -H:EnableURLProtocols=http,https \ - --enable-all-security-services \ - -H:+JNI \ - --verbose \ - --no-fallback \ - --no-server \ - --report-unsupported-elements-at-runtime \ - "--initialize-at-run-time=org.postgresql.sspi.SSPIClient" \ - "-J-Xmx4500m" + runHook preBuild + + # https://github.com/babashka/babashka/blob/77daea7362d8e2562c89c315b1fbcefde6fa56a5/script/compile + args=("-jar" "$BABASHKA_JAR" + "-H:Name=$BABASHKA_BINARY" + "${lib.optionalString stdenv.isDarwin ''-H:-CheckToolchain''}" + "-H:+ReportExceptionStackTraces" + "-J-Dclojure.spec.skip-macros=true" + "-J-Dclojure.compiler.direct-linking=true" + "-H:IncludeResources=BABASHKA_VERSION" + "-H:IncludeResources=SCI_VERSION" + "-H:ReflectionConfigurationFiles=${reflectionJson}" + "--initialize-at-build-time" + # "-H:+PrintAnalysisCallTree" + # "-H:+DashboardAll" + # "-H:DashboardDump=reports/dump" + # "-H:+DashboardPretty" + # "-H:+DashboardJson" + "-H:Log=registerResource:" + "-H:EnableURLProtocols=http,https,jar" + "--enable-all-security-services" + "-H:+JNI" + "--verbose" + "--no-fallback" + "--no-server" + "--report-unsupported-elements-at-runtime" + "--initialize-at-run-time=org.postgresql.sspi.SSPIClient" + "--native-image-info" + "--verbose" + "-H:ServiceLoaderFeatureExcludeServices=javax.sound.sampled.spi.AudioFileReader" + "-H:ServiceLoaderFeatureExcludeServices=javax.sound.midi.spi.MidiFileReader" + "-H:ServiceLoaderFeatureExcludeServices=javax.sound.sampled.spi.MixerProvider" + "-H:ServiceLoaderFeatureExcludeServices=javax.sound.sampled.spi.FormatConversionProvider" + "-H:ServiceLoaderFeatureExcludeServices=javax.sound.sampled.spi.AudioFileWriter" + "-H:ServiceLoaderFeatureExcludeServices=javax.sound.midi.spi.MidiDeviceProvider" + "-H:ServiceLoaderFeatureExcludeServices=javax.sound.midi.spi.SoundbankReader" + "-H:ServiceLoaderFeatureExcludeServices=javax.sound.midi.spi.MidiFileWriter" + "$BABASHKA_XMX") + + native-image ''${args[@]} + + runHook postBuild ''; installPhase = '' + runHook preInstall + mkdir -p $out/bin cp bb $out/bin/bb + + runHook postInstall + ''; + + installCheckPhase = '' + $out/bin/bb --version | grep '${version}' + $out/bin/bb '(+ 1 2)' | grep '3' + $out/bin/bb '(vec (dedupe *input*))' <<< '[1 1 1 1 2]' | grep '[1 2]' ''; meta = with lib; { From 455cb9f91384bc6f2b26342e6f1ada7dcdcb5a54 Mon Sep 17 00:00:00 2001 From: sohalt Date: Fri, 22 Jan 2021 17:48:57 +0100 Subject: [PATCH 46/70] FreeCAD: add spacenav support --- pkgs/applications/graphics/freecad/default.nix | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/pkgs/applications/graphics/freecad/default.nix b/pkgs/applications/graphics/freecad/default.nix index 1c4f05b42da..57d1f794d0f 100644 --- a/pkgs/applications/graphics/freecad/default.nix +++ b/pkgs/applications/graphics/freecad/default.nix @@ -1,9 +1,8 @@ { lib, mkDerivation, fetchFromGitHub, fetchpatch, cmake, ninja, coin3d, xercesc, ode, eigen, qtbase, qttools, qtwebengine, qtxmlpatterns, wrapQtAppsHook, opencascade-occt, gts, hdf5, vtk, medfile, zlib, python3Packages, swig, -gfortran, libXmu, soqt, libf2c, libGLU, makeWrapper, pkg-config, mpi ? null }: - -assert mpi != null; +gfortran, libXmu, soqt, libf2c, libGLU, makeWrapper, pkg-config, mpi, +spaceNavSupport ? true, libspnav, qtx11extras }: let pythonPackages = python3Packages; @@ -34,7 +33,7 @@ in mkDerivation rec { matplotlib pycollada shiboken2 pyside2 pyside2-tools pivy python boost GitPython # for addon manager scipy pyyaml # (at least for) PyrateWorkbench - ]); + ]) ++ lib.optionals spaceNavSupport [ libspnav qtx11extras ]; cmakeFlags = [ "-DBUILD_QT5=ON" From 5f1345a30318cf9559e58576dff8c5d3e4d77a62 Mon Sep 17 00:00:00 2001 From: Patryk Wychowaniec Date: Fri, 26 Feb 2021 16:03:49 +0100 Subject: [PATCH 47/70] nixos/containers: styling improvements --- nixos/tests/containers-bridge.nix | 8 +++----- nixos/tests/containers-custom-pkgs.nix | 6 +++--- nixos/tests/containers-ephemeral.nix | 7 ++++--- nixos/tests/containers-extra_veth.nix | 8 +++----- nixos/tests/containers-hosts.nix | 8 +++----- nixos/tests/containers-imperative.nix | 8 +++----- nixos/tests/containers-ip.nix | 8 +++----- nixos/tests/containers-macvlans.nix | 8 +++----- nixos/tests/containers-physical_interfaces.nix | 7 +++---- nixos/tests/containers-portforward.nix | 8 +++----- nixos/tests/containers-reloadable.nix | 7 +++---- nixos/tests/containers-restart_networking.nix | 8 +++----- nixos/tests/containers-tmpfs.nix | 8 +++----- 13 files changed, 40 insertions(+), 59 deletions(-) diff --git a/nixos/tests/containers-bridge.nix b/nixos/tests/containers-bridge.nix index 1208aa8fced..12fa67c8b01 100644 --- a/nixos/tests/containers-bridge.nix +++ b/nixos/tests/containers-bridge.nix @@ -1,5 +1,3 @@ -# Test for NixOS' container support. - let hostIp = "192.168.0.1"; containerIp = "192.168.0.100/24"; @@ -7,10 +5,10 @@ let containerIp6 = "fc00::2/7"; in -import ./make-test-python.nix ({ pkgs, ...} : { +import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-bridge"; - meta = with pkgs.lib.maintainers; { - maintainers = [ aristid aszlig eelco kampfschlaefer ]; + meta = { + maintainers = with lib.maintainers; [ aristid aszlig eelco kampfschlaefer ]; }; machine = diff --git a/nixos/tests/containers-custom-pkgs.nix b/nixos/tests/containers-custom-pkgs.nix index 1412c32bfb5..c050e49bc29 100644 --- a/nixos/tests/containers-custom-pkgs.nix +++ b/nixos/tests/containers-custom-pkgs.nix @@ -1,4 +1,4 @@ -import ./make-test-python.nix ({ pkgs, lib, ...} : let +import ./make-test-python.nix ({ pkgs, lib, ... }: let customPkgs = pkgs.appendOverlays [ (self: super: { hello = super.hello.overrideAttrs (old: { @@ -8,8 +8,8 @@ import ./make-test-python.nix ({ pkgs, lib, ...} : let in { name = "containers-custom-pkgs"; - meta = with lib.maintainers; { - maintainers = [ adisbladis earvstedt ]; + meta = { + maintainers = with lib.maintainers; [ adisbladis earvstedt ]; }; machine = { config, ... }: { diff --git a/nixos/tests/containers-ephemeral.nix b/nixos/tests/containers-ephemeral.nix index 692554ac0ba..fabf0593f23 100644 --- a/nixos/tests/containers-ephemeral.nix +++ b/nixos/tests/containers-ephemeral.nix @@ -1,7 +1,8 @@ -# Test for NixOS' container support. - -import ./make-test-python.nix ({ pkgs, ...} : { +import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-ephemeral"; + meta = { + maintainers = with lib.maintainers; [ patryk27 ]; + }; machine = { pkgs, ... }: { virtualisation.memorySize = 768; diff --git a/nixos/tests/containers-extra_veth.nix b/nixos/tests/containers-extra_veth.nix index 212f3d0f46c..cbbb2525832 100644 --- a/nixos/tests/containers-extra_veth.nix +++ b/nixos/tests/containers-extra_veth.nix @@ -1,9 +1,7 @@ -# Test for NixOS' container support. - -import ./make-test-python.nix ({ pkgs, ...} : { +import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-extra_veth"; - meta = with pkgs.lib.maintainers; { - maintainers = [ kampfschlaefer ]; + meta = { + maintainers = with lib.maintainers; [ kampfschlaefer ]; }; machine = diff --git a/nixos/tests/containers-hosts.nix b/nixos/tests/containers-hosts.nix index 65a983c42a7..1f24ed1f3c2 100644 --- a/nixos/tests/containers-hosts.nix +++ b/nixos/tests/containers-hosts.nix @@ -1,9 +1,7 @@ -# Test for NixOS' container support. - -import ./make-test-python.nix ({ pkgs, ...} : { +import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-hosts"; - meta = with pkgs.lib.maintainers; { - maintainers = [ montag451 ]; + meta = { + maintainers = with lib.maintainers; [ montag451 ]; }; machine = diff --git a/nixos/tests/containers-imperative.nix b/nixos/tests/containers-imperative.nix index 393b4a5135d..0ff0d3f9545 100644 --- a/nixos/tests/containers-imperative.nix +++ b/nixos/tests/containers-imperative.nix @@ -1,9 +1,7 @@ -# Test for NixOS' container support. - -import ./make-test-python.nix ({ pkgs, ...} : { +import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-imperative"; - meta = with pkgs.lib.maintainers; { - maintainers = [ aristid aszlig eelco kampfschlaefer ]; + meta = { + maintainers = with lib.maintainers; [ aristid aszlig eelco kampfschlaefer ]; }; machine = diff --git a/nixos/tests/containers-ip.nix b/nixos/tests/containers-ip.nix index 0265ed92d41..5abea2dbad9 100644 --- a/nixos/tests/containers-ip.nix +++ b/nixos/tests/containers-ip.nix @@ -1,5 +1,3 @@ -# Test for NixOS' container support. - let webserverFor = hostAddress: localAddress: { inherit hostAddress localAddress; @@ -13,10 +11,10 @@ let }; }; -in import ./make-test-python.nix ({ pkgs, ...} : { +in import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-ipv4-ipv6"; - meta = with pkgs.lib.maintainers; { - maintainers = [ aristid aszlig eelco kampfschlaefer ]; + meta = { + maintainers = with lib.maintainers; [ aristid aszlig eelco kampfschlaefer ]; }; machine = diff --git a/nixos/tests/containers-macvlans.nix b/nixos/tests/containers-macvlans.nix index 9425252cb88..d0f41be8c12 100644 --- a/nixos/tests/containers-macvlans.nix +++ b/nixos/tests/containers-macvlans.nix @@ -1,15 +1,13 @@ -# Test for NixOS' container support. - let # containers IP on VLAN 1 containerIp1 = "192.168.1.253"; containerIp2 = "192.168.1.254"; in -import ./make-test-python.nix ({ pkgs, ...} : { +import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-macvlans"; - meta = with pkgs.lib.maintainers; { - maintainers = [ montag451 ]; + meta = { + maintainers = with lib.maintainers; [ montag451 ]; }; nodes = { diff --git a/nixos/tests/containers-physical_interfaces.nix b/nixos/tests/containers-physical_interfaces.nix index 0b55c3418ed..57bd0eedcc3 100644 --- a/nixos/tests/containers-physical_interfaces.nix +++ b/nixos/tests/containers-physical_interfaces.nix @@ -1,8 +1,7 @@ - -import ./make-test-python.nix ({ pkgs, ...} : { +import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-physical_interfaces"; - meta = with pkgs.lib.maintainers; { - maintainers = [ kampfschlaefer ]; + meta = { + maintainers = with lib.maintainers; [ kampfschlaefer ]; }; nodes = { diff --git a/nixos/tests/containers-portforward.nix b/nixos/tests/containers-portforward.nix index d0be3c7d43e..221a6f50efd 100644 --- a/nixos/tests/containers-portforward.nix +++ b/nixos/tests/containers-portforward.nix @@ -1,5 +1,3 @@ -# Test for NixOS' container support. - let hostIp = "192.168.0.1"; hostPort = 10080; @@ -7,10 +5,10 @@ let containerPort = 80; in -import ./make-test-python.nix ({ pkgs, ...} : { +import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-portforward"; - meta = with pkgs.lib.maintainers; { - maintainers = [ aristid aszlig eelco kampfschlaefer ianwookim ]; + meta = { + maintainers = with lib.maintainers; [ aristid aszlig eelco kampfschlaefer ianwookim ]; }; machine = diff --git a/nixos/tests/containers-reloadable.nix b/nixos/tests/containers-reloadable.nix index 87724691767..876e62c1da9 100644 --- a/nixos/tests/containers-reloadable.nix +++ b/nixos/tests/containers-reloadable.nix @@ -1,7 +1,6 @@ -import ./make-test-python.nix ({ pkgs, lib, ...} : +import ./make-test-python.nix ({ pkgs, lib, ... }: let client_base = { - containers.test1 = { autoStart = true; config = { @@ -16,8 +15,8 @@ let }; in { name = "containers-reloadable"; - meta = with pkgs.lib.maintainers; { - maintainers = [ danbst ]; + meta = { + maintainers = with lib.maintainers; [ danbst ]; }; nodes = { diff --git a/nixos/tests/containers-restart_networking.nix b/nixos/tests/containers-restart_networking.nix index b35552b5b19..e1ad8157b28 100644 --- a/nixos/tests/containers-restart_networking.nix +++ b/nixos/tests/containers-restart_networking.nix @@ -1,5 +1,3 @@ -# Test for NixOS' container support. - let client_base = { networking.firewall.enable = false; @@ -16,11 +14,11 @@ let }; }; }; -in import ./make-test-python.nix ({ pkgs, ...} : +in import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-restart_networking"; - meta = with pkgs.lib.maintainers; { - maintainers = [ kampfschlaefer ]; + meta = { + maintainers = with lib.maintainers; [ kampfschlaefer ]; }; nodes = { diff --git a/nixos/tests/containers-tmpfs.nix b/nixos/tests/containers-tmpfs.nix index 7ebf0d02a24..fd9f9a252ca 100644 --- a/nixos/tests/containers-tmpfs.nix +++ b/nixos/tests/containers-tmpfs.nix @@ -1,9 +1,7 @@ -# Test for NixOS' container support. - -import ./make-test-python.nix ({ pkgs, ...} : { +import ./make-test-python.nix ({ pkgs, lib, ... }: { name = "containers-tmpfs"; - meta = with pkgs.lib.maintainers; { - maintainers = [ ]; + meta = { + maintainers = with lib.maintainers; [ patryk27 ]; }; machine = From 336ef2de99197dd9c07b302685dc9e6282fa5b55 Mon Sep 17 00:00:00 2001 From: Patryk Wychowaniec Date: Fri, 26 Feb 2021 17:14:08 +0100 Subject: [PATCH 48/70] nixos/containers: allow containers with long names to create private networks Launching a container with a private network requires creating a dedicated networking interface for it; name of that interface is derived from the container name itself - e.g. a container named `foo` gets attached to an interface named `ve-foo`. An interface name can span up to IFNAMSIZ characters, which means that a container name must contain at most IFNAMSIZ - 3 - 1 = 11 characters; it's a limit that we validate using a build-time assertion. This limit has been upgraded with Linux 5.8, as it allows for an interface to contain a so-called altname, which can be much longer, while remaining treated as a first-class citizen. Since altnames have been supported natively by systemd for a while now, due diligence on our side ends with dropping the name-assertion on newer kernels. This commit closes #38509. systemd/systemd#14467 systemd/systemd#17220 https://lwn.net/Articles/794289/ --- .../virtualisation/nixos-containers.nix | 12 ++++-- nixos/tests/all-tests.nix | 1 + nixos/tests/containers-names.nix | 37 +++++++++++++++++++ 3 files changed, 46 insertions(+), 4 deletions(-) create mode 100644 nixos/tests/containers-names.nix diff --git a/nixos/modules/virtualisation/nixos-containers.nix b/nixos/modules/virtualisation/nixos-containers.nix index f06977f88fc..3754fe6dac6 100644 --- a/nixos/modules/virtualisation/nixos-containers.nix +++ b/nixos/modules/virtualisation/nixos-containers.nix @@ -271,8 +271,8 @@ let DeviceAllow = map (d: "${d.node} ${d.modifier}") cfg.allowedDevices; }; - system = config.nixpkgs.localSystem.system; + kernelVersion = config.boot.kernelPackages.kernel.version; bindMountOpts = { name, ... }: { @@ -321,7 +321,6 @@ let }; }; - mkBindFlag = d: let flagPrefix = if d.isReadOnly then " --bind-ro=" else " --bind="; mountstr = if d.hostPath != null then "${d.hostPath}:${d.mountPoint}" else "${d.mountPoint}"; @@ -482,11 +481,16 @@ in networking.useDHCP = false; assertions = [ { - assertion = config.privateNetwork -> stringLength name < 12; + assertion = + (builtins.compareVersions kernelVersion "5.8" <= 0) + -> config.privateNetwork + -> stringLength name <= 11; message = '' Container name `${name}` is too long: When `privateNetwork` is enabled, container names can not be longer than 11 characters, because the container's interface name is derived from it. - This might be fixed in the future. See https://github.com/NixOS/nixpkgs/issues/38509 + You should either make the container name shorter or upgrade to a more recent kernel that + supports interface altnames (i.e. at least Linux 5.8 - please see https://github.com/NixOS/nixpkgs/issues/38509 + for details). ''; } ]; diff --git a/nixos/tests/all-tests.nix b/nixos/tests/all-tests.nix index bf094dbe984..02723f88c31 100644 --- a/nixos/tests/all-tests.nix +++ b/nixos/tests/all-tests.nix @@ -72,6 +72,7 @@ in containers-imperative = handleTest ./containers-imperative.nix {}; containers-ip = handleTest ./containers-ip.nix {}; containers-macvlans = handleTest ./containers-macvlans.nix {}; + containers-names = handleTest ./containers-names.nix {}; containers-physical_interfaces = handleTest ./containers-physical_interfaces.nix {}; containers-portforward = handleTest ./containers-portforward.nix {}; containers-reloadable = handleTest ./containers-reloadable.nix {}; diff --git a/nixos/tests/containers-names.nix b/nixos/tests/containers-names.nix new file mode 100644 index 00000000000..9ad2bfb748a --- /dev/null +++ b/nixos/tests/containers-names.nix @@ -0,0 +1,37 @@ +import ./make-test-python.nix ({ pkgs, lib, ... }: { + name = "containers-names"; + meta = { + maintainers = with lib.maintainers; [ patryk27 ]; + }; + + machine = { ... }: { + # We're using the newest kernel, so that we can test containers with long names. + # Please see https://github.com/NixOS/nixpkgs/issues/38509 for details. + boot.kernelPackages = pkgs.linuxPackages_latest; + + containers = let + container = subnet: { + autoStart = true; + privateNetwork = true; + hostAddress = "192.168.${subnet}.1"; + localAddress = "192.168.${subnet}.2"; + config = { }; + }; + + in { + first = container "1"; + second = container "2"; + really-long-name = container "3"; + really-long-long-name-2 = container "4"; + }; + }; + + testScript = '' + machine.wait_for_unit("default.target") + + machine.succeed("ip link show | grep ve-first") + machine.succeed("ip link show | grep ve-second") + machine.succeed("ip link show | grep ve-really-lFYWO") + machine.succeed("ip link show | grep ve-really-l3QgY") + ''; +}) From 32b5534f7333a9ab2caf8bda843e97d3e2376298 Mon Sep 17 00:00:00 2001 From: adisbladis Date: Fri, 26 Feb 2021 19:05:25 +0200 Subject: [PATCH 49/70] emacs.pkgs.pdf-tools: Remove references to dev outputs in epdfinfo --- .../editors/emacs-modes/melpa-packages.nix | 21 ++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/pkgs/applications/editors/emacs-modes/melpa-packages.nix b/pkgs/applications/editors/emacs-modes/melpa-packages.nix index a5e2b7d6052..6a099639d59 100644 --- a/pkgs/applications/editors/emacs-modes/melpa-packages.nix +++ b/pkgs/applications/editors/emacs-modes/melpa-packages.nix @@ -132,9 +132,24 @@ let flycheck-rtags = fix-rtags super.flycheck-rtags; pdf-tools = super.pdf-tools.overrideAttrs (old: { - nativeBuildInputs = [ pkgs.pkg-config ]; - buildInputs = with pkgs; old.buildInputs ++ [ autoconf automake libpng zlib poppler ]; - preBuild = "make server/epdfinfo"; + nativeBuildInputs = [ + pkgs.autoconf + pkgs.automake + pkgs.pkg-config + pkgs.removeReferencesTo + ]; + buildInputs = old.buildInputs ++ [ pkgs.libpng pkgs.zlib pkgs.poppler ]; + preBuild = '' + make server/epdfinfo + remove-references-to \ + -t ${pkgs.stdenv.cc.libc.dev} \ + -t ${pkgs.glib.dev} \ + -t ${pkgs.libpng.dev} \ + -t ${pkgs.poppler.dev} \ + -t ${pkgs.zlib.dev} \ + -t ${pkgs.cairo.dev} \ + server/epdfinfo + ''; recipe = pkgs.writeText "recipe" '' (pdf-tools :repo "politza/pdf-tools" :fetcher github From f78f6cd339730cf0a93b81056d8e7bb393cfb49a Mon Sep 17 00:00:00 2001 From: Ivan Babrou Date: Tue, 9 Feb 2021 23:30:10 -0800 Subject: [PATCH 50/70] llvmPackages_11.openmp: make it compile on aarch64-darwin --- pkgs/development/compilers/llvm/11/openmp.nix | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/pkgs/development/compilers/llvm/11/openmp.nix b/pkgs/development/compilers/llvm/11/openmp.nix index 86e3faee090..c99358cd287 100644 --- a/pkgs/development/compilers/llvm/11/openmp.nix +++ b/pkgs/development/compilers/llvm/11/openmp.nix @@ -1,6 +1,7 @@ { lib , stdenv , fetch +, fetchpatch , cmake , llvm , perl @@ -13,6 +14,15 @@ stdenv.mkDerivation rec { src = fetch pname "0bh5cswgpc79awlq8j5i7hp355adaac7s6zaz0zwp6mkflxli1yi"; + patches = [ + # Fix compilation on aarch64-darwin, remove after the next release. + (fetchpatch { + url = "https://github.com/llvm/llvm-project/commit/7b5254223acbf2ef9cd278070c5a84ab278d7e5f.patch"; + sha256 = "sha256-A+9/IVIoazu68FK5H5CiXcOEYe1Hpp4xTx2mIw7m8Es="; + stripLen = 1; + }) + ]; + nativeBuildInputs = [ cmake perl ]; buildInputs = [ llvm ]; From ef13a2129b59d21410ea04a5fc2e9e26559aa43a Mon Sep 17 00:00:00 2001 From: Ivan Babrou Date: Tue, 9 Feb 2021 10:39:04 -0800 Subject: [PATCH 51/70] libglvnd: disable asm on aarch64-darwin libglvnd itself doesn't know about `aarch64-darwin`, so it tries to use assembly that is not supported by mach-o, failing as a result. --- pkgs/development/libraries/libglvnd/default.nix | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/pkgs/development/libraries/libglvnd/default.nix b/pkgs/development/libraries/libglvnd/default.nix index 1ef63c2406d..3124486f07a 100644 --- a/pkgs/development/libraries/libglvnd/default.nix +++ b/pkgs/development/libraries/libglvnd/default.nix @@ -35,8 +35,11 @@ stdenv.mkDerivation rec { "-Wno-error=array-bounds" ] ++ lib.optional stdenv.cc.isClang "-Wno-error"); - # Indirectly: https://bugs.freedesktop.org/show_bug.cgi?id=35268 - configureFlags = lib.optional stdenv.hostPlatform.isMusl "--disable-tls"; + configureFlags = [] + # Indirectly: https://bugs.freedesktop.org/show_bug.cgi?id=35268 + ++ lib.optional stdenv.hostPlatform.isMusl "--disable-tls" + # Remove when aarch64-darwin asm support is upstream: https://gitlab.freedesktop.org/glvnd/libglvnd/-/issues/216 + ++ lib.optional (stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64) "--disable-asm"; outputs = [ "out" "dev" ]; From c18c9e0a366c93db4b390bc71305f9ac4c27fa56 Mon Sep 17 00:00:00 2001 From: Drew Haven Date: Fri, 26 Feb 2021 09:45:26 -0800 Subject: [PATCH 52/70] cockatrice: 2020-08-23-Release-2.7.5 -> 2021-01-26-Release-2.8.0 --- pkgs/games/cockatrice/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/games/cockatrice/default.nix b/pkgs/games/cockatrice/default.nix index a657913aad7..cb51489de9c 100644 --- a/pkgs/games/cockatrice/default.nix +++ b/pkgs/games/cockatrice/default.nix @@ -4,13 +4,13 @@ mkDerivation rec { pname = "cockatrice"; - version = "2020-08-23-Release-2.7.5"; + version = "2021-01-26-Release-2.8.0"; src = fetchFromGitHub { owner = "Cockatrice"; repo = "Cockatrice"; rev = version; - sha256 = "1yaxm7q0ja3rgx197hh8ynjc6ncc4hm0qdn9v7f0l4fbv0bdpv34"; + sha256 = "0q8ffcklb2b7hcqhy3d2f9kz9aw22pp04pc9y4sslyqmf17pwnz9"; }; buildInputs = [ From 3bd0b03fb3fe9c1a274f69fba39d902490ea81ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20K=C4=85dzio=C5=82ka?= Date: Fri, 26 Feb 2021 18:55:59 +0100 Subject: [PATCH 53/70] tox-node: fix build The custom installPhase got broken as the rust build scripts only provide $releaseDir in postInstall hooks. The default rust installPhase installs the same files, so the custom one is unnecessary. --- pkgs/tools/networking/tox-node/default.nix | 8 -------- 1 file changed, 8 deletions(-) diff --git a/pkgs/tools/networking/tox-node/default.nix b/pkgs/tools/networking/tox-node/default.nix index f250b8d6b65..0b682fa97c1 100644 --- a/pkgs/tools/networking/tox-node/default.nix +++ b/pkgs/tools/networking/tox-node/default.nix @@ -21,14 +21,6 @@ buildRustPackage rec { SODIUM_USE_PKG_CONFIG = "yes"; - installPhase = '' - runHook preInstall - - install -D $releaseDir/tox-node $out/bin/tox-node - - runHook postInstall - ''; - doCheck = false; cargoSha256 = "sha256-kCT2ulB+c2OlsABkyXyzrHfD/G92EPCdTO34FR5oSws="; From 1f810ac9dab42d7d0cd6d07bd3b7f7bcff1bc861 Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 20:18:36 +0100 Subject: [PATCH 54/70] git-annex: update to new version 8.20210223 --- pkgs/development/haskell-modules/configuration-common.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 241312cd911..3aaeafadb19 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -64,7 +64,7 @@ self: super: { name = "git-annex-${super.git-annex.version}-src"; url = "git://git-annex.branchable.com/"; rev = "refs/tags/" + super.git-annex.version; - sha256 = "1m9jfr5b0qwajwwmvcq02263bmnqgcqvpdr06sdwlfz3sxsjfp8r"; + sha256 = "1lvl6i3ym7dyg215fkmslf3rnk29hz7f21jn91y1mghrhch7hvhl"; }; }).override { dbus = if pkgs.stdenv.isLinux then self.dbus else null; From b10ff8e990c34d4c9df44ceb7c6f871708dfea1e Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 20:22:45 +0100 Subject: [PATCH 55/70] hackage2nix: update list of broken packages to fix evaluation errors on Hydra --- .../development/haskell-modules/configuration-hackage2nix.yaml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml index 3a47b2869bf..f12bc20e566 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml @@ -6923,6 +6923,7 @@ broken-packages: - huzzy - hVOIDP - hw-all + - hw-aws-sqs-conduit - hw-ci-assist - hw-dsv - hw-json @@ -9908,9 +9909,11 @@ broken-packages: - servant-zeppelin-server - servant-zeppelin-swagger - server-generic + - serversession - serversession-backend-acid-state - serversession-backend-persistent - serversession-backend-redis + - serversession-frontend-snap - serversession-frontend-yesod - services - ses-html-snaplet From 15834f467316824c9a34458e6f777941da8e3a8f Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 20:57:24 +0100 Subject: [PATCH 56/70] hackage2nix: update list of broken packages to fix evaluation errors on Hydra --- pkgs/development/haskell-modules/configuration-hackage2nix.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml index f12bc20e566..05454bd0b89 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml @@ -9914,6 +9914,7 @@ broken-packages: - serversession-backend-persistent - serversession-backend-redis - serversession-frontend-snap + - serversession-frontend-wai - serversession-frontend-yesod - services - ses-html-snaplet From d2aeeb0d20054a1ba2b9924b11471604488655f7 Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 21:15:17 +0100 Subject: [PATCH 57/70] webkitgtk: remedy the build's confusion about the meaning of "truth" The package could not compile because it did not know the meaning of TRUE and FALSE [1]. So we have to make sure our build environment provides reasonable, sensible definitions to make the build succeed. [1] https://hydra.nixos.org/build/137292531 --- pkgs/development/libraries/webkitgtk/default.nix | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pkgs/development/libraries/webkitgtk/default.nix b/pkgs/development/libraries/webkitgtk/default.nix index 9bf91da6cd9..5e9a990d14e 100644 --- a/pkgs/development/libraries/webkitgtk/default.nix +++ b/pkgs/development/libraries/webkitgtk/default.nix @@ -155,6 +155,9 @@ stdenv.mkDerivation rec { "-DPORT=GTK" "-DUSE_LIBHYPHEN=OFF" "-DUSE_WPE_RENDERER=OFF" + # ensure backward compatibility with the latest version of icu: + # http://linuxfromscratch.org/blfs/view/svn/x/webkitgtk.html + "-DCMAKE_CXX_FLAGS=-DU_DEFINE_FALSE_AND_TRUE=1" ] ++ optionals stdenv.isDarwin [ "-DENABLE_GRAPHICS_CONTEXT_3D=OFF" "-DENABLE_GTKDOC=OFF" From 4e328c8c305ccf945ed60072fc10a4a0a5b4375d Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 21:20:38 +0100 Subject: [PATCH 58/70] haskell-regex-base: drop obsolete patch for ghc-9.0.x --- pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix | 4 ---- 1 file changed, 4 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix index 76f6971917f..55b1d8c9678 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix @@ -99,10 +99,6 @@ self: super: { url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/language-haskell-extract-0.2.4.patch"; sha256 = "0rgzrq0513nlc1vw7nw4km4bcwn4ivxcgi33jly4a7n3c1r32v1f"; }); - regex-base = appendPatch (doJailbreak super.regex-base) (pkgs.fetchpatch { - url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/regex-base-0.94.0.0.patch"; - sha256 = "0k5fglbl7nnhn8400c4cpnflxcbj9p3xi5prl9jfmszr31jwdy5d"; - }); # The test suite depends on ChasingBottoms, which is broken with ghc-9.0.x. unordered-containers = dontCheck super.unordered-containers; From 09dd4a7ea0af7ad172dd7c79d586b9072be939de Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 21:37:22 +0100 Subject: [PATCH 59/70] cabal-install: fix build with ghc-9.0.x --- .../configuration-ghc-9.0.x.nix | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix index 55b1d8c9678..932441f7810 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix @@ -43,19 +43,12 @@ self: super: { unix = null; xhtml = null; - # Take the 3.4.x release candidate. - cabal-install = assert super.cabal-install.version == "3.2.0.0"; - overrideCabal (doJailbreak super.cabal-install) (drv: { - postUnpack = "sourceRoot+=/cabal-install; echo source root reset to $sourceRoot"; - version = "cabal-install-3.4.0.0-rc4"; - editedCabalFile = null; - src = pkgs.fetchgit { - url = "git://github.com/haskell/cabal.git"; - rev = "cabal-install-3.4.0.0-rc4"; - sha256 = "049hllk1d8jid9yg70hmcsdgb0n7hm24p39vavllaahfb0qfimrk"; - }; - executableHaskellDepends = drv.executableHaskellDepends ++ [ self.regex-base self.regex-posix ]; - }); + # Build cabal-install with the compiler's native Cabal. + cabal-install = (doJailbreak super.cabal-install).override { + # Use dontCheck to break test dependency cycles + edit-distance = dontCheck (super.edit-distance.override { random = super.random_1_2_0; }); + random = super.random_1_2_0; + }; # Jailbreaks & Version Updates async = doJailbreak super.async; From c5218b524512fb0cca100a8dcc6b9343ff1761da Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Fri, 26 Feb 2021 12:00:24 +0100 Subject: [PATCH 60/70] rebol/default.nix: remove unused file The rebol attribute has been removed over 4 years ago, so removing the file as will is probably fine. See d6cb238c8ec6b129d46d8281713e6f610ad9e45d. --- .../interpreters/rebol/default.nix | 43 ------------------- 1 file changed, 43 deletions(-) delete mode 100644 pkgs/development/interpreters/rebol/default.nix diff --git a/pkgs/development/interpreters/rebol/default.nix b/pkgs/development/interpreters/rebol/default.nix deleted file mode 100644 index 39a4108e041..00000000000 --- a/pkgs/development/interpreters/rebol/default.nix +++ /dev/null @@ -1,43 +0,0 @@ -{ stdenv, fetchFromGitHub, fetchurl, glibc, libX11, libXt, perl }: - -stdenv.mkDerivation rec { - pname = "rebol-nightly"; - version = "3-alpha"; - src = fetchFromGitHub { - rev = "bd45d0de512ff5953e098301c3d610f6024515d6"; - owner = "earl"; - repo = "r3"; - sha256 = "0pirn6936rxi894xxdvj7xdwlwmmxq2wz36jyjnj26667v2n543c"; - }; - - r3 = fetchurl { - url = "http://rebolsource.net/downloads/experimental/r3-linux-x64-gbf237fc"; - sha256 = "0cm86kn4lcbvyy6pqg67x53y0wz353y0vg7pfqv65agxj1ynxnrx"; - name = "r3"; - }; - - buildInputs = [ glibc libX11 libXt perl ]; - - configurePhase = '' - cp ${r3} make/r3-make - chmod 777 make/r3-make - patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" ./make/r3-make - cd make - perl -pi -e 's#-m32##g' makefile - perl -pi -e 's#sudo .*#echo#g' makefile - make prep - ''; - buildPhase = '' - make - mkdir -p $out/bin - cp r3 $out/bin - ''; - - meta = with lib; { - description = "Relative expression based object language, a language where code is data"; - maintainers = with maintainers; [ vrthra ]; - platforms = [ "x86_64-linux" ]; - license = licenses.asl20; - homepage = "http://www.rebol.com/"; - }; -} From 64187ae13f2639f9dbbf68324c55e769e9caa038 Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 21:48:21 +0100 Subject: [PATCH 61/70] haskell-text-icu: remedy a fatal absence of truth in the build --- pkgs/development/haskell-modules/configuration-common.nix | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 3aaeafadb19..97827fff9ae 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -843,8 +843,11 @@ self: super: { # https://github.com/alphaHeavy/protobuf/issues/34 protobuf = dontCheck super.protobuf; - # https://github.com/bos/text-icu/issues/32 - text-icu = dontCheck super.text-icu; + # Is this package still maintained? https://github.com/haskell/text-icu/issues/30 + text-icu = overrideCabal super.text-icu (drv: { + doCheck = false; # https://github.com/bos/text-icu/issues/32 + configureFlags = ["--ghc-option=-DU_DEFINE_FALSE_AND_TRUE=1"]; # https://github.com/haskell/text-icu/issues/49 + }); # aarch64 and armv7l fixes. happy = if (pkgs.stdenv.hostPlatform.isAarch32 || pkgs.stdenv.hostPlatform.isAarch64) then dontCheck super.happy else super.happy; # Similar to https://ghc.haskell.org/trac/ghc/ticket/13062 From 6e1562761b29813b28b66d601875ddbc1d2024a1 Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 21:49:30 +0100 Subject: [PATCH 62/70] configuration-common: cosmetic --- pkgs/development/haskell-modules/configuration-common.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 97827fff9ae..d954922fcdd 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1610,4 +1610,5 @@ self: super: { }) ]; }); + } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super From c1157b0ba5c694755e2e087af7686b6268d548bc Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 21:53:50 +0100 Subject: [PATCH 63/70] hackage-packages.nix: automatic Haskell package set update This update was generated by hackage2nix v2.16.0-13-gefcfbb2 from Hackage revision https://github.com/commercialhaskell/all-cabal-hashes/commit/20267f89a148bcf4d3c0d3fda0315cf65e499c1f. --- .../haskell-modules/hackage-packages.nix | 226 ++++++++++++++---- 1 file changed, 186 insertions(+), 40 deletions(-) diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index b5ec750478a..4ebf5522bd6 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -37958,8 +37958,8 @@ self: { pname = "base16"; version = "0.3.0.1"; sha256 = "10id9h9mas4kb4kfiz7hhp2hhwnb9mh92pr327c53jqxi4hazgnd"; - revision = "3"; - editedCabalFile = "15r912hb0l92f2cajpq2b6ky4g5qwfmb502nfv1vrg02a1h25xb6"; + revision = "4"; + editedCabalFile = "05fpdw8qkdg7cfyfsnk5npcxqgjgasd8hi096nh6czj96xn4s1b6"; libraryHaskellDepends = [ base bytestring deepseq primitive text text-short ]; @@ -38032,8 +38032,8 @@ self: { pname = "base32"; version = "0.2.0.0"; sha256 = "0xvilxcdcvz07f3qpad35whjd35c9ykicip2cdsd54ysxg71mwzm"; - revision = "1"; - editedCabalFile = "0vsc0fq4rihhx4hicfgy1xpfm1bbq4rnwgfs9qzgmwhslffqy2x5"; + revision = "2"; + editedCabalFile = "0chbgkq65mh6nc48a3hywcv7idfqgb3acv4b7gmz8m6szqq4mx95"; libraryHaskellDepends = [ base bytestring deepseq ghc-byteorder text text-short ]; @@ -38196,6 +38196,8 @@ self: { pname = "base64"; version = "0.4.2.3"; sha256 = "1hdqswxhgjrg8akl5v99hbm02gkpagsbx4i7fxbzdys1k0bj3gxw"; + revision = "1"; + editedCabalFile = "10s7nw79q385f74x76rh8cy0dxfj7idzrj77ng9x32bf8h7jpa6q"; libraryHaskellDepends = [ base bytestring deepseq ghc-byteorder text text-short ]; @@ -43005,6 +43007,31 @@ self: { broken = true; }) {}; + "bitwise-enum_1_0_1_0" = callPackage + ({ mkDerivation, aeson, array, base, deepseq, gauge + , mono-traversable, QuickCheck, test-framework + , test-framework-quickcheck2, vector, wide-word + }: + mkDerivation { + pname = "bitwise-enum"; + version = "1.0.1.0"; + sha256 = "0vmdr8csmxwab7s4nmqdfpqdssivh90fddk94i8wkwj1la867y1z"; + libraryHaskellDepends = [ + aeson array base deepseq mono-traversable vector + ]; + testHaskellDepends = [ + aeson array base deepseq mono-traversable QuickCheck test-framework + test-framework-quickcheck2 vector + ]; + benchmarkHaskellDepends = [ + aeson array base deepseq gauge mono-traversable vector wide-word + ]; + description = "Bitwise operations on bounded enumerations"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "bitx-bitcoin" = callPackage ({ mkDerivation, aeson, base, bytestring, deepseq, directory , doctest, exceptions, hspec, http-client, http-client-tls @@ -45689,7 +45716,6 @@ self: { ]; description = "Haskell source code formatter"; license = lib.licenses.agpl3; - maintainers = with lib.maintainers; [ maralorn ]; }) {}; "broadcast-chan" = callPackage @@ -100269,6 +100295,8 @@ self: { pname = "ghc-byteorder"; version = "4.11.0.0.10"; sha256 = "1dhzd7ygwm7b3hsrlm48iq4p634laby4hf7c8i7xp0c1g64hmrc6"; + revision = "1"; + editedCabalFile = "1qwx6569079a8viq2plkpc1wlqdz8syys6hvx68m051a7zvdwzyl"; libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; doHaddock = false; @@ -101379,6 +101407,19 @@ self: { license = lib.licenses.bsd3; }) {}; + "ghc-trace-events_0_1_2_2" = callPackage + ({ mkDerivation, base, bytestring, tasty-bench, text }: + mkDerivation { + pname = "ghc-trace-events"; + version = "0.1.2.2"; + sha256 = "18vhv99lrfjx6bxww77qxg7gwqmvpylvlrq1bji0hd6mcxxdjn69"; + libraryHaskellDepends = [ base bytestring text ]; + benchmarkHaskellDepends = [ base bytestring tasty-bench ]; + description = "Faster traceEvent and traceMarker, and binary object logging for eventlog"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "ghc-typelits-extra" = callPackage ({ mkDerivation, base, containers, ghc, ghc-prim , ghc-tcplugins-extra, ghc-typelits-knownnat @@ -101766,7 +101807,6 @@ self: { description = "The core of an IDE"; license = lib.licenses.asl20; hydraPlatforms = lib.platforms.none; - maintainers = with lib.maintainers; [ maralorn ]; broken = true; }) {shake-bench = null;}; @@ -101832,7 +101872,6 @@ self: { description = "The core of an IDE"; license = lib.licenses.asl20; hydraPlatforms = lib.platforms.none; - maintainers = with lib.maintainers; [ maralorn ]; broken = true; }) {shake-bench = null;}; @@ -118293,6 +118332,7 @@ self: { testToolDepends = [ ghcide ]; description = "LSP server for GHC"; license = lib.licenses.asl20; + maintainers = with lib.maintainers; [ maralorn ]; }) {}; "haskell-lexer" = callPackage @@ -129212,7 +129252,6 @@ self: { executableHaskellDepends = [ base ]; description = "Source code suggestions"; license = lib.licenses.bsd3; - maintainers = with lib.maintainers; [ maralorn ]; }) {}; "hlint-test" = callPackage @@ -141123,6 +141162,8 @@ self: { testHaskellDepends = [ base ]; description = "AWS SQS conduit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hw-balancedparens" = callPackage @@ -161724,6 +161765,28 @@ self: { license = lib.licenses.bsd3; }) {}; + "lifted-async_0_10_1_3" = callPackage + ({ mkDerivation, async, base, constraints, deepseq, HUnit + , lifted-base, monad-control, mtl, tasty, tasty-bench + , tasty-expected-failure, tasty-hunit, tasty-th, transformers-base + }: + mkDerivation { + pname = "lifted-async"; + version = "0.10.1.3"; + sha256 = "1hml672j8sqxhklxif3nwr8v59a596wwwbllq0zvvmlxcjdzlh7k"; + libraryHaskellDepends = [ + async base constraints lifted-base monad-control transformers-base + ]; + testHaskellDepends = [ + async base HUnit lifted-base monad-control mtl tasty + tasty-expected-failure tasty-hunit tasty-th + ]; + benchmarkHaskellDepends = [ async base deepseq tasty-bench ]; + description = "Run lifted IO operations asynchronously and wait for their results"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "lifted-base" = callPackage ({ mkDerivation, base, criterion, HUnit, monad-control, monad-peel , test-framework, test-framework-hunit, transformers @@ -162817,6 +162880,17 @@ self: { broken = true; }) {blkid = null;}; + "linux-capabilities" = callPackage + ({ mkDerivation, base }: + mkDerivation { + pname = "linux-capabilities"; + version = "0.1.0.0"; + sha256 = "033mnbxg9bzi3cc4js22gpi96g5yslv6sksxdsgab5k075gad85k"; + libraryHaskellDepends = [ base ]; + description = "Linux capabilities Haskell data type"; + license = lib.licenses.asl20; + }) {}; + "linux-cgroup" = callPackage ({ mkDerivation, base, filepath }: mkDerivation { @@ -232352,6 +232426,8 @@ self: { ]; description = "Secure, modular server-side sessions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serversession-backend-acid-state" = callPackage @@ -232442,6 +232518,8 @@ self: { ]; description = "Snap bindings for serversession"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serversession-frontend-wai" = callPackage @@ -232459,6 +232537,8 @@ self: { ]; description = "wai-session bindings for serversession"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serversession-frontend-yesod" = callPackage @@ -252732,6 +252812,18 @@ self: { license = lib.licenses.mit; }) {}; + "tasty-bench_0_2_2" = callPackage + ({ mkDerivation, base, containers, deepseq, tasty }: + mkDerivation { + pname = "tasty-bench"; + version = "0.2.2"; + sha256 = "0x6kg8n778nysv3b7j31bnh62h5srid35nhmvr76bzba4qdgx258"; + libraryHaskellDepends = [ base containers deepseq tasty ]; + description = "Featherlight benchmark framework"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "tasty-dejafu" = callPackage ({ mkDerivation, base, dejafu, random, tagged, tasty }: mkDerivation { @@ -261067,45 +261159,44 @@ self: { }) {}; "too-many-cells" = callPackage - ({ mkDerivation, aeson, base, birch-beer, bytestring, cassava - , colour, containers, deepseq, diagrams, diagrams-cairo - , diagrams-graphviz, diagrams-lib, differential, directory - , diversity, fgl, filepath, find-clumpiness, foldl, graphviz + ({ mkDerivation, aeson, async, async-pool, attoparsec, base + , birch-beer, bytestring, cassava, colour, containers, deepseq + , diagrams, diagrams-cairo, diagrams-graphviz, diagrams-lib + , differential, directory, diversity, fgl, filepath + , find-clumpiness, foldl, graphviz, hashable , hierarchical-clustering, hierarchical-spectral-clustering - , hmatrix, inline-r, lens, managed, matrix-market-attoparsec - , modularity, mtl, optparse-generic, palette, parallel, plots, safe - , scientific, sparse-linear-algebra, spectral-clustering, split - , statistics, streaming, streaming-bytestring, streaming-cassava - , streaming-utils, streaming-with, SVGFonts, temporary - , terminal-progress-bar, text, text-show, transformers, vector - , vector-algorithms, zlib + , hmatrix, hmatrix-svdlibc, inline-r, IntervalMap, lens, managed + , matrix-market-attoparsec, modularity, mtl, mwc-random + , optparse-generic, palette, parallel, plots, process, resourcet + , safe, scientific, sparse-linear-algebra, spectral-clustering + , split, statistics, stm, streaming, streaming-bytestring + , streaming-cassava, streaming-commons, streaming-utils + , streaming-with, SVGFonts, system-filepath, temporary + , terminal-progress-bar, text, text-show, transformers, turtle + , unordered-containers, vector, vector-algorithms, zlib }: mkDerivation { pname = "too-many-cells"; - version = "0.2.2.2"; - sha256 = "091hqg4wxki8v7xkrzmnh1hpm81pif936pbmrzvr5p84sbbyyj91"; + version = "2.1.0.1"; + sha256 = "0clrkr7kxcky6l1gwnbznz013svn7254n8fkkb7mgvn93h94anky"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - aeson base birch-beer bytestring cassava colour containers deepseq - diagrams diagrams-cairo diagrams-graphviz diagrams-lib differential - directory diversity fgl filepath find-clumpiness foldl graphviz + aeson async async-pool attoparsec base birch-beer bytestring + cassava colour containers deepseq diagrams diagrams-cairo + diagrams-graphviz diagrams-lib differential directory diversity fgl + filepath find-clumpiness foldl graphviz hashable hierarchical-clustering hierarchical-spectral-clustering hmatrix - inline-r lens managed matrix-market-attoparsec modularity mtl - palette parallel plots safe scientific sparse-linear-algebra split - statistics streaming streaming-bytestring streaming-cassava - streaming-with SVGFonts temporary text text-show vector - vector-algorithms zlib - ]; - executableHaskellDepends = [ - aeson base birch-beer bytestring cassava colour containers - diagrams-cairo diagrams-lib directory fgl filepath find-clumpiness - graphviz hierarchical-spectral-clustering inline-r lens - matrix-market-attoparsec modularity mtl optparse-generic palette - plots spectral-clustering streaming streaming-bytestring - streaming-utils terminal-progress-bar text text-show transformers - vector + hmatrix-svdlibc inline-r IntervalMap lens managed + matrix-market-attoparsec modularity mtl mwc-random optparse-generic + palette parallel plots process resourcet safe scientific + sparse-linear-algebra spectral-clustering split statistics stm + streaming streaming-bytestring streaming-cassava streaming-commons + streaming-utils streaming-with SVGFonts system-filepath temporary + terminal-progress-bar text text-show transformers turtle + unordered-containers vector vector-algorithms zlib ]; + executableHaskellDepends = [ base optparse-generic ]; description = "Cluster single cells and analyze cell clade relationships"; license = lib.licenses.gpl3; hydraPlatforms = lib.platforms.none; @@ -280951,6 +281042,36 @@ self: { broken = true; }) {}; + "xlsx_0_8_3" = callPackage + ({ mkDerivation, attoparsec, base, base64-bytestring, binary-search + , bytestring, conduit, containers, criterion, data-default, deepseq + , Diff, errors, extra, filepath, groom, lens, mtl, network-uri + , old-locale, raw-strings-qq, safe, smallcheck, tasty, tasty-hunit + , tasty-smallcheck, text, time, transformers, vector, xeno + , xml-conduit, zip-archive, zlib + }: + mkDerivation { + pname = "xlsx"; + version = "0.8.3"; + sha256 = "11g6bfir21wgafnkzzx26r6mz8m39isaz2yqw92k5ymdb1qhs95q"; + libraryHaskellDepends = [ + attoparsec base base64-bytestring binary-search bytestring conduit + containers data-default deepseq errors extra filepath lens mtl + network-uri old-locale safe text time transformers vector xeno + xml-conduit zip-archive zlib + ]; + testHaskellDepends = [ + base bytestring containers Diff groom lens mtl raw-strings-qq + smallcheck tasty tasty-hunit tasty-smallcheck text time vector + xml-conduit + ]; + benchmarkHaskellDepends = [ base bytestring criterion ]; + description = "Simple and incomplete Excel file parser/writer"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "xlsx-tabular" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, data-default , lens, text, xlsx @@ -282658,8 +282779,8 @@ self: { }: mkDerivation { pname = "yahoo-prices"; - version = "0.1.0.1"; - sha256 = "0r0cjhnbskhyfswzv37vfichvpsay2n0pi4bwyis52szddhn4cxx"; + version = "0.1.0.2"; + sha256 = "1zyrj6rq75blzh1v9ja2bbyfaf3c2a6648lcmflmxmd45350ah9f"; libraryHaskellDepends = [ base bytestring cassava lens time vector wreq ]; @@ -287912,6 +288033,31 @@ self: { license = lib.licenses.bsd3; }) {}; + "zip-stream_0_2_1_0" = callPackage + ({ mkDerivation, base, binary, binary-conduit, bytestring, conduit + , conduit-extra, digest, directory, exceptions, filepath, mtl + , primitive, resourcet, text, time, transformers, transformers-base + , zlib + }: + mkDerivation { + pname = "zip-stream"; + version = "0.2.1.0"; + sha256 = "0fx8kj0ijm3555grhdns7agmi084584fh1v0mvkm4x696h1zzvli"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary binary-conduit bytestring conduit conduit-extra digest + exceptions mtl primitive resourcet text time transformers-base zlib + ]; + executableHaskellDepends = [ + base bytestring conduit conduit-extra directory filepath resourcet + text time transformers + ]; + description = "ZIP archive streaming using conduits"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "zipedit" = callPackage ({ mkDerivation, base, directory, mtl, process }: mkDerivation { From 5e401dcd2bdb769438ef4902faeea231beeaf67a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20K=C4=85dzio=C5=82ka?= Date: Fri, 26 Feb 2021 21:59:45 +0100 Subject: [PATCH 64/70] alacritty: fix build Use postInstall instead of installPhase to give the cargo hooks a chance to set $releaseDir. --- .../terminal-emulators/alacritty/default.nix | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/pkgs/applications/terminal-emulators/alacritty/default.nix b/pkgs/applications/terminal-emulators/alacritty/default.nix index b14b874d60c..a7dcd0959d3 100644 --- a/pkgs/applications/terminal-emulators/alacritty/default.nix +++ b/pkgs/applications/terminal-emulators/alacritty/default.nix @@ -90,12 +90,7 @@ rustPlatform.buildRustPackage rec { --replace xdg-open ${xdg-utils}/bin/xdg-open ''; - installPhase = '' - runHook preInstall - - install -D $releaseDir/alacritty $out/bin/alacritty - - '' + ( + postInstall = ( if stdenv.isDarwin then '' mkdir $out/Applications cp -r extra/osx/Alacritty.app $out/Applications @@ -126,8 +121,6 @@ rustPlatform.buildRustPackage rec { tic -xe alacritty,alacritty-direct -o "$terminfo/share/terminfo" extra/alacritty.info mkdir -p $out/nix-support echo "$terminfo" >> $out/nix-support/propagated-user-env-packages - - runHook postInstall ''; dontPatchELF = true; From 48052ca0dd1939beed30dc8c65f541cfa05704fa Mon Sep 17 00:00:00 2001 From: rnhmjoj Date: Fri, 26 Feb 2021 21:37:33 +0100 Subject: [PATCH 65/70] nixos/ksm: remove udev-settle dependency The sysfs file /sys/kernel/mm/ksm/run seems to be available as soon as the kernel has started, so no point in waiting for udev to "settle". If for some reason it doesn't, we let the unit fail explicitly. --- nixos/modules/hardware/ksm.nix | 12 ++++++------ nixos/tests/ksm.nix | 4 ++-- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/nixos/modules/hardware/ksm.nix b/nixos/modules/hardware/ksm.nix index 0938dbdc110..829c3532c45 100644 --- a/nixos/modules/hardware/ksm.nix +++ b/nixos/modules/hardware/ksm.nix @@ -26,13 +26,13 @@ in { systemd.services.enable-ksm = { description = "Enable Kernel Same-Page Merging"; wantedBy = [ "multi-user.target" ]; - after = [ "systemd-udev-settle.service" ]; - script = '' - if [ -e /sys/kernel/mm/ksm ]; then + script = + '' echo 1 > /sys/kernel/mm/ksm/run - ${optionalString (cfg.sleep != null) ''echo ${toString cfg.sleep} > /sys/kernel/mm/ksm/sleep_millisecs''} - fi - ''; + '' + optionalString (cfg.sleep != null) + '' + echo ${toString cfg.sleep} > /sys/kernel/mm/ksm/sleep_millisecs + ''; }; }; } diff --git a/nixos/tests/ksm.nix b/nixos/tests/ksm.nix index 8feccbe6df5..8f84b32020a 100644 --- a/nixos/tests/ksm.nix +++ b/nixos/tests/ksm.nix @@ -1,8 +1,8 @@ -import ./make-test-python.nix ({ pkgs, ...} : +import ./make-test-python.nix ({ lib, ...} : { name = "ksm"; - meta = with pkgs.lib.maintainers; { + meta = with lib.maintainers; { maintainers = [ rnhmjoj ]; }; From f7aa0b4575809a31abd5af15abc783a10a16598d Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 22:28:19 +0100 Subject: [PATCH 66/70] haskell-prettyprinter: disable the freakin' test suite The test suite runs for ages even on fast machines. --- pkgs/development/haskell-modules/configuration-common.nix | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index d954922fcdd..8848203568d 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -969,8 +969,9 @@ self: super: { # musl fixes # dontCheck: use of non-standard strptime "%s" which musl doesn't support; only used in test unix-time = if pkgs.stdenv.hostPlatform.isMusl then dontCheck super.unix-time else super.unix-time; - # dontCheck: printf double rounding behavior - prettyprinter = if pkgs.stdenv.hostPlatform.isMusl then dontCheck super.prettyprinter else super.prettyprinter; + + # The test suite runs for 20+ minutes on a very fast machine, which feels kinda disproportionate. + prettyprinter = dontCheck super.prettyprinter; # Fix with Cabal 2.2, https://github.com/guillaume-nargeot/hpc-coveralls/pull/73 hpc-coveralls = appendPatch super.hpc-coveralls (pkgs.fetchpatch { From 7ee7b5deec517a238a1618202aadbfbc2aadb55b Mon Sep 17 00:00:00 2001 From: zimbatm Date: Fri, 26 Feb 2021 22:52:59 +0100 Subject: [PATCH 67/70] mdsh: 0.5.0 -> 0.6.0 --- .../tor-browser-bundle-bin/default.nix | 28 +++++++++---------- .../tools/documentation/mdsh/default.nix | 6 ++-- 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix b/pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix index 9b0a9078ee5..7857fb4bdf7 100644 --- a/pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix +++ b/pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix @@ -1,11 +1,12 @@ -{ lib, stdenv +{ lib +, stdenv , fetchurl , makeDesktopItem -# Common run-time dependencies + # Common run-time dependencies , zlib -# libxul run-time dependencies + # libxul run-time dependencies , atk , cairo , dbus @@ -27,16 +28,16 @@ , libpulseaudio , apulse -# Media support (implies audio support) + # Media support (implies audio support) , mediaSupport ? true , ffmpeg_3 , gmp -# Pluggable transport dependencies + # Pluggable transport dependencies , python27 -# Wrapper runtime + # Wrapper runtime , coreutils , glibcLocales , gnome3 @@ -44,21 +45,20 @@ , shared-mime-info , gsettings-desktop-schemas -# Hardening + # Hardening , graphene-hardened-malloc -# crashes with intel driver + # crashes with intel driver , useHardenedMalloc ? false -# Whether to disable multiprocess support to work around crashing tabs -# TODO: fix the underlying problem instead of this terrible work-around + # Whether to disable multiprocess support to work around crashing tabs + # TODO: fix the underlying problem instead of this terrible work-around , disableContentSandbox ? true -# Extra preferences + # Extra preferences , extraPrefs ? "" }: with lib; - let libPath = makeLibraryPath libPkgs; @@ -91,7 +91,7 @@ let fteLibPath = makeLibraryPath [ stdenv.cc.cc gmp ]; # Upstream source - version = "10.0.9"; + version = "10.0.12"; lang = "en-US"; @@ -405,7 +405,7 @@ stdenv.mkDerivation rec { changelog = "https://gitweb.torproject.org/builders/tor-browser-build.git/plain/projects/tor-browser/Bundle-Data/Docs/ChangeLog.txt?h=maint-${version}"; platforms = attrNames srcs; maintainers = with maintainers; [ offline matejc thoughtpolice joachifm hax404 cap KarlJoad ]; - hydraPlatforms = []; + hydraPlatforms = [ ]; # MPL2.0+, GPL+, &c. While it's not entirely clear whether # the compound is "libre" in a strict sense (some components place certain # restrictions on redistribution), it's free enough for our purposes. diff --git a/pkgs/development/tools/documentation/mdsh/default.nix b/pkgs/development/tools/documentation/mdsh/default.nix index c8e6cafa27a..68be931aa44 100644 --- a/pkgs/development/tools/documentation/mdsh/default.nix +++ b/pkgs/development/tools/documentation/mdsh/default.nix @@ -2,16 +2,16 @@ rustPlatform.buildRustPackage rec { pname = "mdsh"; - version = "0.5.0"; + version = "0.6.0"; src = fetchFromGitHub { owner = "zimbatm"; repo = "mdsh"; rev = "v${version}"; - sha256 = "02xslf5ssmyklbfsif2d7yk5aaz08n5w0dqiid6v4vlr2mkqcpjl"; + sha256 = "1ki6w3qf8ipcf7ch5120mj16vs7yan8k9zjd25v8x6vbsd1iccgy"; }; - cargoSha256 = "118ykkqlf0x6gcgywx4pg3qawfhfr5q5f51gvrw9s302c1lmgk3g"; + cargoSha256 = "10iqypz8hfyzy1xd78r39z2waa728d97kfnf1bbx8fr4a4pzan7y"; meta = with lib; { description = "Markdown shell pre-processor"; From bdfd50116a9022e1188c1e6a4fe5767bbf65f6e6 Mon Sep 17 00:00:00 2001 From: zimbatm Date: Fri, 26 Feb 2021 22:54:37 +0100 Subject: [PATCH 68/70] Revert "mdsh: 0.5.0 -> 0.6.0" This was pushed by mistake! This reverts commit 7ee7b5deec517a238a1618202aadbfbc2aadb55b. --- .../tor-browser-bundle-bin/default.nix | 28 +++++++++---------- .../tools/documentation/mdsh/default.nix | 6 ++-- 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix b/pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix index 7857fb4bdf7..9b0a9078ee5 100644 --- a/pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix +++ b/pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix @@ -1,12 +1,11 @@ -{ lib -, stdenv +{ lib, stdenv , fetchurl , makeDesktopItem - # Common run-time dependencies +# Common run-time dependencies , zlib - # libxul run-time dependencies +# libxul run-time dependencies , atk , cairo , dbus @@ -28,16 +27,16 @@ , libpulseaudio , apulse - # Media support (implies audio support) +# Media support (implies audio support) , mediaSupport ? true , ffmpeg_3 , gmp - # Pluggable transport dependencies +# Pluggable transport dependencies , python27 - # Wrapper runtime +# Wrapper runtime , coreutils , glibcLocales , gnome3 @@ -45,20 +44,21 @@ , shared-mime-info , gsettings-desktop-schemas - # Hardening +# Hardening , graphene-hardened-malloc - # crashes with intel driver +# crashes with intel driver , useHardenedMalloc ? false - # Whether to disable multiprocess support to work around crashing tabs - # TODO: fix the underlying problem instead of this terrible work-around +# Whether to disable multiprocess support to work around crashing tabs +# TODO: fix the underlying problem instead of this terrible work-around , disableContentSandbox ? true - # Extra preferences +# Extra preferences , extraPrefs ? "" }: with lib; + let libPath = makeLibraryPath libPkgs; @@ -91,7 +91,7 @@ let fteLibPath = makeLibraryPath [ stdenv.cc.cc gmp ]; # Upstream source - version = "10.0.12"; + version = "10.0.9"; lang = "en-US"; @@ -405,7 +405,7 @@ stdenv.mkDerivation rec { changelog = "https://gitweb.torproject.org/builders/tor-browser-build.git/plain/projects/tor-browser/Bundle-Data/Docs/ChangeLog.txt?h=maint-${version}"; platforms = attrNames srcs; maintainers = with maintainers; [ offline matejc thoughtpolice joachifm hax404 cap KarlJoad ]; - hydraPlatforms = [ ]; + hydraPlatforms = []; # MPL2.0+, GPL+, &c. While it's not entirely clear whether # the compound is "libre" in a strict sense (some components place certain # restrictions on redistribution), it's free enough for our purposes. diff --git a/pkgs/development/tools/documentation/mdsh/default.nix b/pkgs/development/tools/documentation/mdsh/default.nix index 68be931aa44..c8e6cafa27a 100644 --- a/pkgs/development/tools/documentation/mdsh/default.nix +++ b/pkgs/development/tools/documentation/mdsh/default.nix @@ -2,16 +2,16 @@ rustPlatform.buildRustPackage rec { pname = "mdsh"; - version = "0.6.0"; + version = "0.5.0"; src = fetchFromGitHub { owner = "zimbatm"; repo = "mdsh"; rev = "v${version}"; - sha256 = "1ki6w3qf8ipcf7ch5120mj16vs7yan8k9zjd25v8x6vbsd1iccgy"; + sha256 = "02xslf5ssmyklbfsif2d7yk5aaz08n5w0dqiid6v4vlr2mkqcpjl"; }; - cargoSha256 = "10iqypz8hfyzy1xd78r39z2waa728d97kfnf1bbx8fr4a4pzan7y"; + cargoSha256 = "118ykkqlf0x6gcgywx4pg3qawfhfr5q5f51gvrw9s302c1lmgk3g"; meta = with lib; { description = "Markdown shell pre-processor"; From a533bbef706ce76649aa8b2703007752562b5cd3 Mon Sep 17 00:00:00 2001 From: Peter Simons Date: Fri, 26 Feb 2021 23:01:18 +0100 Subject: [PATCH 69/70] haskell-brittany: disable the freakin' test suite The test suite runs for ages even on fast machines. --- pkgs/development/haskell-modules/configuration-common.nix | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 8848203568d..4b63f03873b 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -972,6 +972,7 @@ self: super: { # The test suite runs for 20+ minutes on a very fast machine, which feels kinda disproportionate. prettyprinter = dontCheck super.prettyprinter; + brittany = doJailbreak (dontCheck super.brittany); # Outdated upperbound on ghc-exactprint: https://github.com/lspitzner/brittany/issues/342 # Fix with Cabal 2.2, https://github.com/guillaume-nargeot/hpc-coveralls/pull/73 hpc-coveralls = appendPatch super.hpc-coveralls (pkgs.fetchpatch { @@ -1412,10 +1413,6 @@ self: super: { # https://github.com/haskell/haskell-language-server/issues/611 haskell-language-server = dontCheck super.haskell-language-server; - # 2020-02-26: Outdated upperbound on ghc-exactprint - # https://github.com/lspitzner/brittany/issues/342 - brittany = doJailbreak super.brittany; - # 2021-02-11: Jailbreaking because of syntax error on bound revision hls-explicit-imports-plugin = doJailbreak super.hls-explicit-imports-plugin; From 2c9d7ee3694e0fcc5db9199ce3ff24eeb8cacf4a Mon Sep 17 00:00:00 2001 From: Vijay Lulla Date: Fri, 26 Feb 2021 22:42:21 +0000 Subject: [PATCH 70/70] R: 4.0.3 -> 4.0.4 --- pkgs/applications/science/math/R/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/science/math/R/default.nix b/pkgs/applications/science/math/R/default.nix index e41dbb546ea..34ad499ecb9 100644 --- a/pkgs/applications/science/math/R/default.nix +++ b/pkgs/applications/science/math/R/default.nix @@ -12,11 +12,11 @@ assert (!blas.isILP64) && (!lapack.isILP64); stdenv.mkDerivation rec { - name = "R-4.0.3"; + name = "R-4.0.4"; src = fetchurl { url = "https://cran.r-project.org/src/base/R-4/${name}.tar.gz"; - sha256 = "03cypg2qf7v9mq9mr9alz9w5y9m5kdgwbc97bp26pyymg253m609"; + sha256 = "0bl098xcv8v316kqnf43v6gb4kcsv31ydqfm1f7qr824jzb2fgsj"; }; dontUseImakeConfigure = true;